pdca/dist/core/ai-engine-adapter.js

🎯 AI 驅動的 PDCA 多代理開發系統 - 智能循環控制 + 成本管理 + Token 優化 + 多 AI 引擎支援

/**
 * AI 引擎適配器
 * 統一支援多種 AI CLI (Claude, Gemini, OpenAI 等)
 */
import { execSync, spawn } from 'child_process';
import { EventEmitter } from 'events';
/**
 * Claude CLI 適配器
 */
export class ClaudeEngine {
    name = 'Claude CLI';
    command = 'claude';
    checkCommand = 'claude --version';
    async isAvailable() {
        try {
            execSync(this.checkCommand, { stdio: 'ignore' });
            return true;
        }
        catch {
            return false;
        }
    }
    async executePrompt(prompt) {
        // Claude CLI 不支援直接執行 prompt
        // 需要透過檔案系統或其他方式
        throw new Error('Claude CLI 不支援直接執行 prompt，請使用互動模式');
    }
    startInteractive() {
        return spawn(this.command, [], {
            stdio: 'pipe',
            shell: true
        });
    }
}
/**
 * Gemini CLI 適配器
 */
export class GeminiEngine {
    name = 'Gemini CLI';
    command = 'gemini';
    checkCommand = 'gemini --version';
    promptFlag = '-p';
    async isAvailable() {
        try {
            execSync(this.checkCommand, { stdio: 'ignore' });
            return true;
        }
        catch {
            return false;
        }
    }
    async executePrompt(prompt) {
        try {
            // 使用 gemini -p 執行 prompt
            const result = execSync(`gemini -p "${prompt.replace(/"/g, '\\"')}"`, {
                encoding: 'utf8',
                maxBuffer: 10 * 1024 * 1024 // 10MB
            });
            return result;
        }
        catch (error) {
            throw new Error(`Gemini 執行失敗: ${error.message}`);
        }
    }
    startInteractive() {
        return spawn(this.command, [], {
            stdio: 'pipe',
            shell: true
        });
    }
}
/**
 * OpenAI CLI 適配器
 */
export class OpenAIEngine {
    name = 'OpenAI CLI';
    command = 'openai';
    checkCommand = 'openai --version';
    async isAvailable() {
        try {
            execSync(this.checkCommand, { stdio: 'ignore' });
            return true;
        }
        catch {
            return false;
        }
    }
    async executePrompt(prompt) {
        try {
            const result = execSync(`openai complete --prompt "${prompt.replace(/"/g, '\\"')}"`, {
                encoding: 'utf8',
                maxBuffer: 10 * 1024 * 1024
            });
            return result;
        }
        catch (error) {
            throw new Error(`OpenAI 執行失敗: ${error.message}`);
        }
    }
}
/**
 * AI 引擎管理器
 */
export class AIEngineManager extends EventEmitter {
    engines = [
        new ClaudeEngine(),
        new GeminiEngine(),
        new OpenAIEngine()
    ];
    selectedEngine;
    /**
     * 檢測所有可用的 AI 引擎
     */
    async detectAvailableEngines() {
        const available = [];
        console.log('🔍 檢測可用的 AI CLI...');
        for (const engine of this.engines) {
            if (await engine.isAvailable()) {
                available.push(engine);
                console.log(`✅ 檢測到 ${engine.name}`);
                this.emit('engine-detected', engine);
            }
            else {
                console.log(`❌ 未找到 ${engine.name}`);
            }
        }
        if (available.length === 0) {
            console.log('\n⚠️  未檢測到任何 AI CLI');
            console.log('請安裝至少一個 AI CLI：');
            console.log('- Gemini CLI (免費): npm install -g @google/gemini-cli');
            console.log('- Claude CLI: https://claude.ai/cli');
        }
        return available;
    }
    /**
     * 自動選擇最佳引擎
     */
    async selectBestEngine() {
        const available = await this.detectAvailableEngines();
        if (available.length === 0) {
            throw new Error('未檢測到任何 AI CLI，請至少安裝一個');
        }
        // 優先順序：Claude > Gemini > 其他
        const priorityOrder = ['claude', 'gemini', 'openai'];
        for (const cmd of priorityOrder) {
            const engine = available.find(e => e.command === cmd);
            if (engine) {
                this.selectedEngine = engine;
                console.log(`\n🚀 使用 ${engine.name} 作為 AI 引擎`);
                this.emit('engine-selected', engine);
                return engine;
            }
        }
        // 使用第一個可用的
        this.selectedEngine = available[0];
        console.log(`\n🚀 使用 ${this.selectedEngine.name} 作為 AI 引擎`);
        this.emit('engine-selected', this.selectedEngine);
        return this.selectedEngine;
    }
    /**
     * 根據名稱選擇引擎
     */
    async selectEngineByName(name) {
        const engine = this.engines.find(e => e.command === name ||
            e.name.toLowerCase().includes(name.toLowerCase()));
        if (!engine) {
            throw new Error(`未知的 AI 引擎: ${name}`);
        }
        if (!await engine.isAvailable()) {
            throw new Error(`${engine.name} 未安裝或不可用`);
        }
        this.selectedEngine = engine;
        console.log(`🚀 使用 ${engine.name} 作為 AI 引擎`);
        this.emit('engine-selected', engine);
        return engine;
    }
    /**
     * 獲取當前選擇的引擎
     */
    getSelectedEngine() {
        return this.selectedEngine;
    }
    /**
     * 添加自定義引擎
     */
    addEngine(engine) {
        this.engines.push(engine);
    }
}
export default AIEngineManager;
//# sourceMappingURL=ai-engine-adapter.js.map