openclaw-plus

---

name: openclaw-plus description: 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. license: Complete terms in LICENSE.txt

---

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:

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

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

pip install  --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:

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

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:

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

git add   # if stage_all
git commit -m ""
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:

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

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:

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

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 1: Data Pipeline

# 1. Install dependencies
install_package("pandas requests")
2. Fetch data from API
data = call_api("https://api.example.com/dataset")
3. Process with Python
run_python("""
import pandas as pd
import json
with open('raw_data.json', 'r') as f:
    data = json.load(f)
df = pd.DataFrame(data)
df_cleaned = df.dropna()
df_cleaned.to_csv('cleaned_data.csv', index=False)
print(f'Processed {len(df_cleaned)} records')
""")
4. Commit results
git_commit("feat: add cleaned dataset")

Pattern 2: Web Scraping & Analysis

# 1. Install scraping tools
install_package("beautifulsoup4 lxml requests")
2. Fetch webpage
html = fetch_url("https://example.com/data-page")
3. Parse and analyze
run_python("""
from bs4 import BeautifulSoup
import json
with open('page.html', 'r') as f:
    soup = BeautifulSoup(f, 'lxml')
data = []
for item in soup.find_all('div', class_='data-item'):
    data.append({
        'title': item.find('h2').text,
        'value': item.find('span', class_='value').text
    })
with open('scraped_data.json', 'w') as f:
    json.dump(data, f, indent=2)
""")
4. Check and commit
git_status()
git_commit("chore: update scraped data")

Pattern 3: API Integration Testing

# 1. Install testing tools
install_package("pytest requests-mock")
2. Run tests
run_python("""
import requests
import json
Test API endpoint
response = requests.get('https://api.example.com/health')
assert response.status_code == 200
Test with authentication
headers = {'Authorization': 'Bearer test-token'}
response = requests.get('https://api.example.com/data', headers=headers)
print(f'Status: {response.status_code}')
print(f'Data: {response.json()}')
""")
3. Commit test results
git_commit("test: add API integration tests")

Pattern 4: Automated Reporting

# 1. Fetch data from multiple sources
api_data = call_api("https://api.example.com/metrics")
web_data = fetch_url("https://example.com/reports/latest")
2. Process and generate report
install_package("matplotlib pandas")
run_python("""
import pandas as pd
import matplotlib.pyplot as plt
import json
with open('api_data.json', 'r') as f:
    data = json.load(f)
df = pd.DataFrame(data)
df['date'] = pd.to_datetime(df['date'])
plt.figure(figsize=(10, 6))
plt.plot(df['date'], df['value'])
plt.title('Metrics Over Time')
plt.savefig('report.png')
print('Report generated')
""")
3. Commit report
git_commit("docs: add automated metrics report")

---

Error Handling

Each capability includes robust error handling:

Python Execution Errors

try:
    result = run_python(code)
except SyntaxError as e:
    print(f"Syntax error: {e}")
except RuntimeError as e:
    print(f"Runtime error: {e}")

Package Installation Errors

# Handle already installed
if package_installed("pandas"):
    print("Package already installed")
else:
    install_package("pandas")
Handle installation failure
try:
    install_package("nonexistent-package")
except Exception as e:
    print(f"Installation failed: {e}")

Git Operation Errors

# Not a git repository
if not is_git_repo():
    print("Not a git repository")
    exit(1)
Nothing to commit
status = git_status()
if "nothing to commit" in status:
    print("No changes to commit")

Network Errors

# Handle timeouts
try:
    data = fetch_url(url, timeout=5)
except TimeoutError:
    print("Request timed out")
Handle HTTP errors
try:
    response = call_api(url)
except requests.HTTPError as e:
    print(f"HTTP error: {e.response.status_code}")

---

Best Practices

1. Environment Management

Always use --break-system-packages for pip

Check if packages are installed before installing

Use virtual environments when appropriate

Document package versions

2. Git Operations

Check status before committing

Use meaningful commit messages

Follow conventional commit format

Stage only relevant files

3. Code Execution

Validate syntax before running

Handle exceptions gracefully

Capture and log output

Clean up temporary files

4. API/Web Requests

Set appropriate timeouts

