intent-hub 0.1.0

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

@@ -0,0 +1,255 @@
+import type { LLMProvider } from '../llm/provider.js';
+import { SmartIntentAnalyzer, type SmartIntentAnalysis } from '../llm/smart-analyzer.js';
+import { NegotiationEngine, type NegotiationResult, type NegotiationParticipant } from '../llm/negotiation-engine.js';
+import { ConflictDetector, type ActiveIntent, type ConflictInfo } from './conflict-detector.js';
+import { LockManager } from './lock-manager.js';
+import { generateIntentId } from '@anthropic-for-korea/intent-hub-shared';
+
+export interface OrchestratorConfig {
+  useLLMAnalysis: boolean;
+  autoNegotiate: boolean;
+  conflictThreshold: 'low' | 'medium' | 'high';
+}
+
+export interface IntentRequest {
+  sessionId: string;
+  userId: string;
+  username: string;
+  prompt: string;
+}
+
+export interface IntentResponse {
+  intentId: string;
+  status: 'approved' | 'blocked' | 'negotiating' | 'pending_decision';
+  analysis: SmartIntentAnalysis;
+  domains: string[];
+  blockedBy?: {
+    username: string;
+    domain: string;
+    reason: string;
+  }[];
+  negotiation?: NegotiationResult;
+}
+
+type NotifyFn = (sessionId: string, event: string, data: any) => void;
+
+export class Orchestrator {
+  private analyzer: SmartIntentAnalyzer;
+  private negotiationEngine: NegotiationEngine;
+  private conflictDetector: ConflictDetector;
+  private lockManager: LockManager;
+  private pendingIntents: Map<string, ActiveIntent> = new Map();
+  private notify: NotifyFn;
+
+  constructor(
+    provider: LLMProvider,
+    private config: OrchestratorConfig,
+    notify: NotifyFn
+  ) {
+    this.analyzer = new SmartIntentAnalyzer(provider);
+    this.negotiationEngine = new NegotiationEngine(provider);
+    this.conflictDetector = new ConflictDetector(this.analyzer);
+    this.lockManager = new LockManager();
+    this.notify = notify;
+  }
+
+  async processIntent(request: IntentRequest): Promise<IntentResponse> {
+    const intentId = generateIntentId();
+    
+    let analysis: SmartIntentAnalysis;
+    if (this.config.useLLMAnalysis) {
+      analysis = await this.analyzer.analyze(request.prompt);
+    } else {
+      analysis = this.analyzer['fallbackAnalysis'](request.prompt);
+    }
+
+    const domainId = `${analysis.domain}${analysis.subdomain ? ':' + analysis.subdomain : ''}`;
+
+    const activeIntent: ActiveIntent = {
+      intentId,
+      sessionId: request.sessionId,
+      userId: request.userId,
+      username: request.username,
+      prompt: request.prompt,
+      analysis,
+      status: 'active',
+      startedAt: Date.now(),
+    };
+
+    const conflicts = this.conflictDetector.quickConflictCheck(activeIntent);
+    const significantConflicts = conflicts.filter(c => 
+      this.config.conflictThreshold === 'low' ? true :
+      this.config.conflictThreshold === 'medium' ? c.severity !== 'low' :
+      c.severity === 'high'
+    );
+
+    if (significantConflicts.length === 0) {
+      this.lockManager.acquireLock(domainId, intentId, request.userId, request.username);
+      this.conflictDetector.addIntent(activeIntent);
+      
+      return {
+        intentId,
+        status: 'approved',
+        analysis,
+        domains: [domainId],
+      };
+    }
+
+    const conflict = significantConflicts[0]!;
+    const existingIntent = this.conflictDetector.getIntentByUser(conflict.userId1);
+    
+    if (!existingIntent) {
+      this.lockManager.acquireLock(domainId, intentId, request.userId, request.username);
+      this.conflictDetector.addIntent(activeIntent);
+      
+      return {
+        intentId,
+        status: 'approved',
+        analysis,
+        domains: [domainId],
+      };
+    }
+
+    if (!this.config.autoNegotiate) {
+      return {
+        intentId,
+        status: 'blocked',
+        analysis,
+        domains: [domainId],
+        blockedBy: [{
+          username: existingIntent.username,
+          domain: conflict.overlapDomains[0] || domainId,
+          reason: conflict.reason,
+        }],
+      };
+    }
+
+    this.pendingIntents.set(intentId, activeIntent);
+
+    const participant1: NegotiationParticipant = {
+      sessionId: existingIntent.sessionId,
+      userId: existingIntent.userId,
+      username: existingIntent.username,
+      intent: existingIntent.analysis,
+      prompt: existingIntent.prompt,
+    };
+
+    const participant2: NegotiationParticipant = {
+      sessionId: request.sessionId,
+      userId: request.userId,
+      username: request.username,
+      intent: analysis,
+      prompt: request.prompt,
+    };
+
+    this.notify(existingIntent.sessionId, 'negotiation:start', {
+      conflictId: intentId,
+      withUser: request.username,
+      reason: conflict.reason,
+    });
+
+    const negotiationResult = await this.negotiationEngine.startNegotiation(
+      participant1,
+      participant2
+    );
+
+    this.pendingIntents.delete(intentId);
+
+    if (negotiationResult.status === 'agreed' && negotiationResult.plan) {
+      const firstPhase = negotiationResult.plan.phases[0]!;
+      const secondPhase = negotiationResult.plan.phases[1]!;
+
+      if (firstPhase.userId === request.userId) {
+        this.lockManager.acquireLock(domainId, intentId, request.userId, request.username);
+        this.conflictDetector.addIntent(activeIntent);
+
+        this.notify(existingIntent.sessionId, 'negotiation:resolved', {
+          conflictId: negotiationResult.conflictId,
+          result: 'wait',
+          message: `${request.username} will go first. You'll be notified when it's your turn.`,
+        });
+
+        return {
+          intentId,
+          status: 'approved',
+          analysis,
+          domains: [domainId],
+          negotiation: negotiationResult,
+        };
+      } else {
+        this.notify(existingIntent.sessionId, 'negotiation:resolved', {
+          conflictId: negotiationResult.conflictId,
+          result: 'proceed',
+          message: `You can proceed first. ${request.username} will wait.`,
+        });
+
+        return {
+          intentId,
+          status: 'negotiating',
+          analysis,
+          domains: [domainId],
+          negotiation: negotiationResult,
+          blockedBy: [{
+            username: existingIntent.username,
+            domain: conflict.overlapDomains[0] || domainId,
+            reason: `Negotiation resolved: ${existingIntent.username} goes first`,
+          }],
+        };
+      }
+    }
+
+    if (negotiationResult.requiresUserDecision) {
+      this.notify(existingIntent.sessionId, 'decision:required', {
+        conflictId: negotiationResult.conflictId,
+        options: negotiationResult.options,
+        reason: negotiationResult.disagreementReason,
+      });
+
+      return {
+        intentId,
+        status: 'pending_decision',
+        analysis,
+        domains: [domainId],
+        negotiation: negotiationResult,
+      };
+    }
+
+    return {
+      intentId,
+      status: 'blocked',
+      analysis,
+      domains: [domainId],
+      blockedBy: [{
+        username: existingIntent.username,
+        domain: conflict.overlapDomains[0] || domainId,
+        reason: negotiationResult.disagreementReason || 'Negotiation failed',
+      }],
+      negotiation: negotiationResult,
+    };
+  }
+
+  completeIntent(intentId: string, userId: string): void {
+    const intent = Array.from(this.conflictDetector['activeIntents'].values())
+      .find(i => i.intentId === intentId && i.userId === userId);
+
+    if (intent) {
+      intent.status = 'completed';
+      this.conflictDetector.removeIntent(intentId);
+      
+      const domainId = `${intent.analysis.domain}${intent.analysis.subdomain ? ':' + intent.analysis.subdomain : ''}`;
+      this.lockManager.releaseLock(domainId, userId);
+    }
+  }
+
+  getStatus(): {
+    activeIntents: number;
+    pendingNegotiations: number;
+    activeLocks: number;
+  } {
+    return {
+      activeIntents: this.conflictDetector.getActiveIntents().length,
+      pendingNegotiations: this.pendingIntents.size,
+      activeLocks: this.lockManager.getActiveLocks().length,
+    };
+  }
+}

