intent-hub 0.1.0

package/packages/hub/src/cli.ts

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+import { HubServer } from './server/hub-server.js';
+import { SmartHubServer } from './server/smart-hub-server.js';
+import { createProvider } from './llm/provider.js';
+import { DashboardApi } from './api/dashboard.js';
+import { createTunnel, printShareInfo, type TunnelResult } from './tunnel/index.js';
+
+const DEFAULT_PORT = 9876;
+const DEFAULT_DASHBOARD_PORT = 9877;
+
+interface ParsedArgs {
+  port: number;
+  host: string;
+  mode: 'simple' | 'smart';
+  llmProvider: 'openai' | 'anthropic' | 'mock';
+  apiKey?: string;
+  autoNegotiate: boolean;
+  dashboard: boolean;
+  dashboardPort: number;
+  share: boolean;
+  tunnelProvider: 'localtunnel' | 'cloudflared' | 'auto';
+}
+
+function parseArgs(): ParsedArgs {
+  const args = process.argv.slice(2);
+  
+  const getArg = (name: string): string | undefined => {
+    const arg = args.find(a => a.startsWith(`--${name}=`));
+    return arg?.split('=')[1];
+  };
+
+  const hasFlag = (name: string): boolean => {
+    return args.includes(`--${name}`);
+  };
+
+  return {
+    port: parseInt(getArg('port') ?? String(DEFAULT_PORT), 10),
+    host: getArg('host') ?? '0.0.0.0',
+    mode: (getArg('mode') as 'simple' | 'smart') ?? 'smart',
+    llmProvider: (getArg('llm') as 'openai' | 'anthropic' | 'mock') ?? 'mock',
+    apiKey: getArg('api-key') ?? process.env['OPENAI_API_KEY'] ?? process.env['ANTHROPIC_API_KEY'],
+    autoNegotiate: !hasFlag('no-negotiate'),
+    dashboard: hasFlag('dashboard'),
+    dashboardPort: parseInt(getArg('dashboard-port') ?? String(DEFAULT_DASHBOARD_PORT), 10),
+    share: hasFlag('share'),
+    tunnelProvider: (getArg('tunnel') as 'localtunnel' | 'cloudflared' | 'auto') ?? 'auto',
+  };
+}
+
+function printBanner(config: ParsedArgs, shareUrl?: string) {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║   ██╗███╗   ██╗████████╗███████╗███╗   ██╗████████╗           ║
+║   ██║████╗  ██║╚══██╔══╝██╔════╝████╗  ██║╚══██╔══╝           ║
+║   ██║██╔██╗ ██║   ██║   █████╗  ██╔██╗ ██║   ██║              ║
+║   ██║██║╚██╗██║   ██║   ██╔══╝  ██║╚██╗██║   ██║              ║
+║   ██║██║ ╚████║   ██║   ███████╗██║ ╚████║   ██║              ║
+║   ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚═╝  ╚═══╝   ╚═╝              ║
+║                         HUB                                   ║
+║                                                               ║
+║   Team-based LLM Coordination Platform                        ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+
+  Mode:           ${config.mode}
+  LLM Provider:   ${config.llmProvider}
+  Auto-Negotiate: ${config.autoNegotiate}
+  WebSocket:      ws://${config.host}:${config.port}
+  Dashboard:      ${config.dashboard ? `http://localhost:${config.dashboardPort}` : 'disabled (use --dashboard to enable)'}
+  Share Mode:     ${config.share ? 'enabled' : 'disabled (use --share to enable)'}
+`);
+}
+
+function printHelp() {
+  console.log(`
+Intent Hub - Team-based LLM Coordination Platform
+
+Usage:
+  intent-hub [options]
+
+Options:
+  --port=<number>           WebSocket port (default: 9876)
+  --host=<string>           Host to bind to (default: 0.0.0.0)
+  --mode=<mode>             Server mode: simple | smart (default: smart)
+  --llm=<provider>          LLM provider: openai | anthropic | mock (default: mock)
+  --api-key=<key>           API key for LLM provider (or use env vars)
+  --no-negotiate            Disable auto-negotiation
+  --dashboard               Enable web dashboard
+  --dashboard-port=<number> Dashboard HTTP port (default: 9877)
+  --share                   Enable Live Share mode (creates public URL)
+  --tunnel=<provider>       Tunnel provider: auto | localtunnel | cloudflared (default: auto)
+  --help                    Show this help message
+
+Live Share Mode (--share):
+  Creates a public URL that team members can use to connect.
+  No network configuration needed - works through NAT/firewalls.
+  
+  Example:
+    intent-hub --share --llm=openai
+    # Outputs: wss://intent-hub-abc123.loca.lt
+    # Share this URL with your team!
+
+Environment Variables:
+  OPENAI_API_KEY            OpenAI API key
+  ANTHROPIC_API_KEY         Anthropic API key
+
+Examples:
+  intent-hub --share                              # Quick team session
+  intent-hub --share --llm=openai --dashboard     # Full featured
+  intent-hub --port=9876 --mode=smart --llm=mock  # Local testing
+`);
+}
+
+async function main() {
+  if (process.argv.includes('--help') || process.argv.includes('-h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const config = parseArgs();
+  
+  let tunnel: TunnelResult | null = null;
+  
+  let server: HubServer | SmartHubServer;
+  let dashboard: DashboardApi | null = null;
+
+  if (config.mode === 'smart') {
+    const provider = createProvider(config.llmProvider, config.apiKey);
+    
+    const smartServer = new SmartHubServer({
+      port: config.port,
+      host: config.host,
+      llmProvider: provider,
+      orchestratorConfig: {
+        useLLMAnalysis: config.llmProvider !== 'mock',
+        autoNegotiate: config.autoNegotiate,
+        conflictThreshold: 'medium',
+      },
+    });
+    
+    server = smartServer;
+
+    if (config.dashboard) {
+      dashboard = new DashboardApi({
+        port: config.dashboardPort,
+        hubServer: smartServer,
+      });
+    }
+  } else {
+    server = new HubServer({ port: config.port, host: config.host });
+    
+    if (config.dashboard) {
+      console.log('[Dashboard] Warning: Dashboard requires smart mode. Use --mode=smart to enable.');
+    }
+  }
+  
+  server.start();
+  dashboard?.start();
+  
+  printBanner(config);
+  
+  if (config.share) {
+    console.log('[Share] Creating tunnel...');
+    try {
+      tunnel = await createTunnel({
+        port: config.port,
+        provider: config.tunnelProvider,
+      });
+      printShareInfo(tunnel);
+    } catch (err) {
+      console.error('[Share] Failed to create tunnel:', err);
+      console.log('[Share] Falling back to local mode. Team members need network access to connect.');
+    }
+  }
+
+  const shutdown = async () => {
+    console.log('\n[Hub] Shutting down...');
+    if (tunnel) {
+      console.log('[Share] Closing tunnel...');
+      await tunnel.close();
+    }
+    dashboard?.stop();
+    server.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main();

package/packages/hub/src/core/conflict-detector.ts

@@ -0,0 +1,138 @@
+import type { SmartIntentAnalysis, SmartIntentAnalyzer } from '../llm/smart-analyzer.js';
+import type { Intent } from '@anthropic-for-korea/intent-hub-shared';
+
+export interface ActiveIntent {
+  intentId: string;
+  sessionId: string;
+  userId: string;
+  username: string;
+  prompt: string;
+  analysis: SmartIntentAnalysis;
+  status: 'active' | 'waiting' | 'completed';
+  startedAt: number;
+}
+
+export interface ConflictInfo {
+  intentId1: string;
+  intentId2: string;
+  userId1: string;
+  userId2: string;
+  username1: string;
+  username2: string;
+  overlapDomains: string[];
+  overlapFiles: string[];
+  severity: 'low' | 'medium' | 'high';
+  reason: string;
+}
+
+export class ConflictDetector {
+  private activeIntents: Map<string, ActiveIntent> = new Map();
+
+  constructor(private analyzer: SmartIntentAnalyzer) {}
+
+  addIntent(intent: ActiveIntent): void {
+    this.activeIntents.set(intent.intentId, intent);
+  }
+
+  removeIntent(intentId: string): void {
+    this.activeIntents.delete(intentId);
+  }
+
+  getActiveIntents(): ActiveIntent[] {
+    return Array.from(this.activeIntents.values()).filter(i => i.status === 'active');
+  }
+
+  async detectConflicts(newIntent: ActiveIntent): Promise<ConflictInfo[]> {
+    const conflicts: ConflictInfo[] = [];
+    const activeIntents = this.getActiveIntents();
+
+    for (const existing of activeIntents) {
+      if (existing.userId === newIntent.userId) continue;
+
+      const overlap = await this.analyzer.checkOverlap(
+        existing.analysis,
+        newIntent.analysis
+      );
+
+      if (overlap.hasOverlap && overlap.severity !== 'none') {
+        conflicts.push({
+          intentId1: existing.intentId,
+          intentId2: newIntent.intentId,
+          userId1: existing.userId,
+          userId2: newIntent.userId,
+          username1: existing.username,
+          username2: newIntent.username,
+          overlapDomains: overlap.overlapDomains,
+          overlapFiles: overlap.overlapFiles,
+          severity: overlap.severity as 'low' | 'medium' | 'high',
+          reason: overlap.reason,
+        });
+      }
+    }
+
+    return conflicts;
+  }
+
+  quickConflictCheck(newIntent: ActiveIntent): ConflictInfo[] {
+    const conflicts: ConflictInfo[] = [];
+    const activeIntents = this.getActiveIntents();
+
+    for (const existing of activeIntents) {
+      if (existing.userId === newIntent.userId) continue;
+
+      const domainMatch = existing.analysis.domain === newIntent.analysis.domain;
+      const subdomainMatch = existing.analysis.subdomain && 
+                            newIntent.analysis.subdomain && 
+                            existing.analysis.subdomain === newIntent.analysis.subdomain;
+      
+      const fileOverlap = existing.analysis.affectedFiles.filter(
+        f => newIntent.analysis.affectedFiles.includes(f)
+      );
+
+      const tagOverlap = existing.analysis.semanticTags.filter(
+        t => newIntent.analysis.semanticTags.includes(t)
+      );
+
+      let severity: 'low' | 'medium' | 'high' = 'low';
+      let hasConflict = false;
+
+      if (subdomainMatch || fileOverlap.length > 0) {
+        severity = 'high';
+        hasConflict = true;
+      } else if (domainMatch) {
+        severity = 'medium';
+        hasConflict = true;
+      } else if (tagOverlap.length >= 3) {
+        severity = 'low';
+        hasConflict = true;
+      }
+
+      if (hasConflict) {
+        conflicts.push({
+          intentId1: existing.intentId,
+          intentId2: newIntent.intentId,
+          userId1: existing.userId,
+          userId2: newIntent.userId,
+          username1: existing.username,
+          username2: newIntent.username,
+          overlapDomains: domainMatch ? [existing.analysis.domain] : [],
+          overlapFiles: fileOverlap,
+          severity,
+          reason: subdomainMatch ? 'Same subdomain' :
+                  fileOverlap.length > 0 ? 'Shared files' :
+                  domainMatch ? 'Same domain' : 'Related tags',
+        });
+      }
+    }
+
+    return conflicts;
+  }
+
+  getIntentsByDomain(domain: string): ActiveIntent[] {
+    return this.getActiveIntents().filter(i => i.analysis.domain === domain);
+  }
+
+  getIntentByUser(userId: string): ActiveIntent | undefined {
+    return this.getActiveIntents().find(i => i.userId === userId);
+  }
+}

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

@@ -0,0 +1,6 @@
+export { IntentAnalyzer } from './intent-analyzer.js';
+export { LockManager } from './lock-manager.js';
+export { ConflictDetector } from './conflict-detector.js';
+export type { ActiveIntent, ConflictInfo } from './conflict-detector.js';
+export { Orchestrator } from './orchestrator.js';
+export type { OrchestratorConfig, IntentRequest, IntentResponse } from './orchestrator.js';

package/packages/hub/src/core/intent-analyzer.ts

@@ -0,0 +1,112 @@
+import type { IntentAnalysis } from '@anthropic-for-korea/intent-hub-shared';
+
+const DOMAIN_KEYWORDS: Record<string, string[]> = {
+  auth: ['login', 'logout', 'auth', 'authentication', 'oauth', 'session', 'token', 'jwt', 'password', '로그인', '인증'],
+  user: ['user', 'profile', 'account', 'member', '사용자', '회원', '프로필'],
+  payment: ['payment', 'pay', 'billing', 'invoice', 'checkout', 'cart', '결제', '장바구니'],
+  database: ['database', 'db', 'migration', 'schema', 'model', 'entity', '데이터베이스'],
+  api: ['api', 'endpoint', 'route', 'controller', 'rest', 'graphql'],
+  ui: ['ui', 'component', 'button', 'form', 'modal', 'layout', 'style', 'css', '버튼', '컴포넌트'],
+  test: ['test', 'spec', 'jest', 'vitest', 'e2e', 'unit', '테스트'],
+  config: ['config', 'setting', 'env', 'environment', '설정'],
+  docs: ['doc', 'readme', 'documentation', '문서'],
+};
+
+const SUBDOMAIN_KEYWORDS: Record<string, Record<string, string[]>> = {
+  auth: {
+    oauth: ['oauth', 'google', 'github', 'facebook', 'social'],
+    session: ['session', 'cookie'],
+    jwt: ['jwt', 'token', 'refresh'],
+  },
+  payment: {
+    checkout: ['checkout', 'order'],
+    subscription: ['subscription', 'recurring'],
+  },
+};
+
+export class IntentAnalyzer {
+  analyze(prompt: string): IntentAnalysis {
+    const lowerPrompt = prompt.toLowerCase();
+    
+    let domain = 'general';
+    let maxScore = 0;
+
+    for (const [d, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+      const score = keywords.filter(kw => lowerPrompt.includes(kw)).length;
+      if (score > maxScore) {
+        maxScore = score;
+        domain = d;
+      }
+    }
+
+    let subdomain: string | undefined;
+    const subdomains = SUBDOMAIN_KEYWORDS[domain];
+    if (subdomains) {
+      let subMaxScore = 0;
+      for (const [sd, keywords] of Object.entries(subdomains)) {
+        const score = keywords.filter(kw => lowerPrompt.includes(kw)).length;
+        if (score > subMaxScore) {
+          subMaxScore = score;
+          subdomain = sd;
+        }
+      }
+    }
+
+    const affectedFiles = this.extractAffectedFiles(prompt);
+    const semanticTags = this.extractSemanticTags(lowerPrompt);
+    const estimatedScope = this.estimateScope(prompt);
+
+    return {
+      domain,
+      subdomain,
+      affectedFiles,
+      semanticTags,
+      estimatedScope,
+      dependencies: [],
+    };
+  }
+
+  private extractAffectedFiles(prompt: string): string[] {
+    const filePatterns = [
+      /[\w\-\/]+\.(ts|tsx|js|jsx|json|css|scss|html|md)/gi,
+      /src\/[\w\-\/]+/gi,
+      /pages\/[\w\-\/]+/gi,
+      /components\/[\w\-\/]+/gi,
+    ];
+
+    const files: Set<string> = new Set();
+    for (const pattern of filePatterns) {
+      const matches = prompt.match(pattern);
+      if (matches) {
+        for (const match of matches) {
+          files.add(match);
+        }
+      }
+    }
+
+    return Array.from(files);
+  }
+
+  private extractSemanticTags(lowerPrompt: string): string[] {
+    const tags: string[] = [];
+    
+    for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+      for (const kw of keywords) {
+        if (lowerPrompt.includes(kw)) {
+          tags.push(kw);
+        }
+      }
+    }
+
+    return [...new Set(tags)].slice(0, 10);
+  }
+
+  private estimateScope(prompt: string): 'small' | 'medium' | 'large' {
+    const length = prompt.length;
+    const fileCount = (prompt.match(/\.(ts|tsx|js|jsx|json|css)/gi) ?? []).length;
+
+    if (length < 100 && fileCount <= 1) return 'small';
+    if (length < 300 && fileCount <= 3) return 'medium';
+    return 'large';
+  }
+}

package/packages/hub/src/core/lock-manager.ts

@@ -0,0 +1,95 @@
+import type { DomainLock, LockStatus } from '@anthropic-for-korea/intent-hub-shared';
+
+export class LockManager {
+  private locks: Map<string, DomainLock> = new Map();
+
+  acquireLock(
+    domainId: string,
+    intentId: string,
+    userId: string,
+    username: string,
+    expiresInMs?: number
+  ): DomainLock | null {
+    const existing = this.locks.get(domainId);
+    if (existing && existing.status === 'active' && existing.userId !== userId) {
+      return null;
+    }
+
+    const lock: DomainLock = {
+      domainId,
+      intentId,
+      userId,
+      username,
+      acquiredAt: Date.now(),
+      expiresAt: expiresInMs ? Date.now() + expiresInMs : undefined,
+      status: 'active',
+    };
+
+    this.locks.set(domainId, lock);
+    return lock;
+  }
+
+  releaseLock(domainId: string, userId: string): boolean {
+    const lock = this.locks.get(domainId);
+    if (!lock || lock.userId !== userId) {
+      return false;
+    }
+
+    lock.status = 'released';
+    this.locks.delete(domainId);
+    return true;
+  }
+
+  releaseAllForUser(userId: string): number {
+    let count = 0;
+    for (const [domainId, lock] of this.locks) {
+      if (lock.userId === userId) {
+        this.locks.delete(domainId);
+        count++;
+      }
+    }
+    return count;
+  }
+
+  getLockForDomain(domainId: string): DomainLock | undefined {
+    const lock = this.locks.get(domainId);
+    if (lock && lock.status === 'active') {
+      if (lock.expiresAt && Date.now() > lock.expiresAt) {
+        this.locks.delete(domainId);
+        return undefined;
+      }
+      return lock;
+    }
+    return undefined;
+  }
+
+  getActiveLocks(): DomainLock[] {
+    const now = Date.now();
+    const active: DomainLock[] = [];
+    
+    for (const [domainId, lock] of this.locks) {
+      if (lock.status === 'active') {
+        if (lock.expiresAt && now > lock.expiresAt) {
+          this.locks.delete(domainId);
+        } else {
+          active.push(lock);
+        }
+      }
+    }
+
+    return active;
+  }
+
+  getLocksForUser(userId: string): DomainLock[] {
+    return this.getActiveLocks().filter(lock => lock.userId === userId);
+  }
+
+  hasConflict(domainId: string, userId: string): boolean {
+    const lock = this.getLockForDomain(domainId);
+    return lock !== undefined && lock.userId !== userId;
+  }
+
+  findOverlappingDomains(domains: string[], userId: string): string[] {
+    return domains.filter(d => this.hasConflict(d, userId));
+  }
+}