Handle rate limiting

Validate responses

Log requests for debugging

Respect API usage limits

5. Workflow Composition

Chain operations logically

Handle errors at each step

Provide progress feedback

Document dependencies

---

Security Considerations

API Keys & Credentials

Never hardcode credentials

Use environment variables

Validate before use

Rotate regularly

Code Execution

Validate input code

Sandbox when possible

Limit resource usage

Monitor execution

Web Requests

Validate URLs

Use HTTPS when possible

Handle redirects carefully

Respect robots.txt

---

Debugging & Troubleshooting

Common Issues

Python execution fails:

Check syntax with python -m py_compile script.py

Verify packages are installed

Check file paths

Review error messages

Package installation fails:

Ensure pip is up to date

Check internet connectivity

Verify package name

Review dependencies

Git operations fail:

Verify it's a git repository

Check file permissions

Ensure clean working directory

Review git configuration

API/URL requests fail:

Verify URL is correct

Check authentication

Review rate limits

Check network connectivity

---

Examples

Example 1: Complete Data Pipeline

# User request: "Fetch weather data, analyze it, and commit results"
Step 1: Install dependencies
install_package("requests pandas matplotlib")
Step 2: Fetch data
weather_data = call_api(
    "https://api.weather.com/data",
    auth_token="your-api-key"
)
Step 3: Save and analyze
run_python("""
import pandas as pd
import matplotlib.pyplot as plt
import json
Load data
with open('weather_data.json', 'r') as f:
    data = json.load(f)
Create DataFrame
df = pd.DataFrame(data['forecast'])
df['date'] = pd.to_datetime(df['date'])
Analyze
avg_temp = df['temperature'].mean()
max_temp = df['temperature'].max()
min_temp = df['temperature'].min()
Generate plot
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['temperature'], marker='o')
plt.title('Temperature Forecast')
plt.xlabel('Date')
plt.ylabel('Temperature (°F)')
plt.grid(True)
plt.savefig('temperature_forecast.png')
Save summary
summary = {
    'avg_temp': avg_temp,
    'max_temp': max_temp,
    'min_temp': min_temp,
    'records': len(df)
}
with open('weather_summary.json', 'w') as f:
    json.dump(summary, f, indent=2)
print(f'Analysis complete: {len(df)} records processed')
print(f'Average temperature: {avg_temp:.1f}°F')
""")
Step 4: Commit results
git_status()
git_commit("""
feat: add weather data analysis
Fetch 7-day forecast from API
Generate temperature plot
Create summary statistics
""")

Example 2: Web Scraping & Storage

# User request: "Scrape product data and save to database"
Step 1: Install tools
install_package("beautifulsoup4 lxml requests sqlite3")
Step 2: Fetch webpage
html = fetch_url("https://example-shop.com/products")
Step 3: Parse and store
run_python("""
from bs4 import BeautifulSoup
import sqlite3
import json
Parse HTML
with open('products.html', 'r') as f:
    soup = BeautifulSoup(f, 'lxml')
products = []
for item in soup.find_all('div', class_='product'):
    product = {
        'name': item.find('h3').text.strip(),
        'price': float(item.find('span', class_='price').text.strip('$')),
        'rating': float(item.find('span', class_='rating').text),
        'url': item.find('a')['href']
    }
    products.append(product)
Store in SQLite
conn = sqlite3.connect('products.db')
cursor = conn.cursor()
cursor.execute('''
    CREATE TABLE IF NOT EXISTS products (
        id INTEGER PRIMARY KEY,
        name TEXT,
        price REAL,
        rating REAL,
        url TEXT
    )
''')
for p in products:
    cursor.execute('''
        INSERT INTO products (name, price, rating, url)
        VALUES (?, ?, ?, ?)
    ''', (p['name'], p['price'], p['rating'], p['url']))
conn.commit()
conn.close()
print(f'Scraped and stored {len(products)} products')
""")
Step 4: Commit
git_commit("chore: update product database")

Example 3: API Testing Suite