package/packages/hub/src/index.ts

@@ -0,0 +1,8 @@
+export { HubServer, SmartHubServer } from './server/index.js';
+export type { SmartHubServerOptions } from './server/index.js';
+export { IntentAnalyzer, LockManager, ConflictDetector, Orchestrator } from './core/index.js';
+export type { ActiveIntent, ConflictInfo, OrchestratorConfig, IntentRequest, IntentResponse } from './core/index.js';
+export { SessionManager } from './state/index.js';
+export * from './llm/index.js';
+export { DashboardApi } from './api/dashboard.js';
+export type { DashboardApiOptions } from './api/dashboard.js';

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

@@ -0,0 +1,17 @@
+export { 
+  OpenAIProvider, 
+  AnthropicProvider, 
+  MockProvider, 
+  createProvider 
+} from './provider.js';
+export type { LLMProvider, LLMMessage, LLMCompletionOptions, LLMCompletionResult } from './provider.js';
+
+export { SmartIntentAnalyzer } from './smart-analyzer.js';
+export type { SmartIntentAnalysis } from './smart-analyzer.js';
+
+export { NegotiationEngine } from './negotiation-engine.js';
+export type { 
+  NegotiationParticipant, 
+  NegotiationProposal, 
+  NegotiationResult 
+} from './negotiation-engine.js';

