openclaw-plus

A modular super-skill combining developer and web capabilities. Use when the user needs Python execution, package management, git operations, URL fetching, or API interactions. Triggers include requests to run code, install packages, check git status, commit changes, fetch web content, or call APIs. This skill provides a unified workflow for development and web automation tasks.

# 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:

### Pattern