@probelabs/probe 0.6.0-rc100

package/src/agent/acp/tools.js

@@ -0,0 +1,368 @@
+// ACP Tool Integration - Maps probe tools to ACP tool format
+import { randomUUID } from 'crypto';
+import { 
+  ToolCallStatus, 
+  ToolCallKind, 
+  createTextContent,
+  createToolCallProgress 
+} from './types.js';
+
+/**
+ * ACP Tool Call represents a tool execution instance
+ */
+export class ACPToolCall {
+  constructor(id, name, kind, params, sessionId) {
+    this.id = id;
+    this.name = name;
+    this.kind = kind;
+    this.params = params;
+    this.sessionId = sessionId;
+    this.status = ToolCallStatus.PENDING;
+    this.startTime = Date.now();
+    this.endTime = null;
+    this.result = null;
+    this.error = null;
+  }
+  
+  /**
+   * Update tool call status
+   */
+  updateStatus(status, result = null, error = null) {
+    this.status = status;
+    this.result = result;
+    this.error = error;
+    
+    if (status === ToolCallStatus.COMPLETED || status === ToolCallStatus.FAILED) {
+      this.endTime = Date.now();
+    }
+  }
+  
+  /**
+   * Get execution duration in ms
+   */
+  getDuration() {
+    const end = this.endTime || Date.now();
+    return end - this.startTime;
+  }
+  
+  /**
+   * Serialize to JSON
+   */
+  toJSON() {
+    return {
+      id: this.id,
+      name: this.name,
+      kind: this.kind,
+      params: this.params,
+      sessionId: this.sessionId,
+      status: this.status,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      duration: this.getDuration(),
+      result: this.result,
+      error: this.error
+    };
+  }
+}
+
+/**
+ * ACP Tool Manager - manages tool execution and lifecycle
+ */
+export class ACPToolManager {
+  constructor(server, probeAgent) {
+    this.server = server;
+    this.probeAgent = probeAgent;
+    this.activeCalls = new Map();
+    this.debug = server.options.debug;
+  }
+  
+  /**
+   * Execute a tool with ACP lifecycle tracking
+   */
+  async executeToolCall(sessionId, toolName, params) {
+    const toolCallId = randomUUID();
+    const kind = this.getToolKind(toolName);
+    
+    const toolCall = new ACPToolCall(toolCallId, toolName, kind, params, sessionId);
+    this.activeCalls.set(toolCallId, toolCall);
+    
+    if (this.debug) {
+      console.error(`[ACP] Starting tool call: ${toolName} (${toolCallId})`);
+    }
+    
+    // Send pending notification
+    this.server.sendToolCallProgress(
+      sessionId, 
+      toolCallId, 
+      ToolCallStatus.PENDING
+    );
+    
+    try {
+      // Update to in progress
+      toolCall.updateStatus(ToolCallStatus.IN_PROGRESS);
+      this.server.sendToolCallProgress(
+        sessionId, 
+        toolCallId, 
+        ToolCallStatus.IN_PROGRESS
+      );
+      
+      // Execute the actual tool
+      const result = await this.executeProbeTool(toolName, params);
+      
+      // Update to completed
+      toolCall.updateStatus(ToolCallStatus.COMPLETED, result);
+      this.server.sendToolCallProgress(
+        sessionId, 
+        toolCallId, 
+        ToolCallStatus.COMPLETED, 
+        result
+      );
+      
+      if (this.debug) {
+        console.error(`[ACP] Tool call completed: ${toolName} (${toolCall.getDuration()}ms)`);
+      }
+      
+      return result;
+      
+    } catch (error) {
+      // Update to failed
+      toolCall.updateStatus(ToolCallStatus.FAILED, null, error.message);
+      this.server.sendToolCallProgress(
+        sessionId, 
+        toolCallId, 
+        ToolCallStatus.FAILED, 
+        null, 
+        error.message
+      );
+      
+      if (this.debug) {
+        console.error(`[ACP] Tool call failed: ${toolName}`, error);
+      }
+      
+      throw error;
+      
+    } finally {
+      // Clean up completed calls after a delay
+      setTimeout(() => {
+        this.activeCalls.delete(toolCallId);
+      }, 30000); // Keep for 30 seconds for status queries
+    }
+  }
+  
+  /**
+   * Get tool kind based on tool name
+   */
+  getToolKind(toolName) {
+    switch (toolName) {
+      case 'search':
+        return ToolCallKind.search;
+      case 'query':
+        return ToolCallKind.query;
+      case 'extract':
+        return ToolCallKind.extract;
+      case 'delegate':
+        return ToolCallKind.execute;
+      case 'implement':
+        return ToolCallKind.edit;
+      default:
+        return ToolCallKind.execute;
+    }
+  }
+  
+  /**
+   * Execute a probe tool
+   */
+  async executeProbeTool(toolName, params) {
+    // Get the tool from the probe agent
+    const tools = this.probeAgent.wrappedTools;
+    
+    switch (toolName) {
+      case 'search':
+        if (!tools.searchToolInstance) {
+          throw new Error('Search tool not available');
+        }
+        return await tools.searchToolInstance.execute({
+          ...params,
+          sessionId: this.probeAgent.sessionId
+        });
+        
+      case 'query':
+        if (!tools.queryToolInstance) {
+          throw new Error('Query tool not available');
+        }
+        return await tools.queryToolInstance.execute({
+          ...params,
+          sessionId: this.probeAgent.sessionId
+        });
+        
+      case 'extract':
+        if (!tools.extractToolInstance) {
+          throw new Error('Extract tool not available');
+        }
+        return await tools.extractToolInstance.execute({
+          ...params,
+          sessionId: this.probeAgent.sessionId
+        });
+        
+      case 'delegate':
+        if (!tools.delegateToolInstance) {
+          throw new Error('Delegate tool not available');
+        }
+        return await tools.delegateToolInstance.execute({
+          ...params,
+          sessionId: this.probeAgent.sessionId
+        });
+        
+      default:
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+  }
+  
+  /**
+   * Get tool call status
+   */
+  getToolCallStatus(toolCallId) {
+    const toolCall = this.activeCalls.get(toolCallId);
+    return toolCall ? toolCall.toJSON() : null;
+  }
+  
+  /**
+   * Get all active tool calls for a session
+   */
+  getActiveToolCalls(sessionId) {
+    const calls = [];
+    for (const toolCall of this.activeCalls.values()) {
+      if (toolCall.sessionId === sessionId) {
+        calls.push(toolCall.toJSON());
+      }
+    }
+    return calls;
+  }
+  
+  /**
+   * Cancel all tool calls for a session
+   */
+  cancelSessionToolCalls(sessionId) {
+    for (const [id, toolCall] of this.activeCalls) {
+      if (toolCall.sessionId === sessionId && 
+          (toolCall.status === ToolCallStatus.PENDING || 
+           toolCall.status === ToolCallStatus.IN_PROGRESS)) {
+        
+        toolCall.updateStatus(ToolCallStatus.FAILED, null, 'Cancelled');
+        this.server.sendToolCallProgress(
+          sessionId, 
+          id, 
+          ToolCallStatus.FAILED, 
+          null, 
+          'Cancelled'
+        );
+      }
+    }
+  }
+  
+  /**
+   * Get tool definitions for capabilities
+   */
+  static getToolDefinitions() {
+    return [
+      {
+        name: 'search',
+        description: 'Search for code patterns and content using flexible text search with stemming and stopword removal. Supports regex patterns and elastic search query syntax.',
+        kind: ToolCallKind.search,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query using elastic search syntax. Supports logical operators (AND, OR, NOT), quotes for exact matches, field specifiers, and regex patterns.'
+            },
+            path: {
+              type: 'string',
+              description: 'Directory to search in (defaults to current working directory)'
+            },
+            max_results: {
+              type: 'number',
+              description: 'Maximum number of results to return (default: 10)'
+            },
+            allow_tests: {
+              type: 'boolean',
+              description: 'Include test files in results (default: false)'
+            }
+          },
+          required: ['query']
+        }
+      },
+      {
+        name: 'query',
+        description: 'Perform structural queries using AST patterns to find specific code structures like functions, classes, or methods.',
+        kind: ToolCallKind.query,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            pattern: {
+              type: 'string',
+              description: 'AST-grep pattern to search for. Examples: "fn $NAME($$$PARAMS) $$$BODY" for Rust functions, "def $NAME($$$PARAMS): $$$BODY" for Python functions.'
+            },
+            path: {
+              type: 'string',
+              description: 'Directory to search in (defaults to current working directory)'
+            },
+            language: {
+              type: 'string',
+              description: 'Programming language to search in (rust, javascript, python, go, etc.)'
+            },
+            max_results: {
+              type: 'number',
+              description: 'Maximum number of results to return (default: 10)'
+            }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'extract',
+        description: 'Extract specific code blocks from files based on file paths and optional line numbers.',
+        kind: ToolCallKind.extract,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            files: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Array of file paths or file:line specifications to extract from'
+            },
+            context_lines: {
+              type: 'number',
+              description: 'Number of context lines to include before and after (default: 0)'
+            },
+            allow_tests: {
+              type: 'boolean',
+              description: 'Allow test files in results (default: false)'
+            },
+            format: {
+              type: 'string',
+              enum: ['plain', 'markdown', 'json'],
+              description: 'Output format (default: markdown)'
+            }
+          },
+          required: ['files']
+        }
+      },
+      {
+        name: 'delegate',
+        description: 'Automatically delegate big distinct tasks to specialized probe subagents within the agentic loop. Use when complex requests can be broken into focused, parallel tasks.',
+        kind: ToolCallKind.execute,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            task: {
+              type: 'string',
+              description: 'A complete, self-contained task that can be executed independently by a subagent. Should be specific and focused on one area of expertise.'
+            }
+          },
+          required: ['task']
+        }
+      }
+    ];
+  }
+}

