@su-record/vibe 2.5.11 → 2.5.13

package/dist/orchestrator/orchestrator.js

@@ -1,24 +1,18 @@
 /**
  * Orchestrator - 메인 오케스트레이터 클래스
  * /vibe.* 명령어에서 사용할 중앙 오케스트레이션 로직
+ *
+ * v2.6.0: SmartRouter, LLMCluster, AgentManager로 분리
  */
 import { promises as fs } from 'fs';
 import path from 'path';
-import { TASK_LLM_PRIORITY } from './types.js';
-import { discoverAgents, loadAgent, listAgentsByCategory } from './agentDiscovery.js';
-import { debugLog, errorLog, warnLog } from '../lib/utils.js';
-import { DEFAULT_MODELS } from '../lib/constants.js';
 import { parallelResearch, createResearchTasks, parallelResearchWithMultiLlm } from './parallelResearch.js';
-import { launchBackgroundAgent, getBackgroundAgentResult, cancelBackgroundAgent, listActiveSessions, getSessionHistory, launchParallelAgents } from './backgroundAgent.js';
 import { MemoryManager } from '../lib/MemoryManager.js';
-import * as gptApi from '../lib/gpt-api.js';
-import * as geminiApi from '../lib/gemini-api.js';
-// LLM 가용성 캐시 (5분 TTL)
-const LLM_CACHE_TTL = 5 * 60 * 1000;
-const llmAvailabilityCache = {
-    gpt: { available: true, checkedAt: 0, errorCount: 0 },
-    gemini: { available: true, checkedAt: 0, errorCount: 0 }
-};
+import { debugLog, errorLog } from '../lib/utils.js';
+// 분리된 모듈 임포트
+import { SmartRouter } from './SmartRouter.js';
+import { LLMCluster } from './LLMCluster.js';
+import { AgentManager } from './AgentManager.js';
 /**
  * Vibe Orchestrator
  * 모든 /vibe.* 명령어의 오케스트레이션을 담당
@@ -26,6 +20,10 @@ const llmAvailabilityCache = {
 export class VibeOrchestrator {
     options;
     memoryManager;
+    // 분리된 컴포넌트
+    router;
+    llmCluster;
+    agentManager;
     constructor(options = {}) {
         this.options = {
             projectPath: process.cwd(),
@@ -35,295 +33,77 @@ export class VibeOrchestrator {
             ...options
         };
         this.memoryManager = MemoryManager.getInstance(this.options.projectPath);
+        // 컴포넌트 초기화
+        this.router = new SmartRouter({ verbose: this.options.verbose });
+        this.llmCluster = new LLMCluster();
+        this.agentManager = new AgentManager({ projectPath: this.options.projectPath });
     }
     // ============================================
-    // Smart Routing (핵심 오케스트레이션)
+    // Smart Routing (SmartRouter 위임)
     // ============================================
-    /**
-     * 스마트 라우팅 - 작업 유형에 따라 최적의 LLM 선택 + fallback
-     *
-     * @example
-     * const result = await orchestrator.smartRoute({
-     *   type: 'architecture',
-     *   prompt: 'Review this system design'
-     * });
-     */
     async smartRoute(request) {
-        const startTime = Date.now();
-        const { type, prompt, systemPrompt = 'You are a helpful assistant.', preferredLlm, maxRetries = 2 } = request;
-        // LLM 우선순위 결정
-        let providers;
-        if (preferredLlm) {
-            // 지정된 LLM 우선, 나머지는 fallback
-            const others = TASK_LLM_PRIORITY[type].filter(p => p !== preferredLlm);
-            providers = [preferredLlm, ...others];
-        }
-        else {
-            providers = [...TASK_LLM_PRIORITY[type]];
-        }
-        const attemptedProviders = [];
-        const errors = {};
-        // 각 LLM 순차 시도 (fallback chain)
-        for (const provider of providers) {
-            // 캐시 확인 - 최근 실패한 LLM 건너뛰기
-            if (this.isLlmUnavailable(provider)) {
-                if (this.options.verbose) {
-                    debugLog(`[SmartRoute] Skipping ${provider} (recently failed)`);
-                }
-                continue;
-            }
-            attemptedProviders.push(provider);
-            // 재시도 로직
-            for (let attempt = 0; attempt <= maxRetries; attempt++) {
-                try {
-                    const content = await this.callLlm(provider, prompt, systemPrompt);
-                    // 성공 - 캐시 업데이트
-                    this.markLlmAvailable(provider);
-                    return {
-                        content,
-                        provider,
-                        success: true,
-                        usedFallback: attemptedProviders.length > 1,
-                        attemptedProviders,
-                        duration: Date.now() - startTime
-                    };
-                }
-                catch (error) {
-                    const errorMsg = error instanceof Error ? error.message : String(error);
-                    errors[provider] = errorMsg;
-                    if (this.options.verbose) {
-                        debugLog(`[SmartRoute] ${provider} attempt ${attempt + 1} failed: ${errorMsg}`);
-                    }
-                    // Rate limit, quota, 인증 에러는 바로 다음 LLM으로 (재시도 의미 없음)
-                    if (this.shouldSkipRetry(errorMsg)) {
-                        this.markLlmUnavailable(provider);
-                        break;
-                    }
-                    // 마지막 재시도가 아니면 잠시 대기
-                    if (attempt < maxRetries) {
-                        await this.delay(1000 * (attempt + 1));
-                    }
-                }
-            }
-            // 해당 LLM 실패 - 다음으로
-            this.markLlmUnavailable(provider);
-        }
-        // 모든 외부 LLM 실패 - Claude fallback 메시지 반환
-        return {
-            content: this.buildFallbackMessage(type, prompt, errors),
-            provider: 'claude',
-            success: true,
-            usedFallback: true,
-            attemptedProviders,
-            errors: errors,
-            duration: Date.now() - startTime
-        };
-    }
-    /**
-     * LLM 호출 (provider별 분기)
-     */
-    async callLlm(provider, prompt, systemPrompt) {
-        switch (provider) {
-            case 'gpt':
-                return gptApi.vibeGptOrchestrate(prompt, systemPrompt, { jsonMode: false });
-            case 'gemini':
-                return geminiApi.vibeGeminiOrchestrate(prompt, systemPrompt, { jsonMode: false });
-            case 'claude':
-                // Claude는 직접 처리하지 않고 fallback 메시지 반환
-                throw new Error('Claude fallback - handled by caller');
-            default:
-                throw new Error(`Unknown provider: ${provider}`);
-        }
-    }
-    /**
-     * 재시도 없이 즉시 다음 LLM으로 넘어가야 하는 에러인지 확인
-     * - Rate limit/Quota 에러
-     * - 인증 에러 (토큰/키 없음)
-     */
-    shouldSkipRetry(errorMsg) {
-        const skipPatterns = [
-            // Rate limit / Quota
-            'rate limit',
-            'quota',
-            'exhausted',
-            '429',
-            'usage limit',
-            'too many requests',
-            // Auth errors (no token/key) - no retry needed
-            'no token',
-            'token not set',
-            'no api key',
-            'api key not set',
-            'missing token',
-            'missing api key',
-            'not authenticated',
-            'authentication failed',
-            'unauthorized',
-            '401',
-            'auth'
-        ];
-        const lowerMsg = errorMsg.toLowerCase();
-        return skipPatterns.some(pattern => lowerMsg.includes(pattern));
-    }
-    /**
-     * LLM 가용성 확인 (캐시 기반)
-     */
-    isLlmUnavailable(provider) {
-        if (provider === 'claude')
-            return false;
-        const cache = llmAvailabilityCache[provider];
-        const now = Date.now();
-        // 캐시 만료 확인
-        if (now - cache.checkedAt > LLM_CACHE_TTL) {
-            cache.available = true;
-            cache.errorCount = 0;
-            return false;
-        }
-        // 연속 3회 이상 실패 시 unavailable
-        return !cache.available || cache.errorCount >= 3;
-    }
-    /**
-     * LLM 가용 상태로 마킹
-     */
-    markLlmAvailable(provider) {
-        if (provider === 'claude')
-            return;
-        llmAvailabilityCache[provider] = {
-            available: true,
-            checkedAt: Date.now(),
-            errorCount: 0
-        };
-    }
-    /**
-     * LLM 불가용 상태로 마킹
-     */
-    markLlmUnavailable(provider) {
-        if (provider === 'claude')
-            return;
-        const cache = llmAvailabilityCache[provider];
-        cache.errorCount++;
-        cache.checkedAt = Date.now();
-        if (cache.errorCount >= 3) {
-            cache.available = false;
-        }
+        return this.router.route(request);
     }
