openclaw-plus

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"

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 <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: # 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 <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: # 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}")

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

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

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

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

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!