intent-hub 0.1.0

package/scripts/test-e2e.ts

@@ -0,0 +1,194 @@
+import { WebSocketServer, WebSocket } from 'ws';
+
+const PORT = 9878;
+
+console.log('🧪 Direct Integration Test\n');
+console.log('━'.repeat(50));
+
+const clients = new Map<string, { socket: WebSocket; userId: string; username: string }>();
+const locks = new Map<string, { userId: string; username: string }>();
+
+const wss = new WebSocketServer({ port: PORT });
+console.log(`[Server] Started on port ${PORT}`);
+
+wss.on('connection', (socket) => {
+  console.log('[Server] New connection');
+  
+  socket.on('message', (data) => {
+    const msg = JSON.parse(data.toString());
+    console.log(`[Server] Received: ${msg.type}`);
+    
+    if (msg.type === 'agent:connect') {
+      const sessionId = `ses_${Date.now()}`;
+      clients.set(sessionId, {
+        socket,
+        userId: msg.payload.userId,
+        username: msg.payload.username,
+      });
+      
+      socket.send(JSON.stringify({
+        type: 'hub:connected',
+        timestamp: Date.now(),
+        messageId: `msg_${Date.now()}`,
+        payload: { sessionId, activeLocks: [] },
+      }));
+      console.log(`[Server] Client connected: ${msg.payload.username}`);
+    }
+    
+    if (msg.type === 'agent:intent:submit') {
+      const prompt = msg.payload.prompt.toLowerCase();
+      let domain = 'general';
+      
+      if (prompt.includes('oauth') || prompt.includes('로그인') || prompt.includes('auth')) {
+        domain = 'auth';
+      } else if (prompt.includes('결제') || prompt.includes('payment')) {
+        domain = 'payment';
+      }
+      
+      let client: { socket: WebSocket; userId: string; username: string } | undefined;
+      for (const c of clients.values()) {
+        if (c.socket === socket) {
+          client = c;
+          break;
+        }
+      }
+      if (!client) return;
+      
+      const existingLock = locks.get(domain);
+      if (existingLock && existingLock.userId !== client.userId) {
+        socket.send(JSON.stringify({
+          type: 'hub:lock:blocked',
+          timestamp: Date.now(),
+          messageId: `msg_${Date.now()}`,
+          payload: {
+            intentId: `int_${Date.now()}`,
+            blockedBy: [{ domain, username: existingLock.username, intentSummary: 'working' }],
+          },
+        }));
+        console.log(`[Server] ${client.username} BLOCKED on ${domain} by ${existingLock.username}`);
+      } else {
+        locks.set(domain, { userId: client.userId, username: client.username });
+        socket.send(JSON.stringify({
+          type: 'hub:lock:acquired',
+          timestamp: Date.now(),
+          messageId: `msg_${Date.now()}`,
+          payload: { intentId: `int_${Date.now()}`, domains: [domain] },
+        }));
+        console.log(`[Server] ${client.username} ACQUIRED lock on ${domain}`);
+      }
+    }
+  });
+});
+
+async function sleep(ms: number) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+async function runTest() {
+  await sleep(300);
+  
+  console.log('\n[Test] Connecting Alice...');
+  const alice = new WebSocket(`ws://localhost:${PORT}`);
+  
+  await new Promise<void>((resolve) => {
+    alice.on('open', () => {
+      alice.send(JSON.stringify({
+        type: 'agent:connect',
+        timestamp: Date.now(),
+        messageId: 'msg_1',
+        payload: { userId: 'alice', username: 'Alice', projectPath: '/p' },
+      }));
+    });
+    alice.on('message', (data) => {
+      const msg = JSON.parse(data.toString());
+      if (msg.type === 'hub:connected') {
+        console.log('[Test] Alice connected!');
+        resolve();
+      }
+    });
+  });
+  
+  console.log('[Test] Connecting Bob...');
+  const bob = new WebSocket(`ws://localhost:${PORT}`);
+  
+  await new Promise<void>((resolve) => {
+    bob.on('open', () => {
+      bob.send(JSON.stringify({
+        type: 'agent:connect',
+        timestamp: Date.now(),
+        messageId: 'msg_2',
+        payload: { userId: 'bob', username: 'Bob', projectPath: '/p' },
+      }));
+    });
+    bob.on('message', (data) => {
+      const msg = JSON.parse(data.toString());
+      if (msg.type === 'hub:connected') {
+        console.log('[Test] Bob connected!');
+        resolve();
+      }
+    });
+  });
+  
+  const results: string[] = [];
+  
+  alice.on('message', (data) => {
+    const msg = JSON.parse(data.toString());
+    if (msg.type === 'hub:lock:acquired') {
+      results.push(`Alice ACQUIRED ${msg.payload.domains.join(',')}`);
+    } else if (msg.type === 'hub:lock:blocked') {
+      results.push(`Alice BLOCKED`);
+    }
+  });
+  
+  bob.on('message', (data) => {
+    const msg = JSON.parse(data.toString());
+    if (msg.type === 'hub:lock:acquired') {
+      results.push(`Bob ACQUIRED ${msg.payload.domains.join(',')}`);
+    } else if (msg.type === 'hub:lock:blocked') {
+      results.push(`Bob BLOCKED`);
+    }
+  });
+  
+  console.log('\n[Test] Alice: "Google OAuth 로그인"');
+  alice.send(JSON.stringify({
+    type: 'agent:intent:submit',
+    timestamp: Date.now(),
+    messageId: 'msg_3',
+    payload: { prompt: 'Google OAuth 로그인' },
+  }));
+  await sleep(100);
+  
+  console.log('[Test] Bob: "로그인 세션 관리"');
+  bob.send(JSON.stringify({
+    type: 'agent:intent:submit',
+    timestamp: Date.now(),
+    messageId: 'msg_4',
+    payload: { prompt: '로그인 세션 관리' },
+  }));
+  await sleep(100);
+  
+  console.log('[Test] Bob: "결제 기능"');
+  bob.send(JSON.stringify({
+    type: 'agent:intent:submit',
+    timestamp: Date.now(),
+    messageId: 'msg_5',
+    payload: { prompt: '결제 기능' },
+  }));
+  await sleep(200);
+  
+  console.log('\n━'.repeat(50));
+  console.log('Results:', results);
+  
+  const pass = results.includes('Alice ACQUIRED auth') &&
+               results.includes('Bob BLOCKED') &&
+               results.includes('Bob ACQUIRED payment');
+               
+  console.log(pass ? '\n✅ TEST PASSED!' : '\n❌ TEST FAILED');
+  
+  alice.close();
+  bob.close();
+  wss.close();
+  process.exit(pass ? 0 : 1);
+}
+
+runTest().catch(console.error);