-    /**
-     * Fallback 메시지 생성 (Claude가 직접 처리하도록 안내)
-     */
-    buildFallbackMessage(type, prompt, errors) {
-        const errorSummary = Object.entries(errors)
-            .map(([provider, msg]) => `- ${provider}: ${msg}`)
-            .join('\n');
-        return `[External LLM Unavailable - Claude Direct Handling]
-
-All external LLMs failed. Claude should handle this ${type} task directly.
-
-**Original Request:**
-${prompt}
-
-**Failed Providers:**
-${errorSummary}
-
-**Action Required:**
-Claude, please handle this task using your own capabilities. Do NOT retry external LLMs.`;
-    }
-    /**
-     * 지연 유틸리티
-     */
-    delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * 웹 검색 with fallback (GPT → Gemini → Claude WebSearch)
-     */
     async smartWebSearch(query) {
-        return this.smartRoute({
-            type: 'web-search',
-            prompt: query,
-            systemPrompt: 'Search the web and provide relevant information.'
-        });
+        return this.router.webSearch(query);
     }
-    /**
-     * 아키텍처 분석 with fallback
-     */
     async smartArchitectureReview(prompt) {
-        return this.smartRoute({
-            type: 'architecture',
-            prompt,
-            systemPrompt: 'You are a software architect. Analyze and review the architecture.'
-        });
+        return this.router.architectureReview(prompt);
     }