# User request: "Test our API endpoints and generate report"
Step 1: Install testing framework
install_package("pytest requests pytest-html")
Step 2: Create test file and run
run_python("""
import requests
import json
from datetime import datetime
BASE_URL = "https://api.example.com"
results = []
Test 1: Health check
try:
    response = requests.get(f"{BASE_URL}/health")
    results.append({
        'test': 'Health Check',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Health Check',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Test 2: Authentication
try:
    headers = {'Authorization': 'Bearer test-token'}
    response = requests.get(f"{BASE_URL}/auth/validate", headers=headers)
    results.append({
        'test': 'Authentication',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Authentication',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Test 3: Data retrieval
try:
    response = requests.get(f"{BASE_URL}/data/users")
    data = response.json()
    results.append({
        'test': 'Data Retrieval',
        'status': response.status_code,
        'passed': response.status_code == 200 and len(data) > 0,
        'records': len(data) if response.status_code == 200 else 0,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Data Retrieval',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Generate report
report = {
    'timestamp': datetime.now().isoformat(),
    'total_tests': len(results),
    'passed': sum(1 for r in results if r.get('passed')),
    'failed': sum(1 for r in results if not r.get('passed')),
    'results': results
}
with open('api_test_report.json', 'w') as f:
    json.dump(report, f, indent=2)
print(f"Tests complete: {report['passed']}/{report['total_tests']} passed")
for r in results:
    status = '✓' if r.get('passed') else '✗'
    print(f"{status} {r['test']}")
""")
Step 3: Check and commit
git_status()
git_commit("test: add API endpoint tests")

---

Integration with Other Skills

OpenClaw+ works seamlessly with other skills:

With docx skill:

# Generate data, then create report
call_api("https://api.example.com/stats")
run_python("process_stats.py")
Then use docx skill to create formatted report

With xlsx skill:

# Fetch data, process with Python, export to Excel
fetch_url("https://data-source.com/raw.csv")
run_python("clean_and_transform.py")
Then use xlsx skill to create formatted spreadsheet

With pptx skill:

# Generate charts and data visualizations
install_package("matplotlib seaborn")
run_python("generate_charts.py")
Then use pptx skill to create presentation

---

Quick Reference

Python Execution

run_python(code_string)

Package Management

install_package("package_name")
install_package("package==1.0.0")
install_package("-r requirements.txt")

Git Operations

git_status()
git_commit("message")
git_commit("message", stage_all=True)

Web Requests

fetch_url(url, timeout=30)
call_api(url, method="GET", auth_token="token")

---

Conclusion

OpenClaw+ provides a unified, powerful toolkit for development and web automation workflows. By combining Python execution, package management, git operations, and web capabilities, it enables complex multi-step workflows with a single cohesive skill.

Key strengths:

✅ Modular design - use only what you need

✅ Error handling - robust failure recovery

✅ Workflow composition - chain operations easily

✅ Production-ready - follows best practices

✅ Well-documented - clear examples and patterns

Use OpenClaw+ whenever your task involves code execution, package management, version control, or web interactions - or any combination thereof!

Example 1: Complete Data Pipeline

# User request: "Fetch weather data, analyze it, and commit results"
Step 1: Install dependencies
install_package("requests pandas matplotlib")
Step 2: Fetch data
weather_data = call_api(
    "https://api.weather.com/data",
    auth_token="your-api-key"
)
Step 3: Save and analyze
run_python("""
import pandas as pd
import matplotlib.pyplot as plt
import json
Load data
with open('weather_data.json', 'r') as f:
    data = json.load(f)
Create DataFrame
df = pd.DataFrame(data['forecast'])
df['date'] = pd.to_datetime(df['date'])
Analyze
avg_temp = df['temperature'].mean()
max_temp = df['temperature'].max()
min_temp = df['temperature'].min()
Generate plot
plt.figure(figsize=(12, 6))
plt.plot(df['date'], df['temperature'], marker='o')
plt.title('Temperature Forecast')
plt.xlabel('Date')
plt.ylabel('Temperature (°F)')
plt.grid(True)
plt.savefig('temperature_forecast.png')
Save summary
summary = {
    'avg_temp': avg_temp,
    'max_temp': max_temp,
    'min_temp': min_temp,
    'records': len(df)
}
with open('weather_summary.json', 'w') as f:
    json.dump(summary, f, indent=2)
print(f'Analysis complete: {len(df)} records processed')
print(f'Average temperature: {avg_temp:.1f}°F')
""")
Step 4: Commit results
git_status()
git_commit("""
feat: add weather data analysis
Fetch 7-day forecast from API
Generate temperature plot
Create summary statistics
""")

