onbuzz 3.3.0

package/src/interfaces/terminal/state/useTools.js

@@ -0,0 +1,554 @@
+/**
+ * Tools State Management Hook
+ * React hook for managing tools - listing, categorization, execution state, and capabilities
+ */
+
+import { useState, useEffect, useCallback, useRef, useMemo } from 'react';
+import { API_ENDPOINTS, TOOL_CATEGORY } from '../config/constants.js';
+
+/**
+ * Tools state management hook
+ * Manages tool listing, categorization, execution tracking, and capabilities
+ */
+export function useTools(sessionManager, messageRouter, currentAgentId) {
+  // Tool state
+  const [tools, setTools] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+
+  // Execution state
+  const [executingTools, setExecutingTools] = useState(new Set());
+  const [toolResults, setToolResults] = useState(new Map());
+
+  // Tool cache
+  const toolsCache = useRef(null);
+  const toolsCacheTimestamp = useRef(0);
+  const CACHE_TTL = 600000; // 10 minutes
+
+  /**
+   * Fetch available tools
+   */
+  const fetchTools = useCallback(async (options = {}) => {
+    if (!sessionManager?.isValid()) {
+      setError('Invalid session');
+      return { success: false, error: 'Invalid session' };
+    }
+
+    const { forceRefresh = false } = options;
+
+    // Check cache
+    const now = Date.now();
+    if (!forceRefresh && toolsCache.current && (now - toolsCacheTimestamp.current) < CACHE_TTL) {
+      setTools(toolsCache.current);
+      return { success: true, tools: toolsCache.current, cached: true };
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const response = await sessionManager.makeRequest('GET', API_ENDPOINTS.TOOLS);
+
+      if (response.success && response.tools) {
+        // Cache tools
+        toolsCache.current = response.tools;
+        toolsCacheTimestamp.current = now;
+
+        setTools(response.tools);
+        return { success: true, tools: response.tools };
+      }
+
+      throw new Error(response.error || 'Failed to fetch tools');
+    } catch (err) {
+      setError(err.message);
+      return { success: false, error: err.message };
+    } finally {
+      setLoading(false);
+    }
+  }, [sessionManager]);
+
+  /**
+   * Get tool by name
+   */
+  const getToolByName = useCallback((toolName) => {
+    return tools.find(tool => tool.name === toolName) || null;
+  }, [tools]);
+
+  /**
+   * Get tools by category
+   */
+  const getToolsByCategory = useCallback((category) => {
+    return tools.filter(tool => tool.category === category);
+  }, [tools]);
+
+  /**
+   * Get system tools
+   */
+  const getSystemTools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.SYSTEM);
+  }, [getToolsByCategory]);
+
+  /**
+   * Get automation tools
+   */
+  const getAutomationTools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.AUTOMATION);
+  }, [getToolsByCategory]);
+
+  /**
+   * Get analysis tools
+   */
+  const getAnalysisTools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.ANALYSIS);
+  }, [getToolsByCategory]);
+
+  /**
+   * Get utility tools
+   */
+  const getUtilityTools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.UTILITY);
+  }, [getToolsByCategory]);
+
+  /**
+   * Get collaboration tools
+   */
+  const getCollaborationTools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.COLLABORATION);
+  }, [getToolsByCategory]);
+
+  /**
+   * Get AI tools
+   */
+  const getAITools = useCallback(() => {
+    return getToolsByCategory(TOOL_CATEGORY.AI);
+  }, [getToolsByCategory]);
+
+  /**
+   * Check if tool is available
+   */
+  const isToolAvailable = useCallback((toolName) => {
+    return tools.some(tool => tool.name === toolName);
+  }, [tools]);
+
+  /**
+   * Check if tool is executing
+   */
+  const isToolExecuting = useCallback((toolName) => {
+    return executingTools.has(toolName);
+  }, [executingTools]);
+
+  /**
+   * Get tool result
+   */
+  const getToolResult = useCallback((executionId) => {
+    return toolResults.get(executionId) || null;
+  }, [toolResults]);
+
+  /**
+   * Execute a tool
+   */
+  const executeTool = useCallback(async (toolName, parameters = {}) => {
+    if (!sessionManager?.isValid() || !currentAgentId) {
+      throw new Error('Invalid session or no agent selected');
+    }
+
+    if (!toolName) {
+      throw new Error('Tool name is required');
+    }
+
+    // Check if tool exists
+    const tool = getToolByName(toolName);
+    if (!tool) {
+      throw new Error(`Tool not found: ${toolName}`);
+    }
+
+    // Mark as executing
+    setExecutingTools(prev => new Set(prev).add(toolName));
+    setError(null);
+
+    try {
+      // Execute via orchestrator
+      const response = await sessionManager.makeRequest('POST', API_ENDPOINTS.ORCHESTRATOR, {
+        action: 'execute_tool',
+        payload: {
+          agentId: currentAgentId,
+          toolName,
+          parameters,
+        },
+        sessionId: sessionManager.getSessionId(),
+      });
+
+      if (response.success) {
+        // Store result
+        const executionId = response.executionId || `${toolName}-${Date.now()}`;
+        setToolResults(prev => new Map(prev).set(executionId, response.result));
+
+        return {
+          success: true,
+          executionId,
+          result: response.result,
+        };
+      }
+
+      throw new Error(response.error || 'Failed to execute tool');
+    } catch (err) {
+      setError(err.message);
+      throw err;
+    } finally {
+      // Remove from executing set
+      setExecutingTools(prev => {
+        const next = new Set(prev);
+        next.delete(toolName);
+        return next;
+      });
+    }
+  }, [sessionManager, currentAgentId, getToolByName]);
+
+  /**
+   * Get tool capabilities
+   */
+  const getToolCapabilities = useCallback(async (toolName) => {
+    if (!sessionManager?.isValid()) {
+      throw new Error('Invalid session');
+    }
+
+    if (!toolName) {
+      throw new Error('Tool name is required');
+    }
+
+    try {
+      const response = await sessionManager.makeRequest('POST', API_ENDPOINTS.ORCHESTRATOR, {
+        action: 'get_tool_capabilities',
+        payload: { toolName },
+        sessionId: sessionManager.getSessionId(),
+      });
+
+      if (response.success && response.capabilities) {
+        return { success: true, capabilities: response.capabilities };
+      }
+
+      throw new Error(response.error || 'Failed to get tool capabilities');
+    } catch (err) {
+      throw new Error(`Failed to get capabilities for ${toolName}: ${err.message}`);
+    }
+  }, [sessionManager]);
+
+  /**
+   * Enable tool for agent
+   */
+  const enableTool = useCallback(async (agentId, toolName) => {
+    if (!sessionManager?.isValid()) {
+      throw new Error('Invalid session');
+    }
+
+    if (!agentId) {
+      throw new Error('Agent ID is required');
+    }
+
+    if (!toolName) {
+      throw new Error('Tool name is required');
+    }
+
+    try {
+      const response = await sessionManager.makeRequest('POST', API_ENDPOINTS.ORCHESTRATOR, {
+        action: 'enable_tool',
+        payload: {
+          agentId,
+          toolName,
+        },
+        sessionId: sessionManager.getSessionId(),
+      });
+
+      if (response.success) {
+        return { success: true };
+      }
+
+      throw new Error(response.error || 'Failed to enable tool');
+    } catch (err) {
+      throw new Error(`Failed to enable ${toolName}: ${err.message}`);
+    }
+  }, [sessionManager]);
+
+  /**
+   * Disable tool for agent
+   */
+  const disableTool = useCallback(async (agentId, toolName) => {
+    if (!sessionManager?.isValid()) {
+      throw new Error('Invalid session');
+    }
+
+    if (!agentId) {
+      throw new Error('Agent ID is required');
+    }
+
+    if (!toolName) {
+      throw new Error('Tool name is required');
+    }
+
+    try {
+      const response = await sessionManager.makeRequest('POST', API_ENDPOINTS.ORCHESTRATOR, {
+        action: 'disable_tool',
+        payload: {
+          agentId,
+          toolName,
+        },
+        sessionId: sessionManager.getSessionId(),
+      });
+
+      if (response.success) {
+        return { success: true };
+      }
+
+      throw new Error(response.error || 'Failed to disable tool');
+    } catch (err) {
+      throw new Error(`Failed to disable ${toolName}: ${err.message}`);
+    }
+  }, [sessionManager]);
+
+  /**
+   * Get enabled tools for agent
+   */
+  const getEnabledTools = useCallback(async (agentId) => {
+    if (!sessionManager?.isValid()) {
+      throw new Error('Invalid session');
+    }
+
+    if (!agentId) {
+      throw new Error('Agent ID is required');
+    }
+
+    try {
+      const response = await sessionManager.makeRequest('POST', API_ENDPOINTS.ORCHESTRATOR, {
+        action: 'get_enabled_tools',
+        payload: { agentId },
+        sessionId: sessionManager.getSessionId(),
+      });
+
+      if (response.success && response.tools) {
+        return { success: true, tools: response.tools };
+      }
+
+      throw new Error(response.error || 'Failed to get enabled tools');
+    } catch (err) {
+      throw new Error(`Failed to get enabled tools: ${err.message}`);
+    }
+  }, [sessionManager]);
+
+  /**
+   * Get all categories with tool counts
+   */
+  const getCategoryCounts = useCallback(() => {
+    const counts = {};
+
+    for (const category of Object.values(TOOL_CATEGORY)) {
+      counts[category] = tools.filter(t => t.category === category).length;
+    }
+
+    return counts;
+  }, [tools]);
+
+  /**
+   * Search tools by name or description
+   */
+  const searchTools = useCallback((query) => {
+    if (!query || query.trim().length === 0) {
+      return tools;
+    }
+
+    const lowerQuery = query.toLowerCase();
+    return tools.filter(tool =>
+      tool.name?.toLowerCase().includes(lowerQuery) ||
+      tool.description?.toLowerCase().includes(lowerQuery)
+    );
+  }, [tools]);
+
+  /**
+   * Filter tools by multiple criteria
+   */
+  const filterTools = useCallback((criteria = {}) => {
+    let filtered = [...tools];
+
+    if (criteria.category) {
+      filtered = filtered.filter(t => t.category === criteria.category);
+    }
+
+    if (criteria.enabled !== undefined) {
+      filtered = filtered.filter(t => t.enabled === criteria.enabled);
+    }
+
+    if (criteria.query) {
+      const lowerQuery = criteria.query.toLowerCase();
+      filtered = filtered.filter(t =>
+        t.name?.toLowerCase().includes(lowerQuery) ||
+        t.description?.toLowerCase().includes(lowerQuery)
+      );
+    }
+
+    return filtered;
+  }, [tools]);
+
+  /**
+   * Clear tool result
+   */
+  const clearToolResult = useCallback((executionId) => {
+    setToolResults(prev => {
+      const next = new Map(prev);
+      next.delete(executionId);
+      return next;
+    });
+  }, []);
+
+  /**
+   * Clear all tool results
+   */
+  const clearAllToolResults = useCallback(() => {
+    setToolResults(new Map());
+  }, []);
+
+  /**
+   * Clear error
+   */
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  /**
+   * Refresh tool list
+   */
+  const refresh = useCallback(async () => {
+    return fetchTools({ forceRefresh: true });
+  }, [fetchTools]);
+
+  // Set up WebSocket listeners for tool events
+  useEffect(() => {
+    if (!messageRouter) return;
+
+    // Tool execution started
+    const handleToolExecutionStarted = (data) => {
+      if (data.agentId === currentAgentId && data.toolName) {
+        setExecutingTools(prev => new Set(prev).add(data.toolName));
+      }
+    };
+
+    // Tool execution completed
+    const handleToolExecutionCompleted = (data) => {
+      if (data.agentId === currentAgentId && data.toolName) {
+        setExecutingTools(prev => {
+          const next = new Set(prev);
+          next.delete(data.toolName);
+          return next;
+        });
+
+        if (data.executionId && data.result) {
+          setToolResults(prev => new Map(prev).set(data.executionId, data.result));
+        }
+      }
+    };
+
+    // Tool enabled/disabled
+    const handleToolStateChanged = (data) => {
+      if (data.agentId === currentAgentId) {
+        // Refresh tool list to get updated enabled state
+        refresh();
+      }
+    };
+
+    messageRouter.on('tool:execution_started', handleToolExecutionStarted);
+    messageRouter.on('tool:execution_completed', handleToolExecutionCompleted);
+    messageRouter.on('tool:state_changed', handleToolStateChanged);
+
+    return () => {
+      messageRouter.off('tool:execution_started', handleToolExecutionStarted);
+      messageRouter.off('tool:execution_completed', handleToolExecutionCompleted);
+      messageRouter.off('tool:state_changed', handleToolStateChanged);
+    };
+  }, [messageRouter, currentAgentId, refresh]);
+
+  // Auto-fetch tools on mount
+  useEffect(() => {
+    if (sessionManager?.isValid() && tools.length === 0) {
+      fetchTools();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [sessionManager?.isValid, tools.length]);
+
+  // Return hook interface
+  return useMemo(() => ({
+    // State
+    tools,
+    loading,
+    error,
+
+    // Execution state
+    executingTools: Array.from(executingTools),
+    toolResults,
+
+    // Operations
+    fetchTools,
+    executeTool,
+    refresh,
+
+    // Tool queries
+    getToolByName,
+    getToolsByCategory,
+    getSystemTools,
+    getAutomationTools,
+    getAnalysisTools,
+    getUtilityTools,
+    getCollaborationTools,
+    getAITools,
+    isToolAvailable,
+    searchTools,
+    filterTools,
+    getCategoryCounts,
+
+    // Execution queries
+    isToolExecuting,
+    getToolResult,
+    clearToolResult,
+    clearAllToolResults,
+
+    // Capabilities
+    getToolCapabilities,
+
+    // Tool management
+    enableTool,
+    disableTool,
+    getEnabledTools,
+
+    // Utilities
+    clearError,
+  }), [
+    tools,
+    loading,
+    error,
+    executingTools,
+    toolResults,
+    fetchTools,
+    executeTool,
+    refresh,
+    getToolByName,
+    getToolsByCategory,
+    getSystemTools,
+    getAutomationTools,
+    getAnalysisTools,
+    getUtilityTools,
+    getCollaborationTools,
+    getAITools,
+    isToolAvailable,
+    searchTools,
+    filterTools,
+    getCategoryCounts,
+    isToolExecuting,
+    getToolResult,
+    clearToolResult,
+    clearAllToolResults,
+    getToolCapabilities,
+    enableTool,
+    disableTool,
+    getEnabledTools,
+    clearError,
+  ]);
+}
+
+export default useTools;

package/src/interfaces/terminal/utils/debugLogger.js

@@ -0,0 +1,44 @@
+/**
+ * Debug Logger
+ * Logs to file instead of console to avoid corrupting Ink UI
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LOG_FILE = path.join(__dirname, '../../../../debug-terminal-ui.log');
+
+// Clear log file on startup
+try {
+  fs.writeFileSync(LOG_FILE, `=== Terminal UI Debug Log - ${new Date().toISOString()} ===\n`);
+} catch (err) {
+  // Silently fail if we can't create log file
+}
+
+/**
+ * Log a debug message to file
+ */
+export function debugLog(component, message, data = null) {
+  try {
+    const timestamp = new Date().toISOString();
+    let logLine = `[${timestamp}] [${component}] ${message}`;
+
+    if (data !== null && data !== undefined) {
+      if (typeof data === 'object') {
+        logLine += ` ${JSON.stringify(data)}`;
+      } else {
+        logLine += ` ${data}`;
+      }
+    }
+
+    logLine += '\n';
+
+    fs.appendFileSync(LOG_FILE, logLine);
+  } catch (err) {
+    // Silently fail - don't break the app if logging fails
+  }
+}
+
+export default debugLog;