@probelabs/probe 0.6.0-rc100

package/build/agent/acp/server.test.js

@@ -0,0 +1,371 @@
+// Tests for ACP Server
+import { jest } from '@jest/globals';
+import { ACPServer } from './server.js';
+import { ACPConnection } from './connection.js';
+import { ACP_PROTOCOL_VERSION, RequestMethod, SessionMode, ErrorCode } from './types.js';
+
+// Mock manually handled below
+
+describe('ACPServer', () => {
+  let server;
+  let mockConnection;
+  
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+    
+    // Create mock connection
+    mockConnection = {
+      start: jest.fn(),
+      sendResponse: jest.fn(),
+      sendError: jest.fn(),
+      sendNotification: jest.fn(),
+      on: jest.fn()
+    };
+    
+    // Mock the ACPConnection constructor
+    ACPConnection.mockImplementation(() => mockConnection);
+    
+    server = new ACPServer({
+      debug: true,
+      provider: 'anthropic',
+      path: '/test/path'
+    });
+  });
+  
+  describe('initialization', () => {
+    test('should create server with default options', () => {
+      const defaultServer = new ACPServer();
+      expect(defaultServer.options.debug).toBe(false);
+      expect(defaultServer.sessions.size).toBe(0);
+      expect(defaultServer.initialized).toBe(false);
+    });
+    
+    test('should create server with custom options', () => {
+      expect(server.options.debug).toBe(true);
+      expect(server.options.provider).toBe('anthropic');
+      expect(server.options.path).toBe('/test/path');
+    });
+    
+    test('should have correct capabilities', () => {
+      const capabilities = server.getCapabilities();
+      expect(capabilities.tools).toHaveLength(3);
+      expect(capabilities.tools[0].name).toBe('search');
+      expect(capabilities.tools[1].name).toBe('query');
+      expect(capabilities.tools[2].name).toBe('extract');
+      expect(capabilities.sessionManagement).toBe(true);
+      expect(capabilities.streaming).toBe(true);
+    });
+  });
+  
+  describe('server startup', () => {
+    test('should start server and setup connection', async () => {
+      await server.start();
+      
+      expect(ACPConnection).toHaveBeenCalledWith(process.stdin, process.stderr);
+      expect(mockConnection.on).toHaveBeenCalledWith('request', expect.any(Function));
+      expect(mockConnection.on).toHaveBeenCalledWith('notification', expect.any(Function));
+      expect(mockConnection.on).toHaveBeenCalledWith('error', expect.any(Function));
+      expect(mockConnection.on).toHaveBeenCalledWith('disconnect', expect.any(Function));
+      expect(mockConnection.start).toHaveBeenCalled();
+    });
+  });
+  
+  describe('initialize request', () => {
+    test('should handle valid initialize request', async () => {
+      const params = { protocolVersion: ACP_PROTOCOL_VERSION };
+      
+      const result = await server.handleInitialize(params);
+      
+      expect(result).toEqual({
+        protocolVersion: ACP_PROTOCOL_VERSION,
+        serverInfo: {
+          name: 'probe-agent-acp',
+          version: '1.0.0',
+          description: 'Probe AI agent with code search capabilities'
+        },
+        capabilities: server.capabilities
+      });
+      expect(server.initialized).toBe(true);
+    });
+    
+    test('should reject invalid protocol version', async () => {
+      const params = { protocolVersion: '2.0' };
+      
+      await expect(server.handleInitialize(params)).rejects.toThrow('Unsupported protocol version: 2.0');
+    });
+    
+    test('should require protocolVersion parameter', async () => {
+      await expect(server.handleInitialize({})).rejects.toThrow('Invalid params: protocolVersion required');
+      await expect(server.handleInitialize(null)).rejects.toThrow('Invalid params: protocolVersion required');
+    });
+  });
+  
+  describe('session management', () => {
+    test('should create new session', async () => {
+      const result = await server.handleNewSession({});
+      
+      expect(result.sessionId).toBeDefined();
+      expect(result.mode).toBe(SessionMode.NORMAL);
+      expect(result.createdAt).toBeDefined();
+      expect(server.sessions.has(result.sessionId)).toBe(true);
+    });
+    
+    test('should create session with custom ID and mode', async () => {
+      const customId = 'test-session-123';
+      const params = {
+        sessionId: customId,
+        mode: SessionMode.PLANNING
+      };
+      
+      const result = await server.handleNewSession(params);
+      
+      expect(result.sessionId).toBe(customId);
+      expect(result.mode).toBe(SessionMode.PLANNING);
+      expect(server.sessions.has(customId)).toBe(true);
+    });
+    
+    test('should load existing session', async () => {
+      // Create a session first
+      const createResult = await server.handleNewSession({});
+      const sessionId = createResult.sessionId;
+      
+      // Load the session
+      const loadResult = await server.handleLoadSession({ sessionId });
+      
+      expect(loadResult.id).toBe(sessionId);
+      expect(loadResult.mode).toBe(SessionMode.NORMAL);
+      expect(loadResult.historyLength).toBe(0);
+      expect(loadResult.toolCallsCount).toBe(0);
+    });
+    
+    test('should fail to load non-existent session', async () => {
+      const params = { sessionId: 'non-existent' };
+      
+      await expect(server.handleLoadSession(params)).rejects.toThrow('Session not found: non-existent');
+    });
+    
+    test('should set session mode', async () => {
+      // Create a session first
+      const createResult = await server.handleNewSession({});
+      const sessionId = createResult.sessionId;
+      
+      // Set mode
+      const result = await server.handleSetSessionMode({
+        sessionId,
+        mode: SessionMode.PLANNING
+      });
+      
+      expect(result.success).toBe(true);
+      expect(mockConnection.sendNotification).toHaveBeenCalledWith(
+        'sessionUpdated',
+        { sessionId, mode: SessionMode.PLANNING }
+      );
+      
+      const session = server.sessions.get(sessionId);
+      expect(session.mode).toBe(SessionMode.PLANNING);
+    });
+  });
+  
+  describe('request handling', () => {
+    test('should handle requests and send responses', async () => {
+      const message = {
+        method: RequestMethod.INITIALIZE,
+        params: { protocolVersion: ACP_PROTOCOL_VERSION },
+        id: 1
+      };
+      
+      await server.handleRequest(message);
+      
+      expect(mockConnection.sendResponse).toHaveBeenCalledWith(1, expect.objectContaining({
+        protocolVersion: ACP_PROTOCOL_VERSION
+      }));
+    });
+    
+    test('should handle unknown methods', async () => {
+      const message = {
+        method: 'unknownMethod',
+        params: {},
+        id: 2
+      };
+      
+      await server.handleRequest(message);
+      
+      expect(mockConnection.sendError).toHaveBeenCalledWith(
+        2,
+        ErrorCode.METHOD_NOT_FOUND,
+        'Unknown method: unknownMethod'
+      );
+    });
+    
+    test('should handle request errors', async () => {
+      const message = {
+        method: RequestMethod.LOAD_SESSION,
+        params: { sessionId: 'invalid' },
+        id: 3
+      };
+      
+      await server.handleRequest(message);
+      
+      expect(mockConnection.sendError).toHaveBeenCalledWith(
+        3,
+        ErrorCode.INTERNAL_ERROR,
+        'Session not found: invalid'
+      );
+    });
+  });
+  
+  describe('prompt handling', () => {
+    let mockAgent;
+    
+    beforeEach(async () => {
+      // Import and mock ProbeAgent
+      const { ProbeAgent } = await import('../ProbeAgent.js');
+      mockAgent = {
+        answer: jest.fn().mockResolvedValue('Test response'),
+        cancel: jest.fn()
+      };
+      ProbeAgent.mockImplementation(() => mockAgent);
+      
+      // Create a session
+      await server.handleNewSession({ sessionId: 'test-session' });
+    });
+    
+    test('should handle prompt request successfully', async () => {
+      const params = {
+        sessionId: 'test-session',
+        message: 'Test question'
+      };
+      
+      const result = await server.handlePrompt(params);
+      
+      expect(mockAgent.answer).toHaveBeenCalledWith('Test question');
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Test response' }],
+        sessionId: 'test-session',
+        timestamp: expect.any(String)
+      });
+      
+      // Check that history was updated
+      const session = server.sessions.get('test-session');
+      expect(session.history).toHaveLength(2);
+      expect(session.history[0].role).toBe('user');
+      expect(session.history[1].role).toBe('assistant');
+    });
+    
+    test('should handle prompt errors gracefully', async () => {
+      mockAgent.answer.mockRejectedValue(new Error('AI Error'));
+      
+      const params = {
+        sessionId: 'test-session',
+        message: 'Test question'
+      };
+      
+      const result = await server.handlePrompt(params);
+      
+      expect(result).toEqual({
+        content: [{ type: 'text', text: 'Error: AI Error' }],
+        sessionId: 'test-session',
+        timestamp: expect.any(String),
+        error: true
+      });
+    });
+    
+    test('should require sessionId and message', async () => {
+      await expect(server.handlePrompt({})).rejects.toThrow('Invalid params: sessionId and message required');
+      await expect(server.handlePrompt({ sessionId: 'test' })).rejects.toThrow('Invalid params: sessionId and message required');
+      await expect(server.handlePrompt({ message: 'test' })).rejects.toThrow('Invalid params: sessionId and message required');
+    });
+    
+    test('should require valid session', async () => {
+      const params = {
+        sessionId: 'invalid-session',
+        message: 'Test question'
+      };
+      
+      await expect(server.handlePrompt(params)).rejects.toThrow('Session not found: invalid-session');
+    });
+  });
+  
+  describe('cancel handling', () => {
+    let mockAgent;
+    
+    beforeEach(async () => {
+      const { ProbeAgent } = await import('../ProbeAgent.js');
+      mockAgent = {
+        answer: jest.fn().mockResolvedValue('Test response'),
+        cancel: jest.fn()
+      };
+      ProbeAgent.mockImplementation(() => mockAgent);
+      
+      // Create a session and trigger agent creation
+      await server.handleNewSession({ sessionId: 'test-session' });
+      await server.handlePrompt({
+        sessionId: 'test-session',
+        message: 'Test question'
+      });
+    });
+    
+    test('should cancel session operations', async () => {
+      const result = await server.handleCancel({ sessionId: 'test-session' });
+      
+      expect(mockAgent.cancel).toHaveBeenCalled();
+      expect(result.success).toBe(true);
+    });
+    
+    test('should handle cancel for session without agent', async () => {
+      await server.handleNewSession({ sessionId: 'new-session' });
+      
+      const result = await server.handleCancel({ sessionId: 'new-session' });
+      expect(result.success).toBe(true);
+    });
+    
+    test('should require sessionId for cancel', async () => {
+      await expect(server.handleCancel({})).rejects.toThrow('Invalid params: sessionId required');
+    });
+  });
+  
+  describe('disconnect handling', () => {
+    let mockAgent;
+    
+    beforeEach(async () => {
+      const { ProbeAgent } = await import('../ProbeAgent.js');
+      mockAgent = {
+        answer: jest.fn().mockResolvedValue('Test response'),
+        cancel: jest.fn()
+      };
+      ProbeAgent.mockImplementation(() => mockAgent);
+      
+      // Create sessions with agents
+      await server.handleNewSession({ sessionId: 'session1' });
+      await server.handleNewSession({ sessionId: 'session2' });
+      await server.handlePrompt({ sessionId: 'session1', message: 'test' });
+      await server.handlePrompt({ sessionId: 'session2', message: 'test' });
+    });
+    
+    test('should clean up sessions and cancel agents on disconnect', () => {
+      expect(server.sessions.size).toBe(2);
+      
+      server.handleDisconnect();
+      
+      expect(mockAgent.cancel).toHaveBeenCalledTimes(2);
+      expect(server.sessions.size).toBe(0);
+    });
+  });
+  
+  describe('stats', () => {
+    test('should return server statistics', async () => {
+      await server.handleNewSession({});
+      await server.handleNewSession({});
+      server.initialized = true;
+      
+      const stats = server.getStats();
+      
+      expect(stats).toEqual({
+        sessions: 2,
+        initialized: true,
+        capabilities: server.capabilities
+      });
+    });
+  });
+});

