@probelabs/probe 0.6.0-rc100

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

@@ -0,0 +1,410 @@
+#!/usr/bin/env node
+
+/**
+ * Manual ACP Test - Comprehensive testing of the ACP implementation
+ * 
+ * This test spawns the ACP server and sends real protocol messages to verify
+ * the complete functionality including initialization, sessions, and AI interactions.
+ */
+
+import { spawn } from 'child_process';
+import { randomUUID } from 'crypto';
+
+class ACPManualTest {
+  constructor() {
+    this.server = null;
+    this.messageId = 1;
+    this.pendingRequests = new Map();
+    this.buffer = '';
+    this.sessionId = null;
+    this.testResults = [];
+  }
+
+  async startServer() {
+    console.log('🚀 Starting ACP Server...');
+    
+    // Start the ACP server with verbose output
+    this.server = spawn('node', ['src/agent/index.js', '--acp', '--verbose'], {
+      cwd: '/Users/leonidbugaev/conductor/repo/probe/buger-belgrade/npm',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // Handle server debug output
+    this.server.stderr.on('data', (data) => {
+      const output = data.toString().trim();
+      if (output) {
+        // Check if this looks like a JSON-RPC message that was mislabeled
+        const lines = output.split('\n');
+        for (const line of lines) {
+          if (line.trim().startsWith('{"jsonrpc"')) {
+            this.buffer += line + '\n';
+            this.processBuffer();
+          } else if (line.trim()) {
+            console.log(`🔍 Server: ${line}`);
+          }
+        }
+      }
+    });
+
+    // Handle server responses (JSON-RPC messages on stdout)
+    this.server.stdout.on('data', (data) => {
+      this.buffer += data.toString();
+      this.processBuffer();
+    });
+
+    this.server.on('close', (code) => {
+      console.log(`📴 Server closed with code ${code}`);
+    });
+
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log('✅ Server started\n');
+  }
+
+  processBuffer() {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+    
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const message = JSON.parse(line);
+          this.handleMessage(message);
+        } catch (error) {
+          console.log(`⚠️  Failed to parse: ${line}`);
+        }
+      }
+    }
+  }
+
+  handleMessage(message) {
+    if (message.id && this.pendingRequests.has(message.id)) {
+      // Response to our request
+      const { resolve, reject } = this.pendingRequests.get(message.id);
+      this.pendingRequests.delete(message.id);
+      
+      if (message.error) {
+        reject(new Error(`RPC Error ${message.error.code}: ${message.error.message}`));
+      } else {
+        resolve(message.result);
+      }
+    } else if (message.method) {
+      // Notification from server
+      console.log(`📨 Notification: ${message.method}`, JSON.stringify(message.params, null, 2));
+    }
+  }
+
+  async sendRequest(method, params = null, description = '') {
+    const id = this.messageId++;
+    const message = {
+      jsonrpc: '2.0',
+      method,
+      id
+    };
+    
+    if (params !== null) {
+      message.params = params;
+    }
+    
+    console.log(`📤 Sending: ${description || method}`);
+    if (params) {
+      console.log(`   Params: ${JSON.stringify(params, null, 2)}`);
+    }
+    
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      
+      // Send to server
+      this.server.stdin.write(JSON.stringify(message) + '\n');
+      
+      // Timeout after 30 seconds
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error('Request timeout'));
+        }
+      }, 30000);
+    });
+  }
+
+  async runTest(testName, testFn) {
+    try {
+      console.log(`\n🧪 Running: ${testName}`);
+      console.log('-'.repeat(50));
+      
+      const result = await testFn();
+      
+      console.log(`✅ ${testName} - PASSED`);
+      this.testResults.push({ name: testName, status: 'PASSED', result });
+      
+      return result;
+    } catch (error) {
+      console.log(`❌ ${testName} - FAILED`);
+      console.log(`   Error: ${error.message}`);
+      this.testResults.push({ name: testName, status: 'FAILED', error: error.message });
+      
+      throw error;
+    }
+  }
+
+  async test1_Initialize() {
+    return this.runTest('Initialize Protocol', async () => {
+      const result = await this.sendRequest('initialize', {
+        protocolVersion: '1'
+      }, 'Initialize ACP protocol');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      // Verify response
+      if (result.protocolVersion !== '1') {
+        throw new Error('Wrong protocol version in response');
+      }
+      
+      if (!result.serverInfo || result.serverInfo.name !== 'probe-agent-acp') {
+        throw new Error('Invalid server info');
+      }
+      
+      if (!result.capabilities || !Array.isArray(result.capabilities.tools)) {
+        throw new Error('Invalid capabilities');
+      }
+      
+      console.log(`   ✓ Protocol version: ${result.protocolVersion}`);
+      console.log(`   ✓ Server: ${result.serverInfo.name} v${result.serverInfo.version}`);
+      console.log(`   ✓ Tools: ${result.capabilities.tools.length} available`);
+      console.log(`   ✓ Sessions: ${result.capabilities.sessionManagement}`);
+      
+      return result;
+    });
+  }
+
+  async test2_CreateSession() {
+    return this.runTest('Create New Session', async () => {
+      const result = await this.sendRequest('newSession', {}, 'Create new session');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      if (!result.sessionId) {
+        throw new Error('No session ID returned');
+      }
+      
+      if (result.mode !== 'normal') {
+        throw new Error('Wrong default mode');
+      }
+      
+      this.sessionId = result.sessionId;
+      
+      console.log(`   ✓ Session ID: ${this.sessionId}`);
+      console.log(`   ✓ Mode: ${result.mode}`);
+      console.log(`   ✓ Created: ${result.createdAt}`);
+      
+      return result;
+    });
+  }
+
+  async test3_LoadSession() {
+    return this.runTest('Load Existing Session', async () => {
+      const result = await this.sendRequest('loadSession', {
+        sessionId: this.sessionId
+      }, 'Load session');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      if (result.id !== this.sessionId) {
+        throw new Error('Wrong session ID in response');
+      }
+      
+      console.log(`   ✓ Loaded session: ${result.id}`);
+      console.log(`   ✓ Mode: ${result.mode}`);
+      console.log(`   ✓ History length: ${result.historyLength}`);
+      
+      return result;
+    });
+  }
+
+  async test4_SetSessionMode() {
+    return this.runTest('Set Session Mode', async () => {
+      const result = await this.sendRequest('setSessionMode', {
+        sessionId: this.sessionId,
+        mode: 'planning'
+      }, 'Set session to planning mode');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      if (!result.success) {
+        throw new Error('Mode change failed');
+      }
+      
+      console.log(`   ✓ Mode changed to: planning`);
+      
+      return result;
+    });
+  }
+
+  async test5_SimplePrompt() {
+    return this.runTest('Simple Prompt (No AI)', async () => {
+      // Use a simple question that doesn't require AI API calls
+      const result = await this.sendRequest('prompt', {
+        sessionId: this.sessionId,
+        message: 'List the files in the current directory'
+      }, 'Send simple prompt');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      if (!result.content || !Array.isArray(result.content)) {
+        throw new Error('Invalid content format');
+      }
+      
+      if (result.content.length === 0) {
+        throw new Error('Empty content array');
+      }
+      
+      const textContent = result.content.find(c => c.type === 'text');
+      if (!textContent) {
+        throw new Error('No text content found');
+      }
+      
+      console.log(`   ✓ Content blocks: ${result.content.length}`);
+      console.log(`   ✓ Response length: ${textContent.text.length} chars`);
+      console.log(`   ✓ Session ID: ${result.sessionId}`);
+      console.log(`   ✓ Timestamp: ${result.timestamp}`);
+      
+      return result;
+    });
+  }
+
+  async test6_Cancel() {
+    return this.runTest('Cancel Operation', async () => {
+      const result = await this.sendRequest('cancel', {
+        sessionId: this.sessionId
+      }, 'Cancel session operations');
+      
+      console.log(`📥 Response:`, JSON.stringify(result, null, 2));
+      
+      if (!result.success) {
+        throw new Error('Cancel failed');
+      }
+      
+      console.log(`   ✓ Cancellation successful`);
+      
+      return result;
+    });
+  }
+
+  async test7_ErrorHandling() {
+    return this.runTest('Error Handling', async () => {
+      try {
+        await this.sendRequest('invalidMethod', {}, 'Send invalid method');
+        throw new Error('Should have failed with invalid method');
+      } catch (error) {
+        if (!error.message.includes('RPC Error -32601')) {
+          throw new Error(`Wrong error type: ${error.message}`);
+        }
+        
+        console.log(`   ✓ Correctly rejected invalid method`);
+        console.log(`   ✓ Error: ${error.message}`);
+        
+        return { error: error.message };
+      }
+    });
+  }
+
+  async test8_InvalidSession() {
+    return this.runTest('Invalid Session Handling', async () => {
+      try {
+        await this.sendRequest('loadSession', {
+          sessionId: 'nonexistent-session-id'
+        }, 'Try to load nonexistent session');
+        throw new Error('Should have failed with invalid session');
+      } catch (error) {
+        if (!error.message.includes('Session not found')) {
+          throw new Error(`Wrong error type: ${error.message}`);
+        }
+        
+        console.log(`   ✓ Correctly rejected invalid session`);
+        console.log(`   ✓ Error: ${error.message}`);
+        
+        return { error: error.message };
+      }
+    });
+  }
+
+  async runAllTests() {
+    console.log('🧪 ACP Manual Test Suite');
+    console.log('='.repeat(60));
+    console.log('This will test the complete ACP implementation with a real server');
+    console.log();
+    
+    try {
+      await this.startServer();
+      
+      // Run tests in sequence
+      await this.test1_Initialize();
+      await this.test2_CreateSession();
+      await this.test3_LoadSession();
+      await this.test4_SetSessionMode();
+      await this.test5_SimplePrompt();
+      await this.test6_Cancel();
+      await this.test7_ErrorHandling();
+      await this.test8_InvalidSession();
+      
+    } catch (error) {
+      console.log(`\n💥 Test suite failed: ${error.message}`);
+    } finally {
+      this.cleanup();
+    }
+    
+    this.showResults();
+  }
+
+  cleanup() {
+    console.log('\n🧹 Cleaning up...');
+    if (this.server) {
+      this.server.stdin.end();
+      this.server.kill('SIGTERM');
+      
+      // Force kill if still running after 2 seconds
+      setTimeout(() => {
+        if (this.server && !this.server.killed) {
+          this.server.kill('SIGKILL');
+        }
+      }, 2000);
+    }
+  }
+
+  showResults() {
+    console.log('\n📊 Test Results Summary');
+    console.log('='.repeat(40));
+    
+    const passed = this.testResults.filter(t => t.status === 'PASSED').length;
+    const failed = this.testResults.filter(t => t.status === 'FAILED').length;
+    
+    for (const result of this.testResults) {
+      const icon = result.status === 'PASSED' ? '✅' : '❌';
+      console.log(`${icon} ${result.name}`);
+      if (result.error) {
+        console.log(`     ${result.error}`);
+      }
+    }
+    
+    console.log();
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${failed}`);
+    console.log(`Total:  ${this.testResults.length}`);
+    
+    if (failed === 0) {
+      console.log('\n🎉 All tests passed! ACP implementation is working correctly.');
+    } else {
+      console.log(`\n⚠️  ${failed} test(s) failed. Check the errors above.`);
+    }
+  }
+}
+
+// Handle Ctrl+C gracefully
+process.on('SIGINT', () => {
+  console.log('\n⏹️  Test interrupted');
+  process.exit(0);
+});
+
+// Run the manual test
+const test = new ACPManualTest();
+test.runAllTests().catch(console.error);

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

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * Protocol-Only Test - Tests ACP implementation without AI dependencies
+ * This focuses on the protocol mechanics without requiring API keys
+ */
+
+import { spawn } from 'child_process';
+
+class ProtocolTest {
+  constructor() {
+    this.server = null;
+    this.messageId = 1;
+    this.pendingRequests = new Map();
+    this.buffer = '';
+  }
+
+  async startServer() {
+    console.log('🚀 Starting ACP Server (Protocol Test)...');
+    
+    this.server = spawn('node', ['src/agent/index.js', '--acp'], {
+      cwd: '/Users/leonidbugaev/conductor/repo/probe/buger-belgrade/npm',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    this.server.stderr.on('data', (data) => {
+      const output = data.toString().trim();
+      if (output && output.includes('[ACP]')) {
+        console.log(`🔍 ${output}`);
+      }
+    });
+
+    this.server.stdout.on('data', (data) => {
+      this.buffer += data.toString();
+      this.processBuffer();
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('✅ Server ready\n');
+  }
+
+  processBuffer() {
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || '';
+    
+    for (const line of lines) {
+      if (line.trim()) {
+        try {
+          const message = JSON.parse(line);
+          this.handleMessage(message);
+        } catch (error) {
+          console.log(`⚠️  Non-JSON: ${line.substring(0, 50)}...`);
+        }
+      }
+    }
+  }
+
+  handleMessage(message) {
+    if (message.id && this.pendingRequests.has(message.id)) {
+      const { resolve, reject } = this.pendingRequests.get(message.id);
+      this.pendingRequests.delete(message.id);
+      
+      if (message.error) {
+        reject(new Error(`${message.error.code}: ${message.error.message}`));
+      } else {
+        resolve(message.result);
+      }
+    } else if (message.method) {
+      console.log(`📨 Notification: ${message.method}`);
+      if (message.params) {
+        console.log(`   ${JSON.stringify(message.params, null, 4)}`);
+      }
+    }
+  }
+
+  async sendRequest(method, params = null) {
+    const id = this.messageId++;
+    const message = { jsonrpc: '2.0', method, id };
+    if (params !== null) message.params = params;
+    
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+      this.server.stdin.write(JSON.stringify(message) + '\n');
+      
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error('Timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  async runProtocolTest() {
+    console.log('🧪 ACP Protocol Functionality Test');
+    console.log('='.repeat(50));
+    
+    try {
+      await this.startServer();
+      
+      // Test 1: Initialize
+      console.log('1️⃣ Testing Protocol Initialization');
+      const initResult = await this.sendRequest('initialize', { protocolVersion: '1' });
+      console.log(`   ✅ Version: ${initResult.protocolVersion}`);
+      console.log(`   ✅ Server: ${initResult.serverInfo.name}`);
+      console.log(`   ✅ Tools: ${initResult.capabilities.tools.length}`);
+      console.log();
+      
+      // Test 2: Session Creation
+      console.log('2️⃣ Testing Session Management');
+      const sessionResult = await this.sendRequest('newSession', {});
+      const sessionId = sessionResult.sessionId;
+      console.log(`   ✅ Created session: ${sessionId.substring(0, 8)}...`);
+      console.log();
+      
+      // Test 3: Session Loading
+      console.log('3️⃣ Testing Session Loading');
+      const loadResult = await this.sendRequest('loadSession', { sessionId });
+      console.log(`   ✅ Loaded session: ${loadResult.id.substring(0, 8)}...`);
+      console.log(`   ✅ History length: ${loadResult.historyLength}`);
+      console.log();
+      
+      // Test 4: Mode Changes
+      console.log('4️⃣ Testing Session Mode Changes');
+      await this.sendRequest('setSessionMode', { sessionId, mode: 'planning' });
+      console.log(`   ✅ Mode changed to planning`);
+      console.log();
+      
+      // Test 5: Error Handling
+      console.log('5️⃣ Testing Error Handling');
+      try {
+        await this.sendRequest('unknownMethod', {});
+        console.log(`   ❌ Should have failed`);
+      } catch (error) {
+        if (error.message.includes('-32601')) {
+          console.log(`   ✅ Correctly rejected unknown method`);
+        } else {
+          console.log(`   ❌ Wrong error: ${error.message}`);
+        }
+      }
+      console.log();
+      
+      // Test 6: Invalid Session
+      console.log('6️⃣ Testing Invalid Session Handling');
+      try {
+        await this.sendRequest('loadSession', { sessionId: 'invalid' });
+        console.log(`   ❌ Should have failed`);
+      } catch (error) {
+        if (error.message.includes('Session not found')) {
+          console.log(`   ✅ Correctly rejected invalid session`);
+        } else {
+          console.log(`   ❌ Wrong error: ${error.message}`);
+        }
+      }
+      console.log();
+      
+      // Test 7: Cancellation
+      console.log('7️⃣ Testing Cancellation');
+      const cancelResult = await this.sendRequest('cancel', { sessionId });
+      console.log(`   ✅ Cancel successful: ${cancelResult.success}`);
+      console.log();
+      
+      console.log('🎉 All Protocol Tests Passed!');
+      console.log();
+      console.log('📋 Summary:');
+      console.log('   • JSON-RPC 2.0 communication: ✅');
+      console.log('   • Protocol initialization: ✅');
+      console.log('   • Session management: ✅');
+      console.log('   • Mode changes with notifications: ✅');
+      console.log('   • Error handling: ✅');
+      console.log('   • Request validation: ✅');
+      console.log('   • Cancellation support: ✅');
+      
+    } catch (error) {
+      console.log(`❌ Test failed: ${error.message}`);
+    } finally {
+      this.cleanup();
+    }
+  }
+
+  cleanup() {
+    if (this.server) {
+      this.server.stdin.end();
+      this.server.kill();
+    }
+  }
+}
+
+const test = new ProtocolTest();
+test.runProtocolTest().catch(console.error);