package/scripts/test-mvp2.ts

@@ -0,0 +1,167 @@
+import { 
+  Orchestrator, 
+  type OrchestratorConfig,
+  type IntentRequest,
+} from '../packages/hub/dist/index.js';
+
+console.log('🧪 MVP 2 - LLM Negotiation E2E Test\n');
+console.log('━'.repeat(60));
+
+class TestMockProvider {
+  name = 'test-mock';
+
+  async complete() {
+    return { content: 'mock response', model: 'test' };
+  }
+
+  async completeJSON<T>(messages: Array<{ role: string; content: string }>): Promise<T> {
+    const lastMessage = messages[messages.length - 1]?.content || '';
+    
+    if (lastMessage.includes('OAuth') || lastMessage.includes('oauth')) {
+      return {
+        domain: 'auth',
+        subdomain: 'oauth',
+        affectedFiles: ['src/auth/oauth.ts'],
+        semanticTags: ['login', 'oauth', 'google'],
+        estimatedScope: 'medium',
+        dependencies: [],
+        summary: 'OAuth implementation',
+      } as T;
+    }
+    
+    if (lastMessage.includes('세션') || lastMessage.includes('session')) {
+      return {
+        domain: 'auth',
+        subdomain: 'session',
+        affectedFiles: ['src/auth/session.ts'],
+        semanticTags: ['session', 'login'],
+        estimatedScope: 'medium',
+        dependencies: ['auth'],
+        summary: 'Session management',
+      } as T;
+    }
+
+    if (lastMessage.includes('결제') || lastMessage.includes('payment')) {
+      return {
+        domain: 'payment',
+        subdomain: 'checkout',
+        affectedFiles: ['src/payment/checkout.ts'],
+        semanticTags: ['payment', 'checkout'],
+        estimatedScope: 'medium',
+        dependencies: [],
+        summary: 'Payment checkout',
+      } as T;
+    }
+    
+    return {
+      domain: 'general',
+      affectedFiles: [],
+      semanticTags: [],
+      estimatedScope: 'small',
+      dependencies: [],
+      summary: 'General task',
+    } as T;
+  }
+}
+
+async function runTest() {
+  const provider = new TestMockProvider() as any;
+  const notifications: Array<{ sessionId: string; event: string; data: any }> = [];
+  
+  const config: OrchestratorConfig = {
+    useLLMAnalysis: true,
+    autoNegotiate: false,
+    conflictThreshold: 'medium',
+  };
+
+  const orchestrator = new Orchestrator(
+    provider,
+    config,
+    (sessionId, event, data) => {
+      notifications.push({ sessionId, event, data });
+      console.log(`   📢 Notification to ${sessionId}: ${event}`);
+    }
+  );
+
+  console.log('\n1️⃣  Alice: "Google OAuth 구현"\n');
+  
+  const aliceResponse = await orchestrator.processIntent({
+    sessionId: 'ses_alice',
+    userId: 'alice',
+    username: 'Alice',
+    prompt: 'Google OAuth 로그인 구현해줘',
+  });
+  console.log(`   Status: ${aliceResponse.status}`);
+  console.log(`   Domain: ${aliceResponse.domains.join(', ')}`);
+  console.log(`   Analysis: ${aliceResponse.analysis.summary}`);
+
+  console.log('\n2️⃣  Bob: "세션 관리 구현" (같은 auth 도메인)\n');
+  
+  const bobResponse = await orchestrator.processIntent({
+    sessionId: 'ses_bob',
+    userId: 'bob',
+    username: 'Bob',
+    prompt: '로그인 세션 관리 기능 추가해줘',
+  });
+  console.log(`   Status: ${bobResponse.status}`);
+  console.log(`   Domain: ${bobResponse.domains.join(', ')}`);
+  if (bobResponse.blockedBy) {
+    console.log(`   Blocked by: ${bobResponse.blockedBy.map(b => `${b.username} (${b.reason})`).join(', ')}`);
+  }
+
+  console.log('\n3️⃣  Carol: "결제 기능" (다른 도메인)\n');
+  
+  const carolResponse = await orchestrator.processIntent({
+    sessionId: 'ses_carol',
+    userId: 'carol',
+    username: 'Carol',
+    prompt: '결제 기능 추가해줘',
+  });
+  console.log(`   Status: ${carolResponse.status}`);
+  console.log(`   Domain: ${carolResponse.domains.join(', ')}`);
+
+  console.log('\n4️⃣  Alice 작업 완료 → Bob 재시도\n');
+  
+  orchestrator.completeIntent(aliceResponse.intentId, 'alice');
+  console.log('   Alice completed her work');
+
+  const bobRetry = await orchestrator.processIntent({
+    sessionId: 'ses_bob',
+    userId: 'bob',
+    username: 'Bob',
+    prompt: '로그인 세션 관리 기능 추가해줘',
+  });
+  console.log(`   Bob retry status: ${bobRetry.status}`);
+
+  console.log('\n' + '━'.repeat(60));
+  
+  const status = orchestrator.getStatus();
+  console.log(`\n📊 Orchestrator Status:`);
+  console.log(`   Active intents: ${status.activeIntents}`);
+  console.log(`   Active locks: ${status.activeLocks}`);
+
+  const aliceApproved = aliceResponse.status === 'approved';
+  const bobBlocked = bobResponse.status === 'blocked';
+  const carolApproved = carolResponse.status === 'approved';
+  const bobRetryApproved = bobRetry.status === 'approved';
+  
+  console.log('\n' + '━'.repeat(60));
+  
+  if (aliceApproved && bobBlocked && carolApproved && bobRetryApproved) {
+    console.log('\n✅ MVP 2 Test PASSED!\n');
+    console.log('   ✓ Alice approved (auth:oauth)');
+    console.log('   ✓ Bob blocked (same domain conflict)');
+    console.log('   ✓ Carol approved (different domain: payment)');
+    console.log('   ✓ Bob retry approved (after Alice completed)');
+  } else {
+    console.log('\n❌ MVP 2 Test FAILED!\n');
+    console.log(`   Alice: ${aliceResponse.status} (expected: approved)`);
+    console.log(`   Bob: ${bobResponse.status} (expected: blocked)`);
+    console.log(`   Carol: ${carolResponse.status} (expected: approved)`);
+    console.log(`   Bob retry: ${bobRetry.status} (expected: approved)`);
+  }
+
+  process.exit(aliceApproved && bobBlocked && carolApproved && bobRetryApproved ? 0 : 1);
+}
+
+runTest().catch(console.error);