@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/tool-wrapper.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+/**
+ * TOOL WRAPPER - Auto-Delegation System
+ *
+ * Intercepts Read/Write/Edit/Bash/Glob/Grep tool calls and automatically
+ * delegates them to Task agent when appropriate.
+ *
+ * NO USER PROMPTS - Fully automated delegation based on strategies.
+ */
+
+import chalk from 'chalk';
+import { shouldDelegateTool, generateDelegationMessage } from './delegation-strategies.js';
+import taskWorker from './task-agent-worker.js';
+
+/**
+ * Tool Wrapper Class
+ *
+ * Wraps tool execution with auto-delegation logic
+ */
+export class ToolWrapper {
+  constructor(config = {}) {
+    this.agentName = config.agentName || 'ONYX';
+    this.enabled = config.enabled !== false;
+    this.taskWorker = taskWorker;
+    this.executionLog = [];
+    this.delegationLog = [];
+    this.directExecutionLog = [];
+
+    // Statistics
+    this.stats = {
+      total: 0,
+      delegated: 0,
+      direct: 0,
+      errors: 0
+    };
+  }
+
+  /**
+   * Execute tool with auto-delegation
+   *
+   * @param {string} toolName - Tool name (Read, Write, Edit, etc.)
+   * @param {Object} toolParams - Tool parameters
+   * @param {Object} options - Execution options
+   * @returns {Promise<Object>} Execution result
+   */
+  async executeTool(toolName, toolParams = {}, options = {}) {
+    if (!this.enabled) {
+      // Wrapper disabled - pass through to executor
+      return this._executeDirectly(toolName, toolParams, options);
+    }
+
+    const startTime = Date.now();
+
+    // Determine if delegation is needed
+    const decision = shouldDelegateTool(toolName, toolParams, {
+      agentName: this.agentName,
+      ...options.context
+    });
+
+    this.stats.total++;
+
+    if (decision.shouldDelegate) {
+      // AUTO-DELEGATE to Task agent
+      return await this._executeDelegated(toolName, toolParams, decision, options, startTime);
+    } else {
+      // Execute directly
+      return await this._executeDirectly(toolName, toolParams, options, decision, startTime);
+    }
+  }
+
+  /**
+   * Execute via delegation to Task agent
+   */
+  async _executeDelegated(toolName, toolParams, decision, options, startTime) {
+    this.stats.delegated++;
+
+    console.log(chalk.cyan('\n🔄 AUTO-DELEGATION TRIGGERED'));
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(chalk.white(`Agent: ${chalk.bold(this.agentName)}`));
+    console.log(chalk.white(`Tool: ${chalk.red(toolName)}`));
+    console.log(chalk.white(`Reason: ${decision.reason}`));
+    console.log(chalk.white(`Strategy: ${chalk.yellow(decision.strategy)}`));
+    console.log(chalk.dim('─'.repeat(60)));
+
+    try {
+      // Generate delegation message
+      const delegation = generateDelegationMessage(toolName, toolParams, decision);
+
+      // Execute via Task worker
+      const result = await this.taskWorker.executeDelegation(delegation);
+
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        tool: toolName,
+        params: toolParams,
+        delegated: true,
+        decision,
+        result,
+        executionTime,
+        success: result.success
+      };
+
+      this.executionLog.push(logEntry);
+      this.delegationLog.push(logEntry);
+
+      return {
+        success: result.success,
+        delegated: true,
+        tool: toolName,
+        delegateTo: 'Task',
+        strategy: decision.strategy,
+        reason: decision.reason,
+        result: result.result,
+        executionTime
+      };
+
+    } catch (error) {
+      this.stats.errors++;
+
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        tool: toolName,
+        params: toolParams,
+        delegated: true,
+        error: error.message,
+        executionTime,
+        success: false
+      };
+
+      this.executionLog.push(logEntry);
+
+      console.log(chalk.red(`❌ Delegation error: ${error.message}`));
+
+      return {
+        success: false,
+        delegated: true,
+        tool: toolName,
+        error: error.message,
+        executionTime
+      };
+    }
+  }
+
+  /**
+   * Execute tool directly (no delegation)
+   */
+  async _executeDirectly(toolName, toolParams, options, decision = null, startTime = Date.now()) {
+    this.stats.direct++;
+
+    if (decision) {
+      console.log(chalk.dim(`\n⚡ Direct execution: ${toolName} (${decision.reason})`));
+    }
+
+    try {
+      // Execute via provided executor
+      if (options.executor && typeof options.executor === 'function') {
+        const result = await options.executor(toolName, toolParams);
+
+        const executionTime = Date.now() - startTime;
+
+        const logEntry = {
+          timestamp: new Date().toISOString(),
+          tool: toolName,
+          params: toolParams,
+          delegated: false,
+          result,
+          executionTime,
+          success: true,
+          decision
+        };
+
+        this.executionLog.push(logEntry);
+        this.directExecutionLog.push(logEntry);
+
+        return {
+          success: true,
+          delegated: false,
+          tool: toolName,
+          result,
+          executionTime
+        };
+      }
+
+      // No executor - dry run
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        tool: toolName,
+        params: toolParams,
+        delegated: false,
+        dryRun: true,
+        executionTime,
+        success: true,
+        decision
+      };
+
+      this.executionLog.push(logEntry);
+      this.directExecutionLog.push(logEntry);
+
+      return {
+        success: true,
+        delegated: false,
+        dryRun: true,
+        tool: toolName,
+        params: toolParams,
+        message: 'No executor provided - dry run mode',
+        executionTime
+      };
+
+    } catch (error) {
+      this.stats.errors++;
+
+      const executionTime = Date.now() - startTime;
+
+      const logEntry = {
+        timestamp: new Date().toISOString(),
+        tool: toolName,
+        params: toolParams,
+        delegated: false,
+        error: error.message,
+        executionTime,
+        success: false
+      };
+
+      this.executionLog.push(logEntry);
+
+      console.log(chalk.red(`❌ Direct execution error: ${error.message}`));
+
+      return {
+        success: false,
+        delegated: false,
+        tool: toolName,
+        error: error.message,
+        executionTime
+      };
+    }
+  }
+
+  /**
+   * Configure task executor
+   */
+  setTaskExecutor(executor) {
+    this.taskWorker.setTaskExecutor(executor);
+  }
+
+  /**
+   * Get wrapper statistics
+   */
+  getStats() {
+    const delegationRate = this.stats.total > 0
+      ? (this.stats.delegated / this.stats.total * 100).toFixed(2)
+      : 0;
+
+    const errorRate = this.stats.total > 0
+      ? (this.stats.errors / this.stats.total * 100).toFixed(2)
+      : 0;
+
+    return {
+      ...this.stats,
+      delegationRate: parseFloat(delegationRate),
+      errorRate: parseFloat(errorRate)
+    };
+  }
+
+  /**
+   * Print comprehensive report
+   */
+  printReport() {
+    const stats = this.getStats();
+    const taskStats = this.taskWorker.getStats();
+
+    console.log(chalk.blue('\n📊 TOOL WRAPPER REPORT'));
+    console.log(chalk.dim('═'.repeat(60)));
+    console.log(chalk.white(`Agent: ${chalk.bold(this.agentName)}`));
+    console.log(chalk.white(`Status: ${this.enabled ? chalk.green('ENABLED') : chalk.red('DISABLED')}`));
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(chalk.white(`Total Tool Calls: ${chalk.magenta(stats.total)}`));
+    console.log(chalk.white(`Delegated: ${chalk.cyan(stats.delegated)} (${stats.delegationRate}%)`));
+    console.log(chalk.white(`Direct: ${chalk.green(stats.direct)}`));
+    console.log(chalk.white(`Errors: ${chalk.red(stats.errors)} (${stats.errorRate}%)`));
+    console.log(chalk.dim('═'.repeat(60)));
+
+    if (this.delegationLog.length > 0) {
+      console.log(chalk.cyan('\nRecent Delegations:'));
+      this.delegationLog.slice(-5).forEach(log => {
+        const status = log.success ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${status} ${log.tool} - ${log.decision.strategy}`);
+      });
+    }
+
+    if (this.directExecutionLog.length > 0) {
+      console.log(chalk.green('\nRecent Direct Executions:'));
+      this.directExecutionLog.slice(-5).forEach(log => {
+        const status = log.success ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${status} ${log.tool}${log.dryRun ? ' (dry run)' : ''}`);
+      });
+    }
+
+    console.log(chalk.dim('═'.repeat(60)));
+
+    // Task worker stats
+    if (taskStats.total > 0) {
+      console.log(chalk.blue('\n📤 TASK WORKER STATS'));
+      console.log(chalk.dim('─'.repeat(60)));
+      console.log(chalk.white(`Success Rate: ${chalk.cyan(taskStats.successRate + '%')}`));
+      console.log(chalk.white(`Avg Execution Time: ${chalk.yellow(taskStats.avgExecutionTime + 'ms')}`));
+      console.log(chalk.dim('─'.repeat(60)));
+    }
+  }
+
+  /**
+   * Get execution log
+   */
+  getLog(limit = 20) {
+    return this.executionLog.slice(-limit);
+  }
+
+  /**
+   * Enable/disable wrapper
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    console.log(chalk.cyan(`\n🔧 Tool Wrapper: ${enabled ? 'ENABLED' : 'DISABLED'}`));
+  }
+
+  /**
+   * Reset wrapper state
+   */
+  reset() {
+    this.executionLog = [];
+    this.delegationLog = [];
+    this.directExecutionLog = [];
+    this.stats = {
+      total: 0,
+      delegated: 0,
+      direct: 0,
+      errors: 0
+    };
+    this.taskWorker.reset();
+    console.log(chalk.green('✅ Tool Wrapper reset'));
+  }
+}
+
+// Singleton instance
+const toolWrapper = new ToolWrapper();
+
+export default toolWrapper;
+
+/**
+ * USAGE EXAMPLES:
+ *
+ * 1. Basic auto-delegation:
+ *
+ *    import toolWrapper from '@cpretzinger/boss-claude/lib/tool-wrapper.js';
+ *
+ *    const result = await toolWrapper.executeTool('Read', {
+ *      file_path: '/path/to/file.js'
+ *    });
+ *
+ *    // If ONYX agent, automatically delegates to Task
+ *    // If below threshold, executes directly
+ *
+ * 2. With executor function:
+ *
+ *    const result = await toolWrapper.executeTool('Read', {
+ *      file_path: '/path/to/file.js'
+ *    }, {
+ *      executor: async (tool, params) => {
+ *        return await actualReadTool(params);
+ *      }
+ *    });
+ *
+ * 3. Configure task executor:
+ *
+ *    toolWrapper.setTaskExecutor(async (taskParams) => {
+ *      return await taskTool.execute(taskParams);
+ *    });
+ *
+ * 4. Print report:
+ *
+ *    toolWrapper.printReport();
+ */