package/build/agent/acp/test-runner.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * Simple test runner for ACP implementation
+ * Tests basic functionality without requiring a full test framework
+ */
+
+import { ACPServer } from './server.js';
+import { ACPConnection } from './connection.js';
+import { validateMessage, createMessage, createResponse, ACP_PROTOCOL_VERSION } from './types.js';
+import { EventEmitter } from 'events';
+
+class TestRunner {
+  constructor() {
+    this.tests = [];
+    this.passed = 0;
+    this.failed = 0;
+  }
+
+  test(name, fn) {
+    this.tests.push({ name, fn });
+  }
+
+  assert(condition, message) {
+    if (!condition) {
+      throw new Error(message);
+    }
+  }
+
+  assertEqual(actual, expected, message = '') {
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+      throw new Error(`${message}\nExpected: ${JSON.stringify(expected)}\nActual: ${JSON.stringify(actual)}`);
+    }
+  }
+
+  async run() {
+    console.log('🧪 Running ACP Tests');
+    console.log('=' .repeat(40));
+
+    for (const { name, fn } of this.tests) {
+      try {
+        await fn();
+        console.log(`✅ ${name}`);
+        this.passed++;
+      } catch (error) {
+        console.log(`❌ ${name}`);
+        console.log(`   Error: ${error.message}`);
+        this.failed++;
+      }
+    }
+
+    console.log('\n📊 Test Results');
+    console.log('-'.repeat(20));
+    console.log(`Passed: ${this.passed}`);
+    console.log(`Failed: ${this.failed}`);
+    console.log(`Total:  ${this.tests.length}`);
+
+    if (this.failed > 0) {
+      process.exit(1);
+    } else {
+      console.log('\n🎉 All tests passed!');
+    }
+  }
+}
+
+const runner = new TestRunner();
+
+// Test types and utilities
+runner.test('Message validation', () => {
+  // Valid messages
+  runner.assert(validateMessage({ jsonrpc: '2.0', method: 'test' }).valid, 'Valid notification should pass');
+  runner.assert(validateMessage({ jsonrpc: '2.0', method: 'test', id: 1 }).valid, 'Valid request should pass');
+  runner.assert(validateMessage({ jsonrpc: '2.0', id: 1, result: {} }).valid, 'Valid response should pass');
+
+  // Invalid messages
+  runner.assert(!validateMessage(null).valid, 'Null should fail');
+  runner.assert(!validateMessage({ jsonrpc: '1.0', method: 'test' }).valid, 'Wrong version should fail');
+  runner.assert(!validateMessage({ jsonrpc: '2.0', id: 1 }).valid, 'Response without result/error should fail');
+});
+
+runner.test('Message creation', () => {
+  const message = createMessage('test', { param: 'value' }, 123);
+  runner.assertEqual(message, {
+    jsonrpc: '2.0',
+    method: 'test',
+    params: { param: 'value' },
+    id: 123
+  }, 'Message creation should work correctly');
+
+  const response = createResponse(456, { success: true });
+  runner.assertEqual(response, {
+    jsonrpc: '2.0',
+    id: 456,
+    result: { success: true }
+  }, 'Response creation should work correctly');
+});
+
+// Test server capabilities
+runner.test('Server capabilities', () => {
+  const server = new ACPServer();
+  const capabilities = server.getCapabilities();
+
+  runner.assert(Array.isArray(capabilities.tools), 'Should have tools array');
+  runner.assert(capabilities.tools.length === 3, 'Should have 3 tools');
+  runner.assert(capabilities.sessionManagement === true, 'Should support sessions');
+  runner.assert(capabilities.streaming === true, 'Should support streaming');
+
+  const toolNames = capabilities.tools.map(t => t.name);
+  runner.assert(toolNames.includes('search'), 'Should have search tool');
+  runner.assert(toolNames.includes('query'), 'Should have query tool');
+  runner.assert(toolNames.includes('extract'), 'Should have extract tool');
+});
+
+// Test server initialization
+runner.test('Server initialization', async () => {
+  const server = new ACPServer({ debug: false });
+
+  // Test valid initialization
+  const result = await server.handleInitialize({
+    protocolVersion: ACP_PROTOCOL_VERSION
+  });
+
+  runner.assertEqual(result.protocolVersion, ACP_PROTOCOL_VERSION, 'Should return correct version');
+  runner.assert(result.serverInfo.name === 'probe-agent-acp', 'Should have correct server name');
+  runner.assert(server.initialized === true, 'Server should be initialized');
+
+  // Test invalid protocol version
+  try {
+    await server.handleInitialize({ protocolVersion: '2.0' });
+    runner.assert(false, 'Should reject invalid protocol version');
+  } catch (error) {
+    runner.assert(error.message.includes('Unsupported protocol version'), 'Should have version error');
+  }
+});
+
+// Test session management
+runner.test('Session management', async () => {
+  const server = new ACPServer({ debug: false });
+
+  // Create session
+  const createResult = await server.handleNewSession({});
+  runner.assert(createResult.sessionId, 'Should return session ID');
+  runner.assert(createResult.mode === 'normal', 'Should default to normal mode');
+  runner.assert(server.sessions.has(createResult.sessionId), 'Should store session');
+
+  // Load session
+  const loadResult = await server.handleLoadSession({ 
+    sessionId: createResult.sessionId 
+  });
+  runner.assertEqual(loadResult.id, createResult.sessionId, 'Should load correct session');
+
+  // Set session mode
+  const modeResult = await server.handleSetSessionMode({
+    sessionId: createResult.sessionId,
+    mode: 'planning'
+  });
+  runner.assert(modeResult.success === true, 'Should set mode successfully');
+  
+  const session = server.sessions.get(createResult.sessionId);
+  runner.assertEqual(session.mode, 'planning', 'Should update session mode');
+});
+
+// Test connection (basic functionality)
+runner.test('Connection basics', () => {
+  class MockStream extends EventEmitter {
+    constructor() {
+      super();
+      this.encoding = null;
+      this.writtenData = [];
+    }
+    setEncoding(enc) { this.encoding = enc; }
+    write(data) { this.writtenData.push(data); return true; }
+  }
+
+  const input = new MockStream();
+  const output = new MockStream();
+  const connection = new ACPConnection(input, output);
+
+  connection.start();
+  runner.assert(connection.isConnected === true, 'Should be connected');
+
+  // Test message sending
+  connection.sendNotification('test', { data: 'value' });
+  runner.assert(output.writtenData.length === 1, 'Should send notification');
+
+  const sent = JSON.parse(output.writtenData[0]);
+  runner.assertEqual(sent.method, 'test', 'Should send correct method');
+  runner.assertEqual(sent.params, { data: 'value' }, 'Should send correct params');
+  runner.assert(!sent.id, 'Notification should not have ID');
+
+  connection.close();
+});
+
+// Test error handling
+runner.test('Error handling', async () => {
+  const server = new ACPServer({ debug: false });
+
+  // Test missing session
+  try {
+    await server.handleLoadSession({ sessionId: 'nonexistent' });
+    runner.assert(false, 'Should fail for nonexistent session');
+  } catch (error) {
+    runner.assert(error.message.includes('Session not found'), 'Should have session error');
+  }
+
+  // Test missing parameters
+  try {
+    await server.handlePrompt({});
+    runner.assert(false, 'Should require sessionId and message');
+  } catch (error) {
+    runner.assert(error.message.includes('Invalid params'), 'Should have params error');
+  }
+});
+
+// Run all tests
+runner.run().catch(console.error);