intent-hub 0.1.0

package/packages/hub/src/llm/provider.ts

@@ -0,0 +1,175 @@
+export interface LLMMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface LLMCompletionOptions {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+}
+
+export interface LLMCompletionResult {
+  content: string;
+  model: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+export interface LLMProvider {
+  name: string;
+  complete(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<LLMCompletionResult>;
+  completeJSON<T>(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<T>;
+}
+
+export class OpenAIProvider implements LLMProvider {
+  name = 'openai';
+  
+  constructor(private apiKey: string, private defaultModel = 'gpt-4o-mini') {}
+
+  async complete(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<LLMCompletionResult> {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: options?.model ?? this.defaultModel,
+        messages,
+        temperature: options?.temperature ?? 0.7,
+        max_tokens: options?.maxTokens ?? 2048,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return {
+      content: data.choices[0].message.content,
+      model: data.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens,
+      } : undefined,
+    };
+  }
+
+  async completeJSON<T>(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<T> {
+    const response = await fetch('https://api.openai.com/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: options?.model ?? this.defaultModel,
+        messages,
+        temperature: options?.temperature ?? 0.3,
+        max_tokens: options?.maxTokens ?? 2048,
+        response_format: { type: 'json_object' },
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return JSON.parse(data.choices[0].message.content) as T;
+  }
+}
+
+export class AnthropicProvider implements LLMProvider {
+  name = 'anthropic';
+  
+  constructor(private apiKey: string, private defaultModel = 'claude-3-5-sonnet-20241022') {}
+
+  async complete(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<LLMCompletionResult> {
+    const systemMessage = messages.find(m => m.role === 'system');
+    const otherMessages = messages.filter(m => m.role !== 'system');
+
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': this.apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model: options?.model ?? this.defaultModel,
+        max_tokens: options?.maxTokens ?? 2048,
+        system: systemMessage?.content,
+        messages: otherMessages.map(m => ({
+          role: m.role,
+          content: m.content,
+        })),
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return {
+      content: data.content[0].text,
+      model: data.model,
+      usage: data.usage ? {
+        promptTokens: data.usage.input_tokens,
+        completionTokens: data.usage.output_tokens,
+        totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+      } : undefined,
+    };
+  }
+
+  async completeJSON<T>(messages: LLMMessage[], options?: LLMCompletionOptions): Promise<T> {
+    const result = await this.complete([
+      ...messages,
+      { role: 'assistant', content: '{' },
+    ], options);
+    
+    const jsonStr = '{' + result.content;
+    return JSON.parse(jsonStr) as T;
+  }
+}
+
+export class MockProvider implements LLMProvider {
+  name = 'mock';
+
+  async complete(messages: LLMMessage[]): Promise<LLMCompletionResult> {
+    const lastMessage = messages[messages.length - 1];
+    return {
+      content: `Mock response to: ${lastMessage?.content.slice(0, 50)}...`,
+      model: 'mock-model',
+    };
+  }
+
+  async completeJSON<T>(): Promise<T> {
+    return {} as T;
+  }
+}
+
+export function createProvider(type: 'openai' | 'anthropic' | 'mock', apiKey?: string): LLMProvider {
+  switch (type) {
+    case 'openai':
+      if (!apiKey) throw new Error('OpenAI API key required');
+      return new OpenAIProvider(apiKey);
+    case 'anthropic':
+      if (!apiKey) throw new Error('Anthropic API key required');
+      return new AnthropicProvider(apiKey);
+    case 'mock':
+      return new MockProvider();
+    default:
+      throw new Error(`Unknown provider type: ${type}`);
+  }
+}

package/packages/hub/src/llm/smart-analyzer.ts

@@ -0,0 +1,169 @@
+import type { LLMProvider, LLMMessage } from './provider.js';
+import type { IntentAnalysis } from '@anthropic-for-korea/intent-hub-shared';
+
+const INTENT_ANALYSIS_PROMPT = `You are an intent analyzer for a team collaboration system. 
+Analyze the user's request and extract structured information about what they want to do.
+
+Respond in JSON format with the following structure:
+{
+  "domain": "main domain (e.g., auth, user, payment, database, api, ui, test, config, docs)",
+  "subdomain": "specific subdomain if applicable (e.g., oauth, session, profile)",
+  "affectedFiles": ["list of likely affected file paths"],
+  "semanticTags": ["relevant keywords and concepts"],
+  "estimatedScope": "small | medium | large",
+  "dependencies": ["other domains this might depend on or affect"],
+  "summary": "brief one-line summary of the intent"
+}
+
+Consider:
+- What part of the system does this affect?
+- What files would likely be modified?
+- How complex is this task?
+- What other parts of the system might be affected?`;
+
+export interface SmartIntentAnalysis extends IntentAnalysis {
+  summary: string;
+  confidence: number;
+}
+
+export class SmartIntentAnalyzer {
+  constructor(private provider: LLMProvider) {}
+
+  async analyze(prompt: string, projectContext?: string): Promise<SmartIntentAnalysis> {
+    const messages: LLMMessage[] = [
+      { role: 'system', content: INTENT_ANALYSIS_PROMPT },
+    ];
+
+    if (projectContext) {
+      messages.push({
+        role: 'user',
+        content: `Project context:\n${projectContext}\n\nNow analyze this request:`,
+      });
+    }
+
+    messages.push({
+      role: 'user',
+      content: prompt,
+    });
+
+    try {
+      const result = await this.provider.completeJSON<{
+        domain: string;
+        subdomain?: string;
+        affectedFiles: string[];
+        semanticTags: string[];
+        estimatedScope: 'small' | 'medium' | 'large';
+        dependencies: string[];
+        summary: string;
+      }>(messages, { temperature: 0.3 });
+
+      return {
+        domain: result.domain || 'general',
+        subdomain: result.subdomain,
+        affectedFiles: result.affectedFiles || [],
+        semanticTags: result.semanticTags || [],
+        estimatedScope: result.estimatedScope || 'medium',
+        dependencies: result.dependencies || [],
+        summary: result.summary || prompt.slice(0, 50),
+        confidence: 0.9,
+      };
+    } catch (error) {
+      console.error('[SmartIntentAnalyzer] LLM analysis failed, using fallback:', error);
+      return this.fallbackAnalysis(prompt);
+    }
+  }
+
+  private fallbackAnalysis(prompt: string): SmartIntentAnalysis {
+    const lowerPrompt = prompt.toLowerCase();
+    
+    const domainKeywords: Record<string, string[]> = {
+      auth: ['login', 'logout', 'auth', 'oauth', 'session', 'token', 'password', '로그인', '인증'],
+      user: ['user', 'profile', 'account', '사용자', '회원', '프로필'],
+      payment: ['payment', 'pay', 'billing', 'checkout', 'cart', '결제', '장바구니'],
+      database: ['database', 'db', 'migration', 'schema', 'model'],
+      api: ['api', 'endpoint', 'route', 'controller'],
+      ui: ['ui', 'component', 'button', 'form', 'modal', '버튼', '컴포넌트'],
+    };
+
+    let domain = 'general';
+    let maxScore = 0;
+
+    for (const [d, keywords] of Object.entries(domainKeywords)) {
+      const score = keywords.filter(kw => lowerPrompt.includes(kw)).length;
+      if (score > maxScore) {
+        maxScore = score;
+        domain = d;
+      }
+    }
+
+    return {
+      domain,
+      subdomain: undefined,
+      affectedFiles: [],
+      semanticTags: [],
+      estimatedScope: 'medium',
+      dependencies: [],
+      summary: prompt.slice(0, 50),
+      confidence: 0.5,
+    };
+  }
+
+  async checkOverlap(
+    intent1: SmartIntentAnalysis,
+    intent2: SmartIntentAnalysis
+  ): Promise<{
+    hasOverlap: boolean;
+    overlapDomains: string[];
+    overlapFiles: string[];
+    severity: 'none' | 'low' | 'medium' | 'high';
+    reason: string;
+  }> {
+    const messages: LLMMessage[] = [
+      {
+        role: 'system',
+        content: `You analyze whether two development intents might conflict with each other.
+Consider: shared files, shared domains, logical dependencies, potential merge conflicts.
+
+Respond in JSON:
+{
+  "hasOverlap": boolean,
+  "overlapDomains": ["shared domains"],
+  "overlapFiles": ["potentially conflicting files"],
+  "severity": "none" | "low" | "medium" | "high",
+  "reason": "brief explanation"
+}`,
+      },
+      {
+        role: 'user',
+        content: `Intent 1:
+- Domain: ${intent1.domain}${intent1.subdomain ? '/' + intent1.subdomain : ''}
+- Summary: ${intent1.summary}
+- Files: ${intent1.affectedFiles.join(', ') || 'unknown'}
+- Tags: ${intent1.semanticTags.join(', ')}
+
+Intent 2:
+- Domain: ${intent2.domain}${intent2.subdomain ? '/' + intent2.subdomain : ''}
+- Summary: ${intent2.summary}
+- Files: ${intent2.affectedFiles.join(', ') || 'unknown'}
+- Tags: ${intent2.semanticTags.join(', ')}
+
+Do these intents potentially conflict?`,
+      },
+    ];
+
+    try {
+      return await this.provider.completeJSON(messages, { temperature: 0.2 });
+    } catch {
+      const sameDomain = intent1.domain === intent2.domain;
+      const sharedFiles = intent1.affectedFiles.filter(f => intent2.affectedFiles.includes(f));
+      
+      return {
+        hasOverlap: sameDomain || sharedFiles.length > 0,
+        overlapDomains: sameDomain ? [intent1.domain] : [],
+        overlapFiles: sharedFiles,
+        severity: sameDomain ? 'medium' : sharedFiles.length > 0 ? 'low' : 'none',
+        reason: sameDomain ? 'Same domain' : sharedFiles.length > 0 ? 'Shared files' : 'No overlap detected',
+      };
+    }
+  }
+}

package/packages/hub/src/server/hub-server.ts

@@ -0,0 +1,219 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import type { 
+  AgentMessage,
+  HubConnectedMessage,
+  BroadcastUserJoinedMessage,
+  BroadcastUserLeftMessage,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { 
+  parseMessage, 
+  serializeMessage, 
+  createMessage,
+  generateSessionId,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { SessionManager } from '../state/session-manager.js';
+import { LockManager } from '../core/lock-manager.js';
+import { MessageHandler } from './message-handler.js';
+
+export interface HubServerOptions {
+  port: number;
+  host?: string;
+}
+
+export interface ConnectedClient {
+  socket: WebSocket;
+  sessionId: string;
+  userId: string;
+  username: string;
+  projectPath: string;
+  connectedAt: number;
+}
+
+export class HubServer {
+  private wss: WebSocketServer | null = null;
+  private clients: Map<string, ConnectedClient> = new Map();
+  private sessionManager: SessionManager;
+  private lockManager: LockManager;
+  private messageHandler: MessageHandler;
+
+  constructor(private options: HubServerOptions) {
+    this.sessionManager = new SessionManager();
+    this.lockManager = new LockManager();
+    this.messageHandler = new MessageHandler(
+      this.sessionManager,
+      this.lockManager,
+      this.sendToClient.bind(this),
+      this.broadcast.bind(this)
+    );
+  }
+
+  start(): void {
+    this.wss = new WebSocketServer({ 
+      port: this.options.port,
+      host: this.options.host ?? '0.0.0.0',
+    });
+
+    this.wss.on('connection', (socket) => {
+      this.handleConnection(socket);
+    });
+
+    this.wss.on('error', (error) => {
+      console.error('[Hub] Server error:', error);
+    });
+
+    console.log(`[Hub] Server started on ${this.options.host ?? '0.0.0.0'}:${this.options.port}`);
+  }
+
+  stop(): void {
+    if (this.wss) {
+      for (const client of this.clients.values()) {
+        client.socket.close();
+      }
+      this.clients.clear();
+      this.wss.close();
+      this.wss = null;
+      console.log('[Hub] Server stopped');
+    }
+  }
+
+  private handleConnection(socket: WebSocket): void {
+    const tempSessionId = generateSessionId();
+    
+    socket.on('message', (data) => {
+      const message = parseMessage(data.toString());
+      if (!message) {
+        console.warn('[Hub] Invalid message received');
+        return;
+      }
+
+      this.handleMessage(socket, tempSessionId, message as AgentMessage);
+    });
+
+    socket.on('close', () => {
+      this.handleDisconnection(tempSessionId);
+    });
+
+    socket.on('error', (error) => {
+      console.error(`[Hub] Socket error for session ${tempSessionId}:`, error);
+    });
+  }
+
+  private handleMessage(socket: WebSocket, tempSessionId: string, message: AgentMessage): void {
+    if (message.type === 'agent:connect') {
+      const sessionId = generateSessionId();
+      const client: ConnectedClient = {
+        socket,
+        sessionId,
+        userId: message.payload.userId,
+        username: message.payload.username,
+        projectPath: message.payload.projectPath,
+        connectedAt: Date.now(),
+      };
+
+      this.clients.set(sessionId, client);
+      this.sessionManager.addSession(sessionId, client.userId, client.username);
+
+      const response = createMessage<HubConnectedMessage>('hub:connected', {
+        payload: {
+          sessionId,
+          activeLocks: this.lockManager.getActiveLocks().map(lock => ({
+            domainId: lock.domainId,
+            username: lock.username,
+          })),
+        },
+      });
+      this.sendToClient(sessionId, response);
+
+      const joinBroadcast = createMessage<BroadcastUserJoinedMessage>('broadcast:user:joined', {
+        payload: {
+          userId: client.userId,
+          username: client.username,
+        },
+      });
+      this.broadcastExcept(sessionId, joinBroadcast);
+
+      console.log(`[Hub] Client connected: ${client.username} (${sessionId})`);
+      return;
+    }
+
+    const client = this.findClientBySocket(socket);
+    if (!client) {
+      console.warn('[Hub] Message from unknown client');
+      return;
+    }
+
+    this.messageHandler.handle(client.sessionId, message);
+  }
+
+  private handleDisconnection(sessionId: string): void {
+    const client = this.clients.get(sessionId);
+    if (!client) {
+      for (const [sid, c] of this.clients) {
+        if (c.socket.readyState === WebSocket.CLOSED) {
+          this.performDisconnection(sid, c);
+        }
+      }
+      return;
+    }
+
+    this.performDisconnection(sessionId, client);
+  }
+
+  private performDisconnection(sessionId: string, client: ConnectedClient): void {
+    this.lockManager.releaseAllForUser(client.userId);
+    this.sessionManager.removeSession(sessionId);
+    this.clients.delete(sessionId);
+
+    const leaveBroadcast = createMessage<BroadcastUserLeftMessage>('broadcast:user:left', {
+      payload: {
+        userId: client.userId,
+        username: client.username,
+      },
+    });
+    this.broadcast(leaveBroadcast);
+
+    console.log(`[Hub] Client disconnected: ${client.username} (${sessionId})`);
+  }
+
+  private findClientBySocket(socket: WebSocket): ConnectedClient | undefined {
+    for (const client of this.clients.values()) {
+      if (client.socket === socket) {
+        return client;
+      }
+    }
+    return undefined;
+  }
+
+  private sendToClient(sessionId: string, message: HubConnectedMessage | BroadcastUserJoinedMessage | BroadcastUserLeftMessage | any): void {
+    const client = this.clients.get(sessionId);
+    if (client && client.socket.readyState === WebSocket.OPEN) {
+      client.socket.send(serializeMessage(message));
+    }
+  }
+
+  private broadcast(message: BroadcastUserJoinedMessage | BroadcastUserLeftMessage | any): void {
+    const serialized = serializeMessage(message);
+    for (const client of this.clients.values()) {
+      if (client.socket.readyState === WebSocket.OPEN) {
+        client.socket.send(serialized);
+      }
+    }
+  }
+
+  private broadcastExcept(excludeSessionId: string, message: BroadcastUserJoinedMessage | BroadcastUserLeftMessage | any): void {
+    const serialized = serializeMessage(message);
+    for (const [sessionId, client] of this.clients) {
+      if (sessionId !== excludeSessionId && client.socket.readyState === WebSocket.OPEN) {
+        client.socket.send(serialized);
+      }
+    }
+  }
+
+  getConnectedClients(): ConnectedClient[] {
+    return Array.from(this.clients.values());
+  }
+
+  getClientCount(): number {
+    return this.clients.size;
+  }
+}

package/packages/hub/src/server/index.ts

@@ -0,0 +1,4 @@
+export { HubServer } from './hub-server.js';
+export { MessageHandler } from './message-handler.js';
+export { SmartHubServer } from './smart-hub-server.js';
+export type { SmartHubServerOptions } from './smart-hub-server.js';

package/packages/hub/src/server/message-handler.ts

@@ -0,0 +1,111 @@
+import type {
+  AgentMessage,
+  AgentIntentSubmitMessage,
+  AgentDecisionMessage,
+  HubIntentReceivedMessage,
+  HubLockAcquiredMessage,
+  HubLockBlockedMessage,
+  BroadcastLockUpdateMessage,
+  HubMessage,
+  BroadcastMessage,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { createMessage, generateIntentId } from '@anthropic-for-korea/intent-hub-shared';
+import type { SessionManager } from '../state/session-manager.js';
+import type { LockManager } from '../core/lock-manager.js';
+import { IntentAnalyzer } from '../core/intent-analyzer.js';
+
+type SendFn = (sessionId: string, message: HubMessage | BroadcastMessage) => void;
+type BroadcastFn = (message: BroadcastMessage) => void;
+
+export class MessageHandler {
+  private intentAnalyzer: IntentAnalyzer;
+
+  constructor(
+    private sessionManager: SessionManager,
+    private lockManager: LockManager,
+    private send: SendFn,
+    private broadcast: BroadcastFn,
+  ) {
+    this.intentAnalyzer = new IntentAnalyzer();
+  }
+
+  handle(sessionId: string, message: AgentMessage): void {
+    switch (message.type) {
+      case 'agent:intent:submit':
+        this.handleIntentSubmit(sessionId, message);
+        break;
+      case 'agent:decision':
+        this.handleDecision(sessionId, message);
+        break;
+      case 'agent:heartbeat':
+        break;
+      default:
+        console.warn(`[MessageHandler] Unknown message type: ${(message as AgentMessage).type}`);
+    }
+  }
+
+  private handleIntentSubmit(sessionId: string, message: AgentIntentSubmitMessage): void {
+    const session = this.sessionManager.getSession(sessionId);
+    if (!session) {
+      console.warn(`[MessageHandler] Session not found: ${sessionId}`);
+      return;
+    }
+
+    const intentId = generateIntentId();
+    const { prompt } = message.payload;
+
+    const receivedMsg = createMessage<HubIntentReceivedMessage>('hub:intent:received', {
+      payload: { intentId },
+    });
+    this.send(sessionId, receivedMsg);
+
+    const analysis = this.intentAnalyzer.analyze(prompt);
+    const domainId = `${analysis.domain}${analysis.subdomain ? ':' + analysis.subdomain : ''}`;
+
+    const existingLock = this.lockManager.getLockForDomain(domainId);
+
+    if (existingLock && existingLock.userId !== session.userId) {
+      const blockedMsg = createMessage<HubLockBlockedMessage>('hub:lock:blocked', {
+        payload: {
+          intentId,
+          blockedBy: [{
+            domain: domainId,
+            username: existingLock.username,
+            intentSummary: 'Currently working on this domain',
+          }],
+        },
+      });
+      this.send(sessionId, blockedMsg);
+      console.log(`[MessageHandler] Intent blocked: ${session.username} blocked by ${existingLock.username} on ${domainId}`);
+      return;
+    }
+
+    this.lockManager.acquireLock(domainId, intentId, session.userId, session.username);
+
+    const acquiredMsg = createMessage<HubLockAcquiredMessage>('hub:lock:acquired', {
+      payload: {
+        intentId,
+        domains: [domainId],
+      },
+    });
+    this.send(sessionId, acquiredMsg);
+
+    const lockUpdateMsg = createMessage<BroadcastLockUpdateMessage>('broadcast:lock:update', {
+      payload: {
+        locks: this.lockManager.getActiveLocks().map(lock => ({
+          domainId: lock.domainId,
+          username: lock.username,
+          intentSummary: prompt.slice(0, 50),
+        })),
+      },
+    });
+    this.broadcast(lockUpdateMsg);
+
+    console.log(`[MessageHandler] Lock acquired: ${session.username} on ${domainId}`);
+  }
+
+  private handleDecision(sessionId: string, message: AgentDecisionMessage): void {
+    const { conflictId, choice } = message.payload;
+    console.log(`[MessageHandler] Decision received for conflict ${conflictId}: ${choice}`);
+  }
+}