-    /**
-     * UI/UX 분석 with fallback
-     */
     async smartUiuxReview(prompt) {
-        return this.smartRoute({
-            type: 'uiux',
-            prompt,
-            systemPrompt: 'You are a UI/UX expert. Analyze and provide feedback.'
-        });
+        return this.router.uiuxReview(prompt);
     }
-    /**
-     * 코드 분석 with fallback
-     */
     async smartCodeAnalysis(prompt) {
-        return this.smartRoute({
-            type: 'code-analysis',
-            prompt,
-            systemPrompt: 'You are a code analysis expert. Review and analyze the code.'
-        });
+        return this.router.codeAnalysis(prompt);
     }
-    /**
-     * 디버깅 with fallback
-     */
     async smartDebugging(prompt) {
-        return this.smartRoute({
-            type: 'debugging',
-            prompt,
-            systemPrompt: 'You are a debugging expert. Find bugs and suggest fixes.'
-        });
+        return this.router.debugging(prompt);
     }
-    /**
-     * 코드 생성 with fallback (Claude 직접)
-     */
     async smartCodeGen(description, context) {
-        const prompt = context
-            ? `${description}\n\nContext:\n${context}`
-            : description;
-        return this.smartRoute({
-            type: 'code-gen',
-            prompt,
-            systemPrompt: 'Generate clean, well-documented code.'
-        });
+        return this.router.codeGen(description, context);
     }
-    /**
-     * 에이전트 탐색
-     */
+    // ============================================
+    // Agent Management (AgentManager 위임)
+    // ============================================
     async discoverAgents(category) {
-        const result = await discoverAgents({
-            projectPath: this.options.projectPath,
-            category
-        });
-        if ('agents' in result) {
-            return result.agents;
-        }
-        return [];
+        return this.agentManager.discover(category);
     }
-    /**
-     * 특정 에이전트 로드
-     */
     async loadAgent(agentName) {
-        return loadAgent(agentName, this.options.projectPath);
+        return this.agentManager.load(agentName);
     }