package/packages/hub/src/llm/negotiation-engine.ts

@@ -0,0 +1,297 @@
+import type { LLMProvider, LLMMessage } from './provider.js';
+import type { SmartIntentAnalysis } from './smart-analyzer.js';
+import type { ExecutionPlan, ExecutionPhase } from '@anthropic-for-korea/intent-hub-shared';
+import { generateConflictId } from '@anthropic-for-korea/intent-hub-shared';
+
+export interface NegotiationParticipant {
+  sessionId: string;
+  userId: string;
+  username: string;
+  intent: SmartIntentAnalysis;
+  prompt: string;
+}
+
+export interface NegotiationProposal {
+  fromUserId: string;
+  fromUsername: string;
+  proposal: string;
+  suggestedOrder: string[];
+  reasoning: string;
+}
+
+export interface NegotiationResult {
+  conflictId: string;
+  status: 'agreed' | 'disagreed' | 'timeout';
+  plan?: ExecutionPlan;
+  proposals: NegotiationProposal[];
+  disagreementReason?: string;
+  requiresUserDecision: boolean;
+  options?: Array<{
+    id: string;
+    description: string;
+    proposedBy: string;
+  }>;
+}
+
+const NEGOTIATION_SYSTEM_PROMPT = `You are an AI agent helping coordinate work between team members.
+Two developers want to work on potentially overlapping parts of the codebase.
+Your job is to propose a plan that minimizes conflicts and maximizes parallel work.
+
+Consider:
+1. Which work can be done in parallel without conflicts?
+2. Which work has dependencies and should be sequenced?
+3. Can one person define interfaces/contracts first that the other can use?
+4. Is there a natural order (e.g., backend before frontend)?
+
+Respond in JSON:
+{
+  "proposal": "brief description of your proposed approach",
+  "suggestedOrder": ["userId who should go first", "userId who should go second"],
+  "reasoning": "why this order makes sense",
+  "canWorkInParallel": boolean,
+  "parallelStrategy": "if parallel is possible, how to divide the work",
+  "sharedInterface": "any interface/contract that should be agreed upon first"
+}`;
+
+export class NegotiationEngine {
+  private activeNegotiations: Map<string, {
+    participants: NegotiationParticipant[];
+    proposals: NegotiationProposal[];
+    startedAt: number;
+  }> = new Map();
+
+  constructor(private provider: LLMProvider) {}
+
+  async startNegotiation(
+    participant1: NegotiationParticipant,
+    participant2: NegotiationParticipant
+  ): Promise<NegotiationResult> {
+    const conflictId = generateConflictId();
+    
+    this.activeNegotiations.set(conflictId, {
+      participants: [participant1, participant2],
+      proposals: [],
+      startedAt: Date.now(),
+    });
+
+    const proposal1 = await this.getProposal(participant1, participant2);
+    const proposal2 = await this.getProposal(participant2, participant1);
+
+    const negotiation = this.activeNegotiations.get(conflictId)!;
+    negotiation.proposals.push(proposal1, proposal2);
+
+    const consensus = await this.findConsensus(proposal1, proposal2, participant1, participant2);
+
+    this.activeNegotiations.delete(conflictId);
+
+    return {
+      conflictId,
+      ...consensus,
+      proposals: [proposal1, proposal2],
+    };
+  }
+
+  private async getProposal(
+    self: NegotiationParticipant,
+    other: NegotiationParticipant
+  ): Promise<NegotiationProposal> {
+    const messages: LLMMessage[] = [
+      { role: 'system', content: NEGOTIATION_SYSTEM_PROMPT },
+      {
+        role: 'user',
+        content: `You are representing ${self.username} (userId: ${self.userId}).
+
+Your task:
+- Domain: ${self.intent.domain}${self.intent.subdomain ? '/' + self.intent.subdomain : ''}
+- Description: ${self.prompt}
+- Affected files: ${self.intent.affectedFiles.join(', ') || 'to be determined'}
+- Tags: ${self.intent.semanticTags.join(', ')}
+
+Other developer's task (${other.username}, userId: ${other.userId}):
+- Domain: ${other.intent.domain}${other.intent.subdomain ? '/' + other.intent.subdomain : ''}
+- Description: ${other.prompt}
+- Affected files: ${other.intent.affectedFiles.join(', ') || 'to be determined'}
+- Tags: ${other.intent.semanticTags.join(', ')}
+
+Propose a plan that works best for both parties.`,
+      },
+    ];
+
+    try {
+      const result = await this.provider.completeJSON<{
+        proposal: string;
+        suggestedOrder: string[];
+        reasoning: string;
+      }>(messages, { temperature: 0.4 });
+
+      return {
+        fromUserId: self.userId,
+        fromUsername: self.username,
+        proposal: result.proposal,
+        suggestedOrder: result.suggestedOrder,
+        reasoning: result.reasoning,
+      };
+    } catch (error) {
+      return {
+        fromUserId: self.userId,
+        fromUsername: self.username,
+        proposal: `${self.username} should complete their task first`,
+        suggestedOrder: [self.userId, other.userId],
+        reasoning: 'Default proposal due to analysis failure',
+      };
+    }
+  }
+
+  private async findConsensus(
+    proposal1: NegotiationProposal,
+    proposal2: NegotiationProposal,
+    participant1: NegotiationParticipant,
+    participant2: NegotiationParticipant
+  ): Promise<Omit<NegotiationResult, 'conflictId' | 'proposals'>> {
+    const sameOrder = 
+      proposal1.suggestedOrder[0] === proposal2.suggestedOrder[0] &&
+      proposal1.suggestedOrder[1] === proposal2.suggestedOrder[1];
+
+    if (sameOrder) {
+      const firstUserId = proposal1.suggestedOrder[0];
+      const secondUserId = proposal1.suggestedOrder[1];
+      
+      const first = firstUserId === participant1.userId ? participant1 : participant2;
+      const second = secondUserId === participant1.userId ? participant1 : participant2;
+
+      const plan: ExecutionPlan = {
+        phases: [
+          {
+            order: 1,
+            intentId: `int_${first.userId}`,
+            userId: first.userId,
+            domains: [first.intent.domain],
+          },
+          {
+            order: 2,
+            intentId: `int_${second.userId}`,
+            userId: second.userId,
+            domains: [second.intent.domain],
+            dependsOn: [`int_${first.userId}`],
+          },
+        ],
+      };
+
+      return {
+        status: 'agreed',
+        plan,
+        requiresUserDecision: false,
+      };
+    }
+
+    const messages: LLMMessage[] = [
+      {
+        role: 'system',
+        content: `Two AI agents proposed different plans for coordinating work. 
+Determine if a compromise is possible or if human decision is needed.
+
+Respond in JSON:
+{
+  "canResolve": boolean,
+  "resolution": "if can resolve, the agreed plan",
+  "reasoning": "explanation",
+  "firstUserId": "who should go first if resolved",
+  "secondUserId": "who should go second if resolved"
+}`,
+      },
+      {
+        role: 'user',
+        content: `Proposal 1 from ${proposal1.fromUsername}:
+${proposal1.proposal}
+Order: ${proposal1.suggestedOrder.join(' → ')}
+Reasoning: ${proposal1.reasoning}
+
+Proposal 2 from ${proposal2.fromUsername}:
+${proposal2.proposal}
+Order: ${proposal2.suggestedOrder.join(' → ')}
+Reasoning: ${proposal2.reasoning}
+
+Can these be reconciled?`,
+      },
+    ];
+
+    try {
+      const result = await this.provider.completeJSON<{
+        canResolve: boolean;
+        resolution?: string;
+        reasoning: string;
+        firstUserId?: string;
+        secondUserId?: string;
+      }>(messages, { temperature: 0.3 });
+
+      if (result.canResolve && result.firstUserId && result.secondUserId) {
+        const first = result.firstUserId === participant1.userId ? participant1 : participant2;
+        const second = result.secondUserId === participant1.userId ? participant1 : participant2;
+
+        const plan: ExecutionPlan = {
+          phases: [
+            {
+              order: 1,
+              intentId: `int_${first.userId}`,
+              userId: first.userId,
+              domains: [first.intent.domain],
+            },
+            {
+              order: 2,
+              intentId: `int_${second.userId}`,
+              userId: second.userId,
+              domains: [second.intent.domain],
+              dependsOn: [`int_${first.userId}`],
+            },
+          ],
+        };
+
+        return {
+          status: 'agreed',
+          plan,
+          requiresUserDecision: false,
+        };
+      }
+
+      return {
+        status: 'disagreed',
+        requiresUserDecision: true,
+        disagreementReason: result.reasoning,
+        options: [
+          {
+            id: 'option_1',
+            description: `${proposal1.fromUsername}'s plan: ${proposal1.proposal}`,
+            proposedBy: proposal1.fromUsername,
+          },
+          {
+            id: 'option_2',
+            description: `${proposal2.fromUsername}'s plan: ${proposal2.proposal}`,
+            proposedBy: proposal2.fromUsername,
+          },
+        ],
+      };
+    } catch {
+      return {
+        status: 'disagreed',
+        requiresUserDecision: true,
+        disagreementReason: 'Failed to reach automated consensus',
+        options: [
+          {
+            id: 'option_1',
+            description: `${proposal1.fromUsername} goes first`,
+            proposedBy: proposal1.fromUsername,
+          },
+          {
+            id: 'option_2',
+            description: `${proposal2.fromUsername} goes first`,
+            proposedBy: proposal2.fromUsername,
+          },
+        ],
+      };
+    }
+  }
+
+  getActiveNegotiations(): string[] {
+    return Array.from(this.activeNegotiations.keys());
+  }
+}