package/src/agent/acp/tools.test.js

@@ -0,0 +1,334 @@
+// Tests for ACP Tool Manager and Tool Calls
+import { jest } from '@jest/globals';
+import { ACPToolCall, ACPToolManager } from './tools.js';
+import { ToolCallStatus, ToolCallKind } from './types.js';
+
+describe('ACPToolCall', () => {
+  test('should create tool call with correct initial state', () => {
+    const toolCall = new ACPToolCall(
+      'test-id', 
+      'search', 
+      ToolCallKind.search, 
+      { query: 'test' }, 
+      'session-123'
+    );
+    
+    expect(toolCall.id).toBe('test-id');
+    expect(toolCall.name).toBe('search');
+    expect(toolCall.kind).toBe(ToolCallKind.search);
+    expect(toolCall.params).toEqual({ query: 'test' });
+    expect(toolCall.sessionId).toBe('session-123');
+    expect(toolCall.status).toBe(ToolCallStatus.PENDING);
+    expect(toolCall.startTime).toBeLessThanOrEqual(Date.now());
+    expect(toolCall.endTime).toBeNull();
+    expect(toolCall.result).toBeNull();
+    expect(toolCall.error).toBeNull();
+  });
+  
+  test('should update status correctly', async () => {
+    const toolCall = new ACPToolCall('id', 'test', 'kind', {}, 'session');
+    const result = { data: 'test result' };
+    
+    toolCall.updateStatus(ToolCallStatus.IN_PROGRESS);
+    expect(toolCall.status).toBe(ToolCallStatus.IN_PROGRESS);
+    expect(toolCall.endTime).toBeNull();
+    
+    // Add a small delay to ensure timing difference
+    await new Promise(resolve => setTimeout(resolve, 1));
+    
+    toolCall.updateStatus(ToolCallStatus.COMPLETED, result);
+    expect(toolCall.status).toBe(ToolCallStatus.COMPLETED);
+    expect(toolCall.result).toBe(result);
+    expect(toolCall.endTime).toBeGreaterThanOrEqual(toolCall.startTime);
+  });
+  
+  test('should calculate duration correctly', (done) => {
+    const toolCall = new ACPToolCall('id', 'test', 'kind', {}, 'session');
+    
+    setTimeout(() => {
+      const duration = toolCall.getDuration();
+      expect(duration).toBeGreaterThan(0);
+      expect(duration).toBeLessThan(100); // Should be very small
+      done();
+    }, 10);
+  });
+  
+  test('should serialize to JSON correctly', () => {
+    const toolCall = new ACPToolCall(
+      'test-id', 
+      'search', 
+      ToolCallKind.search, 
+      { query: 'test' }, 
+      'session-123'
+    );
+    toolCall.updateStatus(ToolCallStatus.COMPLETED, { found: 5 });
+    
+    const json = toolCall.toJSON();
+    
+    expect(json).toEqual({
+      id: 'test-id',
+      name: 'search',
+      kind: ToolCallKind.search,
+      params: { query: 'test' },
+      sessionId: 'session-123',
+      status: ToolCallStatus.COMPLETED,
+      startTime: toolCall.startTime,
+      endTime: toolCall.endTime,
+      duration: toolCall.getDuration(),
+      result: { found: 5 },
+      error: null
+    });
+  });
+});
+
+describe('ACPToolManager', () => {
+  let mockServer, mockProbeAgent, toolManager;
+  
+  beforeEach(() => {
+    mockServer = {
+      options: { debug: true },
+      sendToolCallProgress: jest.fn()
+    };
+    
+    mockProbeAgent = {
+      sessionId: 'test-session',
+      wrappedTools: {
+        searchToolInstance: {
+          execute: jest.fn().mockResolvedValue('search result')
+        },
+        queryToolInstance: {
+          execute: jest.fn().mockResolvedValue('query result')
+        },
+        extractToolInstance: {
+          execute: jest.fn().mockResolvedValue('extract result')
+        },
+        delegateToolInstance: {
+          execute: jest.fn().mockResolvedValue('delegate result')
+        }
+      }
+    };
+    
+    toolManager = new ACPToolManager(mockServer, mockProbeAgent);
+  });
+  
+  describe('tool kind mapping', () => {
+    test('should map tool names to correct kinds', () => {
+      expect(toolManager.getToolKind('search')).toBe(ToolCallKind.search);
+      expect(toolManager.getToolKind('query')).toBe(ToolCallKind.query);
+      expect(toolManager.getToolKind('extract')).toBe(ToolCallKind.extract);
+      expect(toolManager.getToolKind('delegate')).toBe(ToolCallKind.execute);
+      expect(toolManager.getToolKind('implement')).toBe(ToolCallKind.edit);
+      expect(toolManager.getToolKind('unknown')).toBe(ToolCallKind.execute);
+    });
+  });
+  
+  describe('tool execution', () => {
+    test('should execute search tool successfully', async () => {
+      const params = { query: 'test search', path: '/test' };
+      
+      const result = await toolManager.executeToolCall('session-123', 'search', params);
+      
+      expect(result).toBe('search result');
+      expect(mockProbeAgent.wrappedTools.searchToolInstance.execute).toHaveBeenCalledWith({
+        ...params,
+        sessionId: 'test-session'
+      });
+      
+      // Should send progress notifications
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledTimes(3);
+      expect(mockServer.sendToolCallProgress).toHaveBeenNthCalledWith(
+        1, 'session-123', expect.any(String), ToolCallStatus.PENDING
+      );
+      expect(mockServer.sendToolCallProgress).toHaveBeenNthCalledWith(
+        2, 'session-123', expect.any(String), ToolCallStatus.IN_PROGRESS
+      );
+      expect(mockServer.sendToolCallProgress).toHaveBeenNthCalledWith(
+        3, 'session-123', expect.any(String), ToolCallStatus.COMPLETED, 'search result'
+      );
+    });
+    
+    test('should execute query tool successfully', async () => {
+      const params = { pattern: 'fn $NAME($$$)', language: 'rust' };
+      
+      const result = await toolManager.executeToolCall('session-123', 'query', params);
+      
+      expect(result).toBe('query result');
+      expect(mockProbeAgent.wrappedTools.queryToolInstance.execute).toHaveBeenCalledWith({
+        ...params,
+        sessionId: 'test-session'
+      });
+    });
+    
+    test('should execute extract tool successfully', async () => {
+      const params = { files: ['src/main.rs:10'], context_lines: 5 };
+      
+      const result = await toolManager.executeToolCall('session-123', 'extract', params);
+      
+      expect(result).toBe('extract result');
+      expect(mockProbeAgent.wrappedTools.extractToolInstance.execute).toHaveBeenCalledWith({
+        ...params,
+        sessionId: 'test-session'
+      });
+    });
+    
+    test('should execute delegate tool successfully', async () => {
+      const params = { task: 'Analyze security vulnerabilities in authentication code' };
+      
+      const result = await toolManager.executeToolCall('session-123', 'delegate', params);
+      
+      expect(result).toBe('delegate result');
+      expect(mockProbeAgent.wrappedTools.delegateToolInstance.execute).toHaveBeenCalledWith({
+        ...params,
+        sessionId: 'test-session'
+      });
+    });
+    
+    test('should handle tool execution errors', async () => {
+      const error = new Error('Tool execution failed');
+      mockProbeAgent.wrappedTools.searchToolInstance.execute.mockRejectedValue(error);
+      
+      await expect(toolManager.executeToolCall('session-123', 'search', {})).rejects.toThrow(error);
+      
+      // Should send error notification
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'session-123', expect.any(String), ToolCallStatus.FAILED, null, 'Tool execution failed'
+      );
+    });
+    
+    test('should handle unknown tools', async () => {
+      await expect(toolManager.executeToolCall('session-123', 'unknown', {})).rejects.toThrow('Unknown tool: unknown');
+    });
+    
+    test('should handle missing tool instances', async () => {
+      mockProbeAgent.wrappedTools.searchToolInstance = null;
+      
+      await expect(toolManager.executeToolCall('session-123', 'search', {})).rejects.toThrow('Search tool not available');
+      
+      mockProbeAgent.wrappedTools.delegateToolInstance = null;
+      
+      await expect(toolManager.executeToolCall('session-123', 'delegate', {})).rejects.toThrow('Delegate tool not available');
+    });
+  });
+  
+  describe('tool call tracking', () => {
+    test('should track active tool calls', async () => {
+      expect(toolManager.activeCalls.size).toBe(0);
+      
+      const promise = toolManager.executeToolCall('session-123', 'search', { query: 'test' });
+      
+      // Should have active call during execution
+      expect(toolManager.activeCalls.size).toBe(1);
+      
+      await promise;
+      
+      // Should still have the call (cleaned up after timeout)
+      expect(toolManager.activeCalls.size).toBe(1);
+    });
+    
+    test('should get tool call status', async () => {
+      const promise = toolManager.executeToolCall('session-123', 'search', { query: 'test' });
+      
+      // Get the tool call ID from the active calls
+      const toolCallId = Array.from(toolManager.activeCalls.keys())[0];
+      
+      const status = toolManager.getToolCallStatus(toolCallId);
+      expect(status).toBeDefined();
+      expect(status.name).toBe('search');
+      expect(status.sessionId).toBe('session-123');
+      
+      await promise;
+      
+      const completedStatus = toolManager.getToolCallStatus(toolCallId);
+      expect(completedStatus.status).toBe(ToolCallStatus.COMPLETED);
+    });
+    
+    test('should get active tool calls for session', async () => {
+      await toolManager.executeToolCall('session-123', 'search', { query: 'test1' });
+      await toolManager.executeToolCall('session-123', 'query', { pattern: 'test' });
+      await toolManager.executeToolCall('session-456', 'extract', { files: ['test.rs'] });
+      
+      const session123Calls = toolManager.getActiveToolCalls('session-123');
+      const session456Calls = toolManager.getActiveToolCalls('session-456');
+      
+      expect(session123Calls).toHaveLength(2);
+      expect(session456Calls).toHaveLength(1);
+      
+      expect(session123Calls[0].name).toBe('search');
+      expect(session123Calls[1].name).toBe('query');
+      expect(session456Calls[0].name).toBe('extract');
+    });
+    
+    test('should cancel session tool calls', () => {
+      // Start some tool calls without awaiting
+      toolManager.executeToolCall('session-123', 'search', { query: 'test1' });
+      toolManager.executeToolCall('session-123', 'query', { pattern: 'test' });
+      toolManager.executeToolCall('session-456', 'extract', { files: ['test.rs'] });
+      
+      // Cancel session 123 calls
+      toolManager.cancelSessionToolCalls('session-123');
+      
+      // Should send cancellation notifications
+      expect(mockServer.sendToolCallProgress).toHaveBeenCalledWith(
+        'session-123', expect.any(String), ToolCallStatus.FAILED, null, 'Cancelled'
+      );
+      
+      // Session 456 calls should not be affected
+      const session456Calls = toolManager.getActiveToolCalls('session-456');
+      expect(session456Calls).toHaveLength(1);
+      expect(session456Calls[0].status).not.toBe(ToolCallStatus.FAILED);
+    });
+  });
+  
+  describe('tool definitions', () => {
+    test('should provide correct tool definitions', () => {
+      const definitions = ACPToolManager.getToolDefinitions();
+      
+      expect(definitions).toHaveLength(4);
+      
+      const searchTool = definitions.find(d => d.name === 'search');
+      expect(searchTool).toBeDefined();
+      expect(searchTool.kind).toBe(ToolCallKind.search);
+      expect(searchTool.inputSchema.properties.query).toBeDefined();
+      expect(searchTool.inputSchema.required).toContain('query');
+
+      const queryTool = definitions.find(d => d.name === 'query');
+      expect(queryTool).toBeDefined();
+      expect(queryTool.kind).toBe(ToolCallKind.query);
+      expect(queryTool.inputSchema.properties.pattern).toBeDefined();
+      expect(queryTool.inputSchema.required).toContain('pattern');
+
+      const extractTool = definitions.find(d => d.name === 'extract');
+      expect(extractTool).toBeDefined();
+      expect(extractTool.kind).toBe(ToolCallKind.extract);
+      expect(extractTool.inputSchema.properties.files).toBeDefined();
+      expect(extractTool.inputSchema.required).toContain('files');
+
+      const delegateTool = definitions.find(d => d.name === 'delegate');
+      expect(delegateTool).toBeDefined();
+      expect(delegateTool.kind).toBe(ToolCallKind.execute);
+      expect(delegateTool.inputSchema.properties.task).toBeDefined();
+      expect(delegateTool.inputSchema.required).toContain('task');
+    });
+  });
+  
+  describe('cleanup', () => {
+    beforeEach(() => {
+      jest.useFakeTimers();
+    });
+    
+    afterEach(() => {
+      jest.useRealTimers();
+    });
+    
+    test('should clean up completed tool calls after timeout', async () => {
+      await toolManager.executeToolCall('session-123', 'search', { query: 'test' });
+      
+      expect(toolManager.activeCalls.size).toBe(1);
+      
+      // Fast-forward time by 30 seconds
+      jest.advanceTimersByTime(30000);
+      
+      expect(toolManager.activeCalls.size).toBe(0);
+    });
+  });
+});