Example 2: Web Scraping & Storage

# User request: "Scrape product data and save to database"
Step 1: Install tools
install_package("beautifulsoup4 lxml requests sqlite3")
Step 2: Fetch webpage
html = fetch_url("https://example-shop.com/products")
Step 3: Parse and store
run_python("""
from bs4 import BeautifulSoup
import sqlite3
import json
Parse HTML
with open('products.html', 'r') as f:
    soup = BeautifulSoup(f, 'lxml')
products = []
for item in soup.find_all('div', class_='product'):
    product = {
        'name': item.find('h3').text.strip(),
        'price': float(item.find('span', class_='price').text.strip('$')),
        'rating': float(item.find('span', class_='rating').text),
        'url': item.find('a')['href']
    }
    products.append(product)
Store in SQLite
conn = sqlite3.connect('products.db')
cursor = conn.cursor()
cursor.execute('''
    CREATE TABLE IF NOT EXISTS products (
        id INTEGER PRIMARY KEY,
        name TEXT,
        price REAL,
        rating REAL,
        url TEXT
    )
''')
for p in products:
    cursor.execute('''
        INSERT INTO products (name, price, rating, url)
        VALUES (?, ?, ?, ?)
    ''', (p['name'], p['price'], p['rating'], p['url']))
conn.commit()
conn.close()
print(f'Scraped and stored {len(products)} products')
""")
Step 4: Commit
git_commit("chore: update product database")

Example 3: API Testing Suite

# User request: "Test our API endpoints and generate report"
Step 1: Install testing framework
install_package("pytest requests pytest-html")
Step 2: Create test file and run
run_python("""
import requests
import json
from datetime import datetime
BASE_URL = "https://api.example.com"
results = []
Test 1: Health check
try:
    response = requests.get(f"{BASE_URL}/health")
    results.append({
        'test': 'Health Check',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Health Check',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Test 2: Authentication
try:
    headers = {'Authorization': 'Bearer test-token'}
    response = requests.get(f"{BASE_URL}/auth/validate", headers=headers)
    results.append({
        'test': 'Authentication',
        'status': response.status_code,
        'passed': response.status_code == 200,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Authentication',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Test 3: Data retrieval
try:
    response = requests.get(f"{BASE_URL}/data/users")
    data = response.json()
    results.append({
        'test': 'Data Retrieval',
        'status': response.status_code,
        'passed': response.status_code == 200 and len(data) > 0,
        'records': len(data) if response.status_code == 200 else 0,
        'response_time': response.elapsed.total_seconds()
    })
except Exception as e:
    results.append({
        'test': 'Data Retrieval',
        'status': 'Error',
        'passed': False,
        'error': str(e)
    })
Generate report
report = {
    'timestamp': datetime.now().isoformat(),
    'total_tests': len(results),
    'passed': sum(1 for r in results if r.get('passed')),
    'failed': sum(1 for r in results if not r.get('passed')),
    'results': results
}
with open('api_test_report.json', 'w') as f:
    json.dump(report, f, indent=2)
print(f"Tests complete: {report['passed']}/{report['total_tests']} passed")
for r in results:
    status = '✓' if r.get('passed') else '✗'
    print(f"{status} {r['test']}")
""")
Step 3: Check and commit
git_status()
git_commit("test: add API endpoint tests")

---

1. Environment Management

Always use --break-system-packages for pip

Check if packages are installed before installing

Use virtual environments when appropriate

Document package versions

2. Git Operations

Check status before committing

Use meaningful commit messages

Follow conventional commit format

Stage only relevant files

3. Code Execution

Validate syntax before running

Handle exceptions gracefully

Capture and log output

Clean up temporary files

4. API/Web Requests

Set appropriate timeouts

Handle rate limiting

Validate responses

Log requests for debugging

Respect API usage limits

5. Workflow Composition

Chain operations logically

Handle errors at each step

Provide progress feedback

Document dependencies

---