-    /**
-     * 병렬 리서치 실행
-     */
+    async launchAgent(args) {
+        return this.agentManager.launch(args);
+    }
+    async launchAgents(configs) {
+        return this.agentManager.launchParallel(configs);
+    }
+    async getAgentResult(sessionId) {
+        return this.agentManager.getResult(sessionId);
+    }
+    cancelAgent(sessionId) {
+        return this.agentManager.cancel(sessionId);
+    }
+    getActiveSessions() {
+        return this.agentManager.getActiveSessions();
+    }
+    getHistory(limit = 10) {
+        return this.agentManager.getHistory(limit);
+    }
+    async runParallelReview(filePaths, techStack = []) {
+        const results = await this.agentManager.runParallelReview(filePaths, techStack);
+        if (this.options.saveResults) {
+            await this.saveOrchestratorResult('review', { results, filePaths, techStack });
+        }
+        return results;
+    }
+    // ============================================
+    // Parallel Research
+    // ============================================
     async runParallelResearch(args) {
         const result = await parallelResearch({
             ...args,
             projectPath: args.projectPath || this.options.projectPath
         });
-        // 결과 저장
         if (this.options.saveResults && 'results' in result) {
             await this.saveOrchestratorResult('research', result);
         }
@@ -337,20 +117,14 @@ Claude, please handle this task using your own capabilities. Do NOT retry extern
             failureCount: 0
         };
     }
-    /**
-     * 기능 기반 리서치 (간편 API)
-     * v2.5.0: Multi-LLM Research (Claude + GPT + Gemini) 지원
-     */
     async researchFeature(feature, techStack = []) {
         const tasks = createResearchTasks(feature, techStack);
-        // Multi-LLM 리서치 (Claude 에이전트 + GPT + Gemini 병렬 실행)
         const result = await parallelResearchWithMultiLlm({
             tasks,
             projectPath: this.options.projectPath,
             feature,
             techStack
         });
-        // 결과 저장
         if (this.options.saveResults && 'results' in result) {
             await this.saveOrchestratorResult('research', result);
         }
@@ -364,150 +138,41 @@ Claude, please handle this task using your own capabilities. Do NOT retry extern
             failureCount: 0
         };
     }
-    /**
-     * 백그라운드 에이전트 시작
-     */
-    async launchAgent(args) {
-        const result = await launchBackgroundAgent({
-            ...args,
-            projectPath: args.projectPath || this.options.projectPath
-        });
-        if ('handle' in result) {
-            return result.handle;
-        }
-        return null;
+    // ============================================
+    // LLM Integration (LLMCluster 위임)
+    // ============================================
+    /** @deprecated GPT Codex API는 웹 검색을 지원하지 않습니다. geminiWebSearch를 사용하세요. */
+    async gptWebSearch(query) {
+        return this.llmCluster.gptWebSearch(query);
     }
-    /**
-     * 여러 에이전트 동시 실행
-     */
-    async launchAgents(configs) {
-        const result = await launchParallelAgents(configs.map(c => ({
-            ...c,
-            projectPath: c.projectPath || this.options.projectPath
-        })));
-        if ('handles' in result) {
-            return result.handles;
-        }
-        return [];
+    async gptOrchestrate(prompt, systemPrompt, options) {
+        return this.llmCluster.gptOrchestrate(prompt, systemPrompt, options);
     }
-    /**
-     * 에이전트 결과 조회
-     */
-    async getAgentResult(sessionId) {
-        const result = await getBackgroundAgentResult(sessionId);
-        if ('result' in result) {
-            return result.result;
-        }
-        return null;
+    async geminiWebSearch(query) {
+        return this.llmCluster.geminiWebSearch(query);
     }
-    /**
-     * 에이전트 취소
-     */
-    cancelAgent(sessionId) {
-        const result = cancelBackgroundAgent(sessionId);
-        return result.content[0].text.includes('cancelled');
+    async geminiOrchestrate(prompt, systemPrompt, options) {
+        return this.llmCluster.geminiOrchestrate(prompt, systemPrompt, options);
     }
-    /**
-     * 활성 세션 목록
-     */
-    getActiveSessions() {
-        return listActiveSessions();
+    async multiLlmQuery(prompt, options) {
+        return this.llmCluster.multiQuery(prompt, options);
     }
-    /**
-     * 세션 히스토리
-     */
-    getHistory(limit = 10) {
-        return getSessionHistory(limit);
+    async checkLlmStatus() {
+        return this.llmCluster.checkStatus();
     }
-    /**
-     * 리뷰 에이전트 병렬 실행
-     * /vibe.review에서 사용
-     */
-    async runParallelReview(filePaths, techStack = []) {
-        // 리뷰 에이전트 탐색
-        const reviewAgents = await listAgentsByCategory('review', this.options.projectPath);
-        // 기술 스택에 맞는 에이전트만 필터링
-        const relevantAgents = this.filterRelevantAgents(reviewAgents, techStack);
-        // 각 에이전트에 대한 프롬프트 생성
-        const agentConfigs = relevantAgents.map(agent => ({
-            agentName: agent.name,
-            prompt: this.buildReviewPrompt(agent, filePaths),
-            model: DEFAULT_MODELS.REVIEW,
-            maxTurns: 3,
-            allowedTools: ['Read', 'Glob', 'Grep']
-        }));
-        // 병렬 실행
-        const handles = await this.launchAgents(agentConfigs);
-        // 모든 결과 수집
-        const results = [];
-        for (const handle of handles) {
-            const result = await handle.getResult();
-            results.push(result);
-        }
-        // 결과 저장
-        if (this.options.saveResults) {
-            await this.saveOrchestratorResult('review', { results, filePaths, techStack });
-        }
-        return results;
+    // ============================================
+    // Memory Management
+    // ============================================
+    saveToMemory(key, value, category = 'orchestrator') {
+        this.memoryManager.save(key, value, category);
     }
-    /**
-     * 기술 스택에 맞는 에이전트 필터링
-     */
-    filterRelevantAgents(agents, techStack) {
-        // 항상 실행할 코어 리뷰어
-        const coreReviewers = [
-            'security-reviewer',
-            'performance-reviewer',
-            'architecture-reviewer',
-            'complexity-reviewer',
-            'simplicity-reviewer',
-            'data-integrity-reviewer',
-            'test-coverage-reviewer',
-            'git-history-reviewer'
-        ];
-        // 스택별 리뷰어 매핑
-        const stackReviewers = {
-            typescript: ['typescript-reviewer'],
-            python: ['python-reviewer'],
-            react: ['react-reviewer'],
-            rails: ['rails-reviewer'],
-            ruby: ['rails-reviewer']
-        };
-        const relevantNames = new Set(coreReviewers);
-        // 기술 스택에 맞는 리뷰어 추가
-        for (const tech of techStack) {
-            const reviewers = stackReviewers[tech.toLowerCase()];
-            if (reviewers) {
-                reviewers.forEach(r => relevantNames.add(r));
-            }
-        }
-        return agents.filter(agent => {
-            const normalizedName = agent.name.toLowerCase().replace(/\s+/g, '-');
-            return relevantNames.has(normalizedName) ||
-                Array.from(relevantNames).some(r => normalizedName.includes(r));
-        });
+    getFromMemory(key) {
+        const memory = this.memoryManager.recall(key);
+        return memory?.value || null;
     }
-    /**
-     * 리뷰 프롬프트 생성
-     */
-    buildReviewPrompt(agent, filePaths) {
-        return `You are a ${agent.name}. Review the following files for issues in your domain:
-
-Files to review:
-${filePaths.map(f => `- ${f}`).join('\n')}
-
-${agent.content}
-
-Provide findings in this format:
-- Priority: P1 (Critical), P2 (Important), P3 (Nice-to-have)
-- Category: Your specialty area
-- Location: file:line
-- Issue: Description
-- Fix: Recommendation`;
-    }
-    /**
-     * 결과 저장
-     */
+    // ============================================
+    // Internal Utilities
+    // ============================================
     async saveOrchestratorResult(type, data) {
         const resultsDir = path.join(this.options.projectPath, this.options.resultsPath);
         try {
@@ -523,106 +188,17 @@ Provide findings in this format:
             errorLog('Failed to save orchestrator result:', error);
         }
     }
-    /**
-     * 메모리에 결과 저장
-     */
-    saveToMemory(key, value, category = 'orchestrator') {
-        this.memoryManager.save(key, value, category);
-    }
-    /**
-     * 메모리에서 결과 조회
-     */
-    getFromMemory(key) {
-        const memory = this.memoryManager.recall(key);
-        return memory?.value || null;
-    }
-    // ============================================
-    // GPT Integration (웹 검색, 아키텍처 분석)
     // ============================================
-    /**
-     * GPT 웹 검색 (Gemini로 위임)
-     * @param query 검색 쿼리
-     * @deprecated GPT Codex API는 웹 검색을 지원하지 않습니다. geminiWebSearch를 사용하세요.
-     */
-    async gptWebSearch(query) {
-        // GPT Codex API는 웹 검색 미지원 → Gemini로 위임
-        return this.geminiWebSearch(query);
-    }
-    /**
-     * GPT 오케스트레이션
-     * @param prompt 프롬프트
-     * @param systemPrompt 시스템 프롬프트
-     * @param options 옵션 (jsonMode 등)
-     */
-    async gptOrchestrate(prompt, systemPrompt = 'You are a helpful assistant.', options) {
-        return gptApi.vibeGptOrchestrate(prompt, systemPrompt, options);
-    }
+    // Component Accessors (고급 사용)
     // ============================================
-    // Gemini Integration (UI/UX 분석, 코드 분석)
-    // ============================================
-    /**
-     * Gemini 웹 검색
-     * @param query 검색 쿼리
-     */
-    async geminiWebSearch(query) {
-        return geminiApi.quickWebSearch(query);
+    getRouter() {
+        return this.router;
     }
-    /**
-     * Gemini 오케스트레이션
-     * @param prompt 프롬프트
-     * @param systemPrompt 시스템 프롬프트
-     * @param options 옵션 (jsonMode 등)
-     */
-    async geminiOrchestrate(prompt, systemPrompt = 'You are a helpful assistant.', options) {
-        return geminiApi.vibeGeminiOrchestrate(prompt, systemPrompt, options);
+    getLLMCluster() {
+        return this.llmCluster;
     }
-    // ============================================
-    // Multi-LLM Orchestration
-    // ============================================
-    /**
-     * 멀티 LLM 병렬 쿼리
-     * GPT, Gemini 동시 호출하여 결과 비교
-     */
-    async multiLlmQuery(prompt, options) {
-        const { useGpt = true, useGemini = true } = options || {};
-        const results = {};
-        const promises = [];
-        if (useGpt) {
-            promises.push(gptApi.vibeGptOrchestrate(prompt, 'You are a helpful assistant.', { jsonMode: false })
-                .then(r => { results.gpt = r; }).catch(e => { warnLog('GPT query failed in multiLlm', e); }));
-        }
-        if (useGemini) {
-            promises.push(geminiApi.vibeGeminiOrchestrate(prompt, 'You are a helpful assistant.', { jsonMode: false })
-                .then(r => { results.gemini = r; }).catch(e => { warnLog('Gemini query failed in multiLlm', e); }));
-        }
-        await Promise.all(promises);
-        return results;
-    }
-    /**
-     * LLM 상태 확인 (전체)
-     */
-    async checkLlmStatus() {
-        // GPT/Gemini는 실제 호출로 확인
-        let gptAvailable = false;
-        let geminiAvailable = false;
-        try {
-            await gptApi.vibeGptOrchestrate('ping', 'Reply with pong', { jsonMode: false });
-            gptAvailable = true;
-        }
-        catch (e) {
-            warnLog('GPT status check failed', e);
-        }
-        try {
-            await geminiApi.vibeGeminiOrchestrate('ping', 'Reply with pong', { jsonMode: false });
-            geminiAvailable = true;
-        }
-        catch (e) {
-            warnLog('Gemini status check failed', e);
-        }
-        return {
-            gpt: { available: gptAvailable },
-            gemini: { available: geminiAvailable }
-        };
+    getAgentManager() {
+        return this.agentManager;
     }
 }
 // 싱글톤 인스턴스 (선택적 사용)