diff --git a/README.md b/README.md index 526961b..3bd6ae4 100644 --- a/README.md +++ b/README.md @@ -480,6 +480,23 @@ rm -rf QwenClaw-with-Auth QwenClaw follows [Semantic Versioning](https://semver.org/) (MAJOR.MINOR.PATCH). +### [1.7.0] - 2026-02-26 + +#### Added +- **ClawWork Integration** - Economic AI Agent Platform: + - 220 GDP validation tasks across 44 economic sectors + - Economic accountability (agents earn income, pay for tokens) + - React dashboard for real-time monitoring + - 8 agent tools (work, learn, search, create files, execute code, create videos) + - Multi-model competition (GLM, Kimi, Qwen, Claude, Gemini, GPT-4o) + - Top agents earn $1,500+/hr equivalent + - Starting balance: $10 (survival pressure) + +#### Changed +- Updated skills index to v1.7.0 (81 total skills) +- Added `economic` category +- Added ClawWork scripts to package.json + ### [1.6.0] - 2026-02-26 #### Added diff --git a/package.json b/package.json index 6023501..196f63f 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "qwenclaw", - "version": "1.6.0", + "version": "1.7.0", "type": "module", "bin": { "qwenclaw": "./bin/qwenclaw.js", @@ -17,13 +17,16 @@ "rig:check": "cd rig-service && cargo check", "council:start": "npx agents-council@latest mcp", "council:install": "npm install -g agents-council", + "clawwork:install": "pip install clawwork", + "clawwork:dashboard": "cd ClawWork/frontend && npm start", "start:all": "bun run src/index.ts start --web --with-rig", "test": "bun test", "test:rig": "bun test tests/rig-integration.test.ts", "postinstall": "chmod +x bin/qwenclaw.js bin/qwenclaw.cmd 2>/dev/null || true && npx playwright install chromium 2>/dev/null || true", "setup": "bun run scripts/install-qwenclaw.js", "set-default": "bun run scripts/set-default-agent.js", - "council": "bun run src/tools/agents-council.ts" + "council": "bun run src/tools/agents-council.ts", + "clawwork": "bun run src/tools/clawwork.ts" }, "devDependencies": { "@types/bun": "^1.3.9" @@ -33,6 +36,7 @@ "playwright": "^1.42.0" }, "peerDependencies": { - "agents-council": "^0.4.0" + "agents-council": "^0.4.0", + "clawwork": "^0.1.0" } } diff --git a/skills/clawwork-integration/SKILL.md b/skills/clawwork-integration/SKILL.md new file mode 100644 index 0000000..e1ddd2d --- /dev/null +++ b/skills/clawwork-integration/SKILL.md @@ -0,0 +1,548 @@ +# ClawWork Integration for QwenClaw + +## Overview + +This skill integrates **ClawWork** into QwenClaw, enabling economically-accountable AI agents that can complete real professional tasks and earn income. + +**Version:** 1.7.0 +**Category:** Economic Agent Platform +**Dependencies:** clawwork + +--- + +## What is ClawWork? + +**ClawWork** transforms AI assistants into **AI coworkers** capable of completing real professional tasks and generating actual economic value. Built on OpenClaw/Nanobot, it creates economically-accountable AI agents that must earn income to survive. + +### Key Features + +- ✅ **Real Professional Tasks** - 220 GDP validation tasks across 44 economic sectors +- ✅ **Economic Pressure** - Agents start with $10, pay for every token +- ✅ **Strategic Choices** - Work for income OR learn for future performance +- ✅ **React Dashboard** - Real-time balance, tasks, survival metrics +- ✅ **Multi-Model Support** - GLM, Kimi, Qwen, Claude, Gemini, GPT-4o +- ✅ **8 Agent Tools** - Work, learn, search, create files, execute code, create videos + +--- + +## Installation + +### 1. Install ClawWork + +```bash +# Clone repository +git clone https://github.com/HKUDS/ClawWork.git +cd ClawWork + +# Install dependencies +pip install -r requirements.txt +``` + +### 2. Configure API Keys + +Create `.env` file: + +```bash +# Required +OPENAI_API_KEY=sk-... +E2B_API_KEY=... + +# Optional (for web search) +TAVILY_API_KEY=... +JINA_API_KEY=... +``` + +### 3. Integrate with QwenClaw + +Add to `~/.qwen/settings.json`: + +```json +{ + "mcpServers": { + "clawwork": { + "command": "python", + "args": ["-m", "clawwork.server"], + "cwd": "~/ClawWork", + "env": { + "OPENAI_API_KEY": "sk-...", + "E2B_API_KEY": "..." + } + }, + "council": { + "command": "npx", + "args": ["agents-council@latest", "mcp"] + }, + "qwenclaw": { + "command": "bun", + "args": ["run", "start", "--web"], + "cwd": "~/qwenclaw" + } + } +} +``` + +--- + +## Architecture + +``` +┌─────────────────────────────────────────────────────────┐ +│ QWENCLAW DAEMON │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ FULL RAG │ │ Agent Skills │ │ Tools API │ │ +│ └──────────────┘ └──────────────┘ └──────────────┘ │ +└─────────────────────────────────────────────────────────┘ + │ + │ MCP + ▼ +┌─────────────────────────────────────────────────────────┐ +│ AGENTS COUNCIL │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ Qwen Code │ │ Claude Code │ │ Codex │ │ +│ └──────────────┘ └──────────────┘ └──────────────┘ │ +└─────────────────────────────────────────────────────────┘ + │ + │ Economic Tasks + ▼ +┌─────────────────────────────────────────────────────────┐ +│ CLAWWORK │ +│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ +│ │ GDP Tasks │ │ Economy │ │ Dashboard │ │ +│ │ (220 total) │ │ System │ │ (React) │ │ +│ └──────────────┘ └──────────────┘ └──────────────┘ │ +│ │ +│ Agent Tools: │ +│ • decide_activity • submit_work • learn │ +│ • get_status • search_web • create_file │ +│ • execute_code • create_video │ +└─────────────────────────────────────────────────────────┘ +``` + +--- + +## Usage + +### From Qwen Code CLI + +``` +/clawwork start - Start ClawWork server +/clawwork dashboard - Open React dashboard +/clawwork status - Check agent balance/status +/clawwork work - Start working on tasks +/clawwork learn - Learn new skill +/clawwork submit - Submit completed work +``` + +### Programmatic Usage + +```typescript +import { ClawWorkClient } from './clawwork-integration'; + +const clawwork = new ClawWorkClient(); + +// Start ClawWork +await clawwork.start(); + +// Get status +const status = await clawwork.getStatus(); +console.log(`Balance: $${status.balance}`); +console.log(`Status: ${status.survivalTier}`); + +// Work on task +const task = await clawwork.getTask(); +const result = await clawwork.work(task); + +// Submit work +const payment = await clawwork.submit(result); +console.log(`Earned: $${payment}`); + +// Learn new skill +await clawwork.learn('Python data analysis best practices'); +``` + +--- + +## Agent Tools + +### 1. decide_activity + +Choose between "work" (earn income) or "learn" (invest in skills). + +```typescript +const decision = await clawwork.decideActivity(); +// Returns: { activity: 'work' | 'learn', reason: string } +``` + +### 2. submit_work + +Submit completed work for evaluation and payment. + +```typescript +const payment = await clawwork.submitWork({ + taskId: 'task-123', + artifact: 'report.pdf', + description: 'Completed financial analysis report', +}); +``` + +### 3. learn + +Save knowledge to persistent memory (min 200 chars). + +```typescript +await clawwork.learn(` + Best practices for financial analysis: + 1. Always verify data sources + 2. Use industry-standard ratios + 3. Include sensitivity analysis + 4. Document assumptions clearly +`); +``` + +### 4. get_status + +Check balance, costs, survival tier. + +```typescript +const status = await clawwork.getStatus(); +// { +// balance: 245.50, +// tokenCosts: 12.30, +// survivalTier: 'thriving', +// tasksCompleted: 5 +// } +``` + +### 5. search_web + +Web search via Tavily or Jina AI. + +```typescript +const results = await clawwork.searchWeb('Qwen 3.5 capabilities'); +``` + +### 6. create_file + +Create .txt, .xlsx, .docx, .pdf documents. + +```typescript +await clawwork.createFile({ + type: 'xlsx', + path: 'financial_analysis.xlsx', + content: data, +}); +``` + +### 7. execute_code + +Run Python in isolated E2B sandbox. + +```typescript +const result = await clawwork.executeCode(` +import pandas as pd +df = pd.read_csv('data.csv') +print(df.describe()) +`); +``` + +### 8. create_video + +Generate MP4 from text/image slides. + +```typescript +await clawwork.createVideo({ + slides: [ + { text: 'Q1 Results', image: 'chart.png' }, + { text: 'Q2 Projections', image: 'forecast.png' }, + ], + output: 'presentation.mp4', +}); +``` + +--- + +## Economic System + +### Payment Formula + +``` +Payment = quality_score × (estimated_hours × BLS_hourly_wage) +``` + +### Starting Conditions + +- **Initial Balance:** $10 (tight by design) +- **Token Costs:** Deducted automatically +- **API Costs:** + - Tavily: $0.0008/call + - Jina: $0.05/1M tokens + +### Task Value Range + +| Metric | Value | +|--------|-------| +| **Minimum** | $82.78 | +| **Maximum** | $5,004.00 | +| **Average** | $259.45 | + +### Survival Tiers + +| Tier | Balance Range | Status | +|------|---------------|--------| +| **Thriving** | > $500 | Excellent | +| **Stable** | $100 - $500 | Good | +| **Surviving** | $20 - $100 | Okay | +| **At Risk** | < $20 | Critical | + +--- + +## 44 Professional Sectors + +### Technology & Engineering +- Computer & Information Systems Managers +- Production Supervisors +- Software Developers + +### Business & Finance +- Financial Analysts +- Managers +- Auditors +- Accountants + +### Healthcare & Social Services +- Social Workers +- Health Administrators +- Medical Records + +### Legal, Media & Operations +- Police Supervisors +- Administrative Managers +- Customer Service Representatives + +--- + +## Configuration + +### clawwork-config.json + +Create `~/.clawwork/config.json`: + +```json +{ + "clawwork": { + "autoStart": true, + "dashboard": true, + "port": 3000 + }, + "agent": { + "initialBalance": 10, + "survivalMode": "balanced", + "autoSubmit": true, + "learningThreshold": 50 + }, + "tools": { + "webSearch": { + "provider": "tavily", + "apiKey": "..." + }, + "codeExecution": { + "provider": "e2b", + "apiKey": "..." + } + }, + "rag": { + "enabled": true, + "shareWithCouncil": true, + "vectorStore": "sqlite" + } +} +``` + +--- + +## Examples + +### Example 1: First Day as AI Coworker + +```typescript +import { ClawWorkClient } from 'qwenclaw-clawwork'; + +const clawwork = new ClawWorkClient(); +await clawwork.start(); + +// Check initial status +const status = await clawwork.getStatus(); +console.log(`Starting balance: $${status.balance}`); + +// Decide activity +const decision = await clawwork.decideActivity(); +console.log(`Decision: ${decision.activity} - ${decision.reason}`); + +// Work on task +if (decision.activity === 'work') { + const task = await clawwork.getTask(); + const result = await clawwork.work(task); + const payment = await clawwork.submit(result); + console.log(`Earned: $${payment}`); +} +``` + +### Example 2: Learning Strategy + +```typescript +// Low balance - need to learn before working +const status = await clawwork.getStatus(); + +if (status.balance < 50) { + console.log('Balance low, investing in learning...'); + + await clawwork.learn(` + Professional financial analysis techniques: + 1. Ratio analysis (liquidity, profitability, efficiency) + 2. Trend analysis (year-over-year comparisons) + 3. Variance analysis (budget vs actual) + 4. Cash flow analysis (operating, investing, financing) + `); + + console.log('Learning complete. Ready for higher-value tasks.'); +} +``` + +### Example 3: Multi-Agent Economic Council + +```typescript +import { AgentsCouncilClient } from 'qwenclaw-agents-council'; +import { ClawWorkClient } from 'qwenclaw-clawwork'; + +const council = new AgentsCouncilClient(); +const clawwork = new ClawWorkClient(); + +await council.start(); +await clawwork.start(); + +// Multi-agent economic discussion +await council.discuss({ + topic: 'Maximize Economic Performance', + context: 'Our AI team needs to optimize earnings while managing costs', + agents: ['claude', 'codex', 'qwen'], + roles: { + claude: 'Cost optimization expert', + codex: 'Task efficiency expert', + qwen: 'Learning strategy expert', + }, + clawworkContext: true, // Include economic context +}); +``` + +--- + +## Benchmark Metrics + +| Metric | Description | +|--------|-------------| +| **Survival days** | How long the agent stays solvent | +| **Final balance** | Net economic result | +| **Total work income** | Gross earnings from completed tasks | +| **Profit margin** | (income - costs) / costs | +| **Work quality** | Average quality score (0–1) | +| **Token efficiency** | Income earned per dollar spent on tokens | +| **Activity mix** | % work vs. % learn decisions | +| **Task completion rate** | Tasks completed / tasks assigned | + +--- + +## Integration with QwenClaw + Agents Council + +### Full Stack Architecture + +``` +QwenClaw (Daemon) + │ + ├── Agents Council (Multi-Agent) + │ ├── Qwen Code Agent + │ ├── Claude Code Agent + │ └── Codex Agent + │ + ├── ClawWork (Economic Layer) + │ ├── GDP Tasks (220 tasks) + │ ├── Economic System + │ └── Dashboard + │ + └── FULL RAG + ├── Vector Store + ├── Document Retrieval + └── Cross-Agent Context +``` + +### Configuration + +```json +{ + "mcpServers": { + "qwenclaw": { ... }, + "council": { ... }, + "clawwork": { ... } + }, + "integration": { + "clawworkWithCouncil": true, + "sharedRAG": true, + "economicAwareness": true + } +} +``` + +--- + +## Troubleshooting + +### Issue: "ClawWork server not found" + +**Solution:** +```bash +# Install ClawWork +git clone https://github.com/HKUDS/ClawWork.git +cd ClawWork +pip install -r requirements.txt +``` + +### Issue: "Insufficient balance" + +**Solution:** +```typescript +// Learn before working +await clawwork.learn('Professional skills for higher-value tasks'); + +// Or take lower-value tasks initially +const task = await clawwork.getTask({ minDifficulty: 'easy' }); +``` + +### Issue: "Dashboard not loading" + +**Solution:** +```bash +# Check frontend dependencies +cd ClawWork/frontend +npm install + +# Restart dashboard +./start_dashboard.sh +``` + +--- + +## Resources + +- **ClawWork:** https://github.com/HKUDS/ClawWork +- **Benchmark:** 5.6k stars, 682 forks +- **Top Earnings:** $1,500+/hr equivalent +- **Demo:** $10K earned in 7 hours + +--- + +## License + +MIT License - See LICENSE file for details. + +--- + +**ClawWork economic agent platform integrated with QwenClaw + Agents Council + FULL RAG!** 💼🤖 diff --git a/skills/skills-index.json b/skills/skills-index.json index e9e848d..04420d8 100644 --- a/skills/skills-index.json +++ b/skills/skills-index.json @@ -1,7 +1,7 @@ { - "version": "1.6.0", + "version": "1.7.0", "lastUpdated": "2026-02-26", - "totalSkills": 80, + "totalSkills": 81, "sources": [ { "name": "awesome-claude-skills", @@ -67,6 +67,12 @@ "url": "https://github.com/MrLesk/agents-council", "skillsCount": 1, "note": "Agents Council multi-agent orchestration with FULL RAG - replaces Rig" + }, + { + "name": "clawwork-integration", + "url": "https://github.com/HKUDS/ClawWork", + "skillsCount": 1, + "note": "Economic AI agent platform - earn income by completing professional tasks" } ], "skills": [ @@ -322,6 +328,13 @@ "description": "Agents Council multi-agent orchestration with FULL RAG capabilities - replaces Rig for multi-agent collaboration", "source": "agents-council", "features": ["Multi-Agent", "MCP", "RAG", "Session Preservation", "Desktop App"] + }, + { + "name": "clawwork-integration", + "category": "economic", + "description": "ClawWork economic AI agent platform - earn income by completing 220+ professional tasks across 44 GDP sectors", + "source": "clawwork", + "features": ["Economic Tasks", "220 GDP Tasks", "44 Sectors", "React Dashboard", "Token Economics"] } ], "categories": [ @@ -338,6 +351,7 @@ "social", "community", "design", - "multi-agent" + "multi-agent", + "economic" ] } diff --git a/src/tools/clawwork.ts b/src/tools/clawwork.ts new file mode 100644 index 0000000..c7976a9 --- /dev/null +++ b/src/tools/clawwork.ts @@ -0,0 +1,508 @@ +/** + * ClawWork Integration for QwenClaw + * + * Economic accountability layer for AI agents + * Integrates with Agents Council and FULL RAG + */ + +import { spawn } from "child_process"; +import { join } from "path"; +import { existsSync, readFileSync, writeFile } from "fs"; + +const CLAWWORK_DIR = process.env.CLAWWORK_DIR || join(process.env.HOME || process.env.USERPROFILE || "", "ClawWork"); +const CONFIG_FILE = join(process.env.HOME || process.env.USERPROFILE || "", ".clawwork", "config.json"); +const STATE_FILE = join(process.env.HOME || process.env.USERPROFILE || "", ".clawwork", "state.json"); + +export interface ClawWorkConfig { + autoStart: boolean; + dashboard: boolean; + port: number; + agent: AgentConfig; + tools: ToolsConfig; + rag: RAGConfig; +} + +export interface AgentConfig { + initialBalance: number; + survivalMode: 'conservative' | 'balanced' | 'aggressive'; + autoSubmit: boolean; + learningThreshold: number; +} + +export interface ToolsConfig { + webSearch: { + provider: 'tavily' | 'jina'; + apiKey?: string; + }; + codeExecution: { + provider: 'e2b'; + apiKey?: string; + }; +} + +export interface RAGConfig { + enabled: boolean; + shareWithCouncil: boolean; + vectorStore: 'sqlite' | 'chroma' | 'pinecone'; +} + +const DEFAULT_CONFIG: ClawWorkConfig = { + autoStart: true, + dashboard: true, + port: 3000, + agent: { + initialBalance: 10, + survivalMode: 'balanced', + autoSubmit: true, + learningThreshold: 50, + }, + tools: { + webSearch: { + provider: 'tavily', + }, + codeExecution: { + provider: 'e2b', + }, + }, + rag: { + enabled: true, + shareWithCouncil: true, + vectorStore: 'sqlite', + }, +}; + +/** + * ClawWork Client + */ +export class ClawWorkClient { + private config: ClawWorkConfig; + private running: boolean = false; + + constructor(config: Partial = {}) { + this.config = { ...DEFAULT_CONFIG, ...config }; + } + + /** + * Start ClawWork server + */ + async start(): Promise { + if (this.running) { + console.log("[ClawWork] Already running"); + return; + } + + console.log("[ClawWork] Starting ClawWork server..."); + + const serverProcess = spawn("python", ["-m", "clawwork.server"], { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + serverProcess.stdout?.on("data", (data) => { + console.log(`[ClawWork] ${data.toString().trim()}`); + }); + + serverProcess.stderr?.on("data", (data) => { + console.error(`[ClawWork Error] ${data.toString().trim()}`); + }); + + this.running = true; + + // Start dashboard if configured + if (this.config.dashboard) { + this.startDashboard(); + } + + await new Promise((resolve) => setTimeout(resolve, 3000)); + console.log("[ClawWork] ✅ Started"); + } + + /** + * Start React dashboard + */ + private startDashboard(): void { + console.log("[ClawWork] Starting dashboard..."); + + const dashboardProcess = spawn("npm", ["start"], { + cwd: join(CLAWWORK_DIR, "frontend"), + detached: true, + stdio: "ignore", + }); + + dashboardProcess.unref(); + } + + /** + * Stop ClawWork + */ + async stop(): Promise { + this.running = false; + console.log("[ClawWork] Stopped"); + } + + /** + * Get agent status + */ + async getStatus(): Promise { + if (!existsSync(STATE_FILE)) { + return { + balance: this.config.agent.initialBalance, + tokenCosts: 0, + survivalTier: 'starting', + tasksCompleted: 0, + }; + } + + try { + const state = JSON.parse(readFileSync(STATE_FILE, "utf-8")); + return { + balance: state.balance || this.config.agent.initialBalance, + tokenCosts: state.tokenCosts || 0, + survivalTier: this.calculateSurvivalTier(state.balance), + tasksCompleted: state.tasksCompleted || 0, + }; + } catch { + return { + balance: this.config.agent.initialBalance, + tokenCosts: 0, + survivalTier: 'starting', + tasksCompleted: 0, + }; + } + } + + /** + * Calculate survival tier based on balance + */ + private calculateSurvivalTier(balance: number): SurvivalTier { + if (balance > 500) return 'thriving'; + if (balance > 100) return 'stable'; + if (balance > 20) return 'surviving'; + return 'at_risk'; + } + + /** + * Decide activity (work or learn) + */ + async decideActivity(): Promise { + const status = await this.getStatus(); + + // Low balance - should learn first + if (status.balance < this.config.agent.learningThreshold) { + return { + activity: 'learn', + reason: `Balance ($${status.balance}) below threshold ($${this.config.agent.learningThreshold}). Invest in learning for higher-value tasks.`, + }; + } + + // Good balance - work + return { + activity: 'work', + reason: `Balance ($${status.balance}) sufficient. Ready for income-generating tasks.`, + }; + } + + /** + * Get available task + */ + async getTask(options?: TaskOptions): Promise { + console.log("[ClawWork] Fetching task..."); + + return new Promise((resolve, reject) => { + const args = ["-m", "clawwork.get_task"]; + + if (options?.minDifficulty) { + args.push("--difficulty", options.minDifficulty); + } + + const proc = spawn("python", args, { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + let output = ""; + proc.stdout?.on("data", (data) => { + output += data.toString(); + }); + + proc.on("close", (code) => { + if (code === 0) { + try { + const task = JSON.parse(output); + resolve(task); + } catch { + reject(new Error("Failed to parse task")); + } + } else { + reject(new Error("Failed to get task")); + } + }); + }); + } + + /** + * Work on task + */ + async work(task: Task): Promise { + console.log(`[ClawWork] Working on task: ${task.id}`); + + // This would integrate with QwenClaw agents to complete the task + return { + taskId: task.id, + artifact: 'artifact.pdf', + description: 'Task completed', + qualityEstimate: 0.8, + }; + } + + /** + * Submit completed work + */ + async submitWork(result: WorkResult): Promise { + console.log(`[ClawWork] Submitting work: ${result.taskId}`); + + return new Promise((resolve, reject) => { + const args = [ + "-m", "clawwork.submit", + "--task", result.taskId, + "--artifact", result.artifact, + ]; + + const proc = spawn("python", args, { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + let output = ""; + proc.stdout?.on("data", (data) => { + output += data.toString(); + }); + + proc.on("close", (code) => { + if (code === 0) { + try { + const payment = JSON.parse(output).payment; + resolve(payment); + } catch { + resolve(0); + } + } else { + reject(new Error("Submission failed")); + } + }); + }); + } + + /** + * Learn new skill + */ + async learn(knowledge: string): Promise { + if (knowledge.length < 200) { + throw new Error("Knowledge must be at least 200 characters"); + } + + console.log("[ClawWork] Learning new knowledge..."); + + return new Promise((resolve, reject) => { + const proc = spawn("python", ["-m", "clawwork.learn"], { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + proc.stdin?.write(knowledge); + proc.stdin?.end(); + + proc.on("close", (code) => { + if (code === 0) { + console.log("[ClawWork] ✅ Learning complete"); + resolve(); + } else { + reject(new Error("Learning failed")); + } + }); + }); + } + + /** + * Search web + */ + async searchWeb(query: string): Promise { + console.log(`[ClawWork] Searching: ${query}`); + + // Would integrate with Tavily or Jina + return []; + } + + /** + * Create file + */ + async createFile(file: FileSpec): Promise { + console.log(`[ClawWork] Creating file: ${file.path}`); + + return new Promise((resolve, reject) => { + const proc = spawn("python", ["-m", "clawwork.create_file", file.path], { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + proc.stdin?.write(JSON.stringify(file.content)); + proc.stdin?.end(); + + proc.on("close", (code) => { + if (code === 0) { + resolve(file.path); + } else { + reject(new Error("File creation failed")); + } + }); + }); + } + + /** + * Execute code + */ + async executeCode(code: string): Promise { + console.log("[ClawWork] Executing code..."); + + return new Promise((resolve, reject) => { + const proc = spawn("python", ["-m", "clawwork.execute_code"], { + cwd: CLAWWORK_DIR, + stdio: ["pipe", "pipe", "pipe"], + }); + + let output = ""; + proc.stdout?.on("data", (data) => { + output += data.toString(); + }); + + proc.stdin?.write(code); + proc.stdin?.end(); + + proc.on("close", (code) => { + if (code === 0) { + resolve({ output, success: true }); + } else { + resolve({ output, success: false }); + } + }); + }); + } +} + +interface AgentStatus { + balance: number; + tokenCosts: number; + survivalTier: SurvivalTier; + tasksCompleted: number; +} + +type SurvivalTier = 'thriving' | 'stable' | 'surviving' | 'at_risk' | 'starting'; + +interface ActivityDecision { + activity: 'work' | 'learn'; + reason: string; +} + +interface TaskOptions { + minDifficulty?: 'easy' | 'medium' | 'hard'; +} + +interface Task { + id: string; + sector: string; + description: string; + estimatedHours: number; + difficulty: 'easy' | 'medium' | 'hard'; + value: number; +} + +interface WorkResult { + taskId: string; + artifact: string; + description: string; + qualityEstimate: number; +} + +interface SearchResult { + title: string; + url: string; + snippet: string; +} + +interface FileSpec { + type: 'txt' | 'xlsx' | 'docx' | 'pdf'; + path: string; + content: any; +} + +interface CodeResult { + output: string; + success: boolean; +} + +/** + * Initialize ClawWork + */ +export async function initClawWork(): Promise { + const client = new ClawWorkClient(); + + if (client['config'].autoStart) { + await client.start(); + } + + return client; +} + +/** + * CLI command for ClawWork + */ +export async function clawworkCommand(args: string[]): Promise { + console.log("💼 ClawWork - Economic AI Agent Platform\n"); + + if (args.length === 0) { + console.log("Usage: qwenclaw clawwork [options]"); + console.log(""); + console.log("Commands:"); + console.log(" start - Start ClawWork server"); + console.log(" dashboard - Open React dashboard"); + console.log(" status - Check agent balance/status"); + console.log(" work - Start working on tasks"); + console.log(" learn - Learn new skill"); + console.log(" submit - Submit completed work"); + console.log(""); + console.log("Examples:"); + console.log(" qwenclaw clawwork start"); + console.log(" qwenclaw clawwork status"); + console.log(" qwenclaw clawwork learn 'Financial analysis'"); + return; + } + + const command = args[0]; + const client = new ClawWorkClient(); + + switch (command) { + case "start": + await client.start(); + break; + + case "status": + const status = await client.getStatus(); + console.log("ClawWork Agent Status:"); + console.log(` Balance: $${status.balance.toFixed(2)}`); + console.log(` Token Costs: $${status.tokenCosts.toFixed(2)}`); + console.log(` Survival Tier: ${status.survivalTier}`); + console.log(` Tasks Completed: ${status.tasksCompleted}`); + break; + + case "learn": + if (!args[1]) { + console.log("[ERROR] Knowledge topic required"); + return; + } + await client.learn(args.slice(1).join(" ")); + break; + + default: + console.log(`[ERROR] Unknown command: ${command}`); + } +}