openclaw-plus

What this skill does

# OpenClaw+ 🚀

A modular super-skill that combines essential developer tools and web capabilities into a unified, powerful workflow.

## Overview

OpenClaw+ integrates seven core capabilities into one streamlined skill:

**Developer Skills:**
- `run_python` - Execute Python code with proper environment management
- `git_status` - Check repository status and track changes
- `git_commit` - Commit changes with meaningful messages
- `install_package` - Install Python packages with dependency handling

**Web Skills:**
- `fetch_url` - Retrieve web content with robust error handling
- `call_api` - Make API requests with authentication and response parsing

This modular design allows you to chain operations efficiently - install packages, run code, fetch data, commit results - all in one cohesive workflow.

---

## When to Use OpenClaw+

Use this skill when the user's request involves:

- Running Python scripts or code snippets
- Installing Python packages (pip, conda, system packages)
- Checking git repository status
- Committing code changes
- Fetching content from URLs
- Making API calls (REST, GraphQL, etc.)
- Combining any of the above in a workflow

**Common patterns:**
- "Install pandas and run this analysis"
- "Fetch data from this API and save it"
- "Check git status and commit my changes"
- "Run this script and call this endpoint"
- "Install these packages, run the code, then commit"

---

## Core Capabilities

### 1. Python Execution (`run_python`)

Execute Python code with proper environment management and output capture.

**Key features:**
- Captures stdout, stderr, and return values
- Handles exceptions gracefully
- Supports multi-line scripts
- Access to installed packages
- Environment variable support

**Usage patterns:**
```python
# Simple execution
result = run_python("print('Hello, world!')")

# With installed packages
run_python("""
import pandas as pd
import numpy as np

data = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
print(data.describe())
""")

# File operations
run_python("""
with open('output.txt', 'w') as f:
    f.write('Results: ...')
""")
```

**Best practices:**
- Always check for syntax errors before execution
- Handle file paths carefully (use absolute paths when needed)
- Capture exceptions and provide clear error messages
- For large scripts, consider creating a .py file first

---

### 2. Package Installation (`install_package`)

Install Python packages with intelligent dependency resolution.

**Key features:**
- Pip package installation
- System package support (apt, brew, etc.)
- Conda environment support
- Dependency conflict detection
- Version pinning

**Usage patterns:**
```bash
# Install single package
install_package("pandas")

# Install specific version
install_package("numpy==1.24.0")

# Install multiple packages
install_package("requests beautifulsoup4 lxml")

# Install from requirements.txt
install_package("-r requirements.txt")

# System packages (when needed)
install_package("libpq-dev", system=True)
```

**Best practices:**
- Always use `--break-system-packages` flag for pip in this environment
- Check if package is already installed before installing
- Handle version conflicts explicitly
- Provide clear feedback on installation success/failure

**Implementation:**
```bash
pip install <package> --break-system-packages
```

---

### 3. Git Status (`git_status`)

Check repository status and track changes.

**Key features:**
- Shows modified, added, deleted files
- Displays untracked files
- Shows current branch
- Indicates if ahead/behind remote
- Supports custom git directories

**Usage patterns:**
```bash
# Check current directory
git_status()

# Check specific directory
git_status("/path/to/repo")

# Parse output for automation
status = git_status()
if "modified:" in status:
    print("Changes detected")
```

**Best practices:**
- Always check status before committing
- Parse output to detect specific changes
- Handle cases where directory isn't a git repo
- Provide context about what changed

**Implementation:**
```bash
git status
git diff --stat
git log -1 --oneline
```

---

### 4. Git Commit (`git_commit`)

Commit changes with meaningful messages following best practices.

**Key features:**
- Conventional commit format support
- Multi-line commit messages
- Automatic staging option
- Commit message validation
- Amend support

**Usage patterns:**
```bash
# Simple commit
git_commit("Add new feature")

# Conventional commit
git_commit("feat: add user authentication")

# Multi-line with description
git_commit("""
feat: add data processing pipeline

- Implement CSV reader
- Add data validation
- Create output formatter
""")

# Stage and commit
git_commit("fix: resolve parsing error", stage_all=True)
```

**Best practices:**
- Use conventional commit format: `type(scope): description`
- Types: feat, fix, docs, style, refactor, test, chore
- Keep first line under 50 characters
- Add detailed description if needed
- Reference issue numbers when applicable

**Implementation:**
```bash
git add <files>  # if stage_all
git commit -m "<message>"
git log -1 --oneline  # confirm commit
```

---

### 5. URL Fetching (`fetch_url`)

Retrieve content from URLs with robust error handling.

**Key features:**
- HTTP/HTTPS support
- Custom headers
- Authentication support
- Redirect following
- Timeout handling
- Response parsing (JSON, XML, HTML, text)

**Usage patterns:**
```python
# Fetch HTML
html = fetch_url("https://example.com")

# Fetch JSON
data = fetch_url("https://api.example.com/data", 
                 parse_json=True)

# With authentication
content = fetch_url("https://api.example.com/protected",
                    headers={"Authorization": "Bearer TOKEN"})

# With custom timeout
content = fetch_url("https://slow-site.com", timeout=30)

# POST request
response = fetch_url("https://api.example.com/submit",
                     method="POST",
                     data={"key": "value"})
```

**Best practices:**
- Always handle network errors gracefully
- Set appropriate timeouts
- Validate URLs before fetching
- Parse response based on content type
- Handle rate limiting
- Respect robots.txt

**Implementation:**
```python
import requests

response = requests.get(url, headers=headers, timeout=timeout)
response.raise_for_status()
return response.text  # or response.json()
```

---

### 6. API Calls (`call_api`)

Make API requests with authentication and response parsing.

**Key features:**
- REST API support
- GraphQL support
- Authentication (Bearer, Basic, API Key)
- Request/response logging
- Error handling with retries
- Response validation

**Usage patterns:**
```python
# Simple GET request
data = call_api("https://api.example.com/users")

# With authentication
data = call_api("https://api.example.com/data",
                auth_token="your-token")

# POST with JSON body
result = call_api("https://api.example.com/create",
                  method="POST",
                  json_data={"name": "John", "age": 30})

# With custom headers
data = call_api("https://api.example.com/endpoint",
                headers={"X-Custom-Header": "value"})

# GraphQL query
result = call_api("https://api.example.com/graphql",
                  method="POST",
                  json_data={
                      "query": "{ users { id name } }"
                  })
```

**Best practices:**
- Validate API keys/tokens before use
- Handle rate limits with exponential backoff
- Parse response format (JSON, XML, etc.)
- Log requests for debugging
- Handle pagination for large datasets
- Validate response schemas
- Use appropriate HTTP methods (GET, POST, PUT, DELETE, PATCH)

**Implementation:**
```python
import requests

headers = {"Authorization": f"Bearer {token}"}
response = requests.request(
    method=method,
    url=url,
    headers=headers,
    json=json_data,
    timeout=30
)
response.raise_for_status()
return response.json()
```

---

## Workflow Patterns

OpenClaw+ shines when combining multiple capabilities:

### Patter