@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/tool-wrapper-integration.js

@@ -0,0 +1,369 @@
+#!/usr/bin/env node
+/**
+ * TOOL WRAPPER INTEGRATION
+ *
+ * Integration layer for Tool Wrapper system.
+ * Provides hooks and utilities for integrating auto-delegation
+ * into Boss Claude and ONYX agents.
+ */
+
+import chalk from 'chalk';
+import toolWrapper from './tool-wrapper.js';
+import taskWorker from './task-agent-worker.js';
+
+/**
+ * Initialize Tool Wrapper system
+ *
+ * @param {Object} config - Configuration options
+ * @returns {Object} Integration interface
+ */
+export function initializeToolWrapper(config = {}) {
+  const {
+    agentName = 'ONYX',
+    taskExecutor = null,
+    enabled = true,
+    verbose = false
+  } = config;
+
+  // Configure tool wrapper
+  if (agentName) {
+    toolWrapper.agentName = agentName;
+  }
+
+  toolWrapper.setEnabled(enabled);
+
+  // Configure task executor
+  if (taskExecutor) {
+    toolWrapper.setTaskExecutor(taskExecutor);
+  }
+
+  if (verbose) {
+    console.log(chalk.blue('\n🔧 Tool Wrapper Initialized'));
+    console.log(chalk.dim('─'.repeat(60)));
+    console.log(chalk.white(`Agent: ${chalk.bold(agentName)}`));
+    console.log(chalk.white(`Status: ${enabled ? chalk.green('ENABLED') : chalk.red('DISABLED')}`));
+    console.log(chalk.white(`Task Executor: ${taskExecutor ? chalk.green('CONFIGURED') : chalk.yellow('NOT CONFIGURED')}`));
+    console.log(chalk.dim('─'.repeat(60)));
+  }
+
+  return {
+    toolWrapper,
+    taskWorker,
+    executeTool: toolWrapper.executeTool.bind(toolWrapper),
+    setTaskExecutor: toolWrapper.setTaskExecutor.bind(toolWrapper),
+    getStats: toolWrapper.getStats.bind(toolWrapper),
+    printReport: toolWrapper.printReport.bind(toolWrapper),
+    reset: toolWrapper.reset.bind(toolWrapper)
+  };
+}
+
+/**
+ * Create tool execution wrapper for specific agent
+ *
+ * @param {string} agentName - Name of agent
+ * @param {Function} taskExecutor - Task tool executor function
+ * @returns {Function} Wrapped executeTool function
+ */
+export function createAgentToolWrapper(agentName, taskExecutor = null) {
+  const wrapperConfig = {
+    agentName,
+    taskExecutor,
+    enabled: true
+  };
+
+  const wrapper = initializeToolWrapper(wrapperConfig);
+
+  // Return wrapped function with agent context
+  return async function executeToolWithDelegation(toolName, toolParams, options = {}) {
+    return await wrapper.executeTool(toolName, toolParams, {
+      ...options,
+      context: {
+        agentName,
+        ...options.context
+      }
+    });
+  };
+}
+
+/**
+ * Hook into Read tool
+ */
+export function hookRead(originalReadFn, agentName = 'ONYX') {
+  return async function wrappedRead(params, options = {}) {
+    const result = await toolWrapper.executeTool('Read', params, {
+      executor: originalReadFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook into Write tool
+ */
+export function hookWrite(originalWriteFn, agentName = 'ONYX') {
+  return async function wrappedWrite(params, options = {}) {
+    const result = await toolWrapper.executeTool('Write', params, {
+      executor: originalWriteFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook into Edit tool
+ */
+export function hookEdit(originalEditFn, agentName = 'ONYX') {
+  return async function wrappedEdit(params, options = {}) {
+    const result = await toolWrapper.executeTool('Edit', params, {
+      executor: originalEditFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook into Bash tool
+ */
+export function hookBash(originalBashFn, agentName = 'ONYX') {
+  return async function wrappedBash(params, options = {}) {
+    const result = await toolWrapper.executeTool('Bash', params, {
+      executor: originalBashFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook into Grep tool
+ */
+export function hookGrep(originalGrepFn, agentName = 'ONYX') {
+  return async function wrappedGrep(params, options = {}) {
+    const result = await toolWrapper.executeTool('Grep', params, {
+      executor: originalGrepFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook into Glob tool
+ */
+export function hookGlob(originalGlobFn, agentName = 'ONYX') {
+  return async function wrappedGlob(params, options = {}) {
+    const result = await toolWrapper.executeTool('Glob', params, {
+      executor: originalGlobFn,
+      context: { agentName },
+      ...options
+    });
+
+    return result.success ? result.result : result;
+  };
+}
+
+/**
+ * Hook all tools at once
+ *
+ * @param {Object} tools - Object with original tool functions
+ * @param {string} agentName - Name of agent
+ * @returns {Object} Object with wrapped tool functions
+ */
+export function hookAllTools(tools, agentName = 'ONYX') {
+  const wrapped = {};
+
+  if (tools.Read) {
+    wrapped.Read = hookRead(tools.Read, agentName);
+  }
+
+  if (tools.Write) {
+    wrapped.Write = hookWrite(tools.Write, agentName);
+  }
+
+  if (tools.Edit) {
+    wrapped.Edit = hookEdit(tools.Edit, agentName);
+  }
+
+  if (tools.Bash) {
+    wrapped.Bash = hookBash(tools.Bash, agentName);
+  }
+
+  if (tools.Grep) {
+    wrapped.Grep = hookGrep(tools.Grep, agentName);
+  }
+
+  if (tools.Glob) {
+    wrapped.Glob = hookGlob(tools.Glob, agentName);
+  }
+
+  return wrapped;
+}
+
+/**
+ * Verify wrapper is intercepting correctly
+ *
+ * @returns {Promise<Object>} Verification results
+ */
+export async function verifyWrapper() {
+  console.log(chalk.blue('\n🔍 Verifying Tool Wrapper Integration'));
+  console.log(chalk.dim('═'.repeat(60)));
+
+  const results = {
+    passed: [],
+    failed: [],
+    total: 0
+  };
+
+  const testTools = [
+    {
+      name: 'Read',
+      params: { file_path: '/test/path.js' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Write',
+      params: { file_path: '/test/path.js', content: 'test' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Edit',
+      params: { file_path: '/test/path.js', old_string: 'a', new_string: 'b' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Bash',
+      params: { command: 'echo test' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Grep',
+      params: { pattern: 'test', path: '/src' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Glob',
+      params: { pattern: '**/*.js' },
+      shouldDelegate: true
+    },
+    {
+      name: 'Task',
+      params: { description: 'Test task' },
+      shouldDelegate: false
+    }
+  ];
+
+  for (const test of testTools) {
+    results.total++;
+
+    try {
+      const result = await toolWrapper.executeTool(test.name, test.params);
+
+      const delegated = result.delegated === true;
+      const expectedDelegation = test.shouldDelegate;
+
+      if (delegated === expectedDelegation) {
+        results.passed.push({
+          tool: test.name,
+          expected: expectedDelegation ? 'delegated' : 'direct',
+          actual: delegated ? 'delegated' : 'direct',
+          success: true
+        });
+        console.log(chalk.green(`✓ ${test.name}: ${delegated ? 'delegated' : 'direct'} (expected)`));
+      } else {
+        results.failed.push({
+          tool: test.name,
+          expected: expectedDelegation ? 'delegated' : 'direct',
+          actual: delegated ? 'delegated' : 'direct',
+          success: false
+        });
+        console.log(chalk.red(`✗ ${test.name}: ${delegated ? 'delegated' : 'direct'} (expected ${expectedDelegation ? 'delegated' : 'direct'})`));
+      }
+
+    } catch (error) {
+      results.failed.push({
+        tool: test.name,
+        error: error.message,
+        success: false
+      });
+      console.log(chalk.red(`✗ ${test.name}: ERROR - ${error.message}`));
+    }
+  }
+
+  console.log(chalk.dim('═'.repeat(60)));
+  console.log(chalk.white(`Results: ${chalk.green(results.passed.length)} passed, ${chalk.red(results.failed.length)} failed`));
+  console.log(chalk.dim('═'.repeat(60)));
+
+  // Reset after verification
+  toolWrapper.reset();
+
+  return results;
+}
+
+/**
+ * Get integration status
+ */
+export function getIntegrationStatus() {
+  const stats = toolWrapper.getStats();
+  const taskStats = taskWorker.getStats();
+
+  return {
+    wrapper: {
+      agentName: toolWrapper.agentName,
+      enabled: toolWrapper.enabled,
+      stats
+    },
+    taskWorker: {
+      configured: taskWorker.taskExecutor !== null,
+      stats: taskStats
+    },
+    timestamp: new Date().toISOString()
+  };
+}
+
+/**
+ * Print integration status
+ */
+export function printIntegrationStatus() {
+  const status = getIntegrationStatus();
+
+  console.log(chalk.blue('\n📊 TOOL WRAPPER INTEGRATION STATUS'));
+  console.log(chalk.dim('═'.repeat(60)));
+  console.log(chalk.white(`Agent: ${chalk.bold(status.wrapper.agentName)}`));
+  console.log(chalk.white(`Wrapper: ${status.wrapper.enabled ? chalk.green('ENABLED') : chalk.red('DISABLED')}`));
+  console.log(chalk.white(`Task Executor: ${status.taskWorker.configured ? chalk.green('CONFIGURED') : chalk.yellow('NOT CONFIGURED')}`));
+  console.log(chalk.dim('─'.repeat(60)));
+  console.log(chalk.white(`Total Calls: ${chalk.magenta(status.wrapper.stats.total)}`));
+  console.log(chalk.white(`Delegation Rate: ${chalk.cyan(status.wrapper.stats.delegationRate + '%')}`));
+  console.log(chalk.white(`Task Success Rate: ${status.taskWorker.configured ? chalk.green(status.taskWorker.stats.successRate + '%') : chalk.dim('N/A')}`));
+  console.log(chalk.dim('═'.repeat(60)));
+}
+
+export default {
+  initializeToolWrapper,
+  createAgentToolWrapper,
+  hookRead,
+  hookWrite,
+  hookEdit,
+  hookBash,
+  hookGrep,
+  hookGlob,
+  hookAllTools,
+  verifyWrapper,
+  getIntegrationStatus,
+  printIntegrationStatus,
+  toolWrapper,
+  taskWorker
+};