aiexecode 1.0.157

package/src/ai_based/pip_package_installer.js

@@ -0,0 +1,173 @@
+import { checkValidPackageName } from "./pip_package_lookup.js";
+import { installPythonPackage, isPackageInstalled, analyzeImports } from "../system/code_executer.js";
+import { createDebugLogger } from "../util/debug_log.js";
+
+const debugLog = createDebugLogger('pip_package_installer.log', 'pip_package_installer');
+
+// 이 파일은 코드에서 필요로 하는 파이썬 패키지를 확인하고 자동으로 설치합니다.
+// Code Executer가 스크립트를 실행할 때 패키지 누락 오류가 나지 않도록 Orchestrator 실행 이전에 환경을 준비합니다.
+
+// 하나의 파일을 분석해 필요한 외부 패키지를 찾아 설치합니다.
+export async function installRequiredPackages(filePath) {
+    try {
+        const analysisResult = await analyzeImports(filePath);
+        const externalPackages = analysisResult;
+        if (externalPackages.length === 0) {
+            return {
+                success: true,
+                message: "No external packages required",
+                installedPackages: []
+            };
+        }
+        const validPackageNames = await checkValidPackageName(externalPackages);
+        const installResults = [];
+        const alreadyInstalled = [];
+        const failedInstalls = [];
+
+        for (const packageName of validPackageNames) {
+            const isInstalled = await isPackageInstalled(packageName);
+            if (isInstalled) {
+                alreadyInstalled.push(packageName);
+                continue;
+            }
+            const installSuccess = await installPythonPackage(packageName);
+            if (installSuccess) {
+                installResults.push(packageName);
+            } else {
+                failedInstalls.push(packageName);
+            }
+        }
+
+        return {
+            success: failedInstalls.length === 0,
+            originalPackages: externalPackages,
+            validatedPackages: validPackageNames,
+            installedPackages: installResults,
+            alreadyInstalled: alreadyInstalled,
+            failedInstalls: failedInstalls,
+            summary: {
+                total: validPackageNames.length,
+                installed: installResults.length,
+                alreadyInstalled: alreadyInstalled.length,
+                failed: failedInstalls.length
+            }
+        };
+
+    } catch (error) {
+        return {
+            success: false,
+            error: error.message,
+            details: error
+        };
+    }
+}
+
+export async function installPackageList(packageList) {
+    try {
+        debugLog(`\n=== Installing package list ===`);
+        debugLog("Packages to install:", packageList);
+
+        const validPackageNames = await checkValidPackageName(packageList);
+        debugLog("Valid package names:", validPackageNames);
+
+        const installResults = [];
+        const alreadyInstalled = [];
+        const failedInstalls = [];
+
+        for (const packageName of validPackageNames) {
+            debugLog(`\n--- Processing package: ${packageName} ---`);
+
+            const isInstalled = await isPackageInstalled(packageName);
+            if (isInstalled) {
+                debugLog(`[SKIP] ${packageName} is already installed`);
+                alreadyInstalled.push(packageName);
+                continue;
+            }
+
+            debugLog(`Installing ${packageName}...`);
+            const installSuccess = await installPythonPackage(packageName);
+
+            if (installSuccess) {
+                debugLog(`[OK] Successfully installed ${packageName}`);
+                installResults.push(packageName);
+            } else {
+                debugLog(`[FAIL] Failed to install ${packageName}`);
+                failedInstalls.push(packageName);
+            }
+        }
+
+        return {
+            success: failedInstalls.length === 0,
+            originalPackages: packageList,
+            validatedPackages: validPackageNames,
+            installedPackages: installResults,
+            alreadyInstalled: alreadyInstalled,
+            failedInstalls: failedInstalls,
+            summary: {
+                total: validPackageNames.length,
+                installed: installResults.length,
+                alreadyInstalled: alreadyInstalled.length,
+                failed: failedInstalls.length
+            }
+        };
+
+    } catch (error) {
+        return {
+            success: false,
+            error: error.message,
+            details: error
+        };
+    }
+}
+
+export async function installRequiredPackagesForFiles(filePaths) {
+    try {
+        debugLog(`\n=== Analyzing multiple files ===`);
+        debugLog("Files to analyze:", filePaths);
+
+        const allExternalPackages = new Set();
+        const analysisResults = [];
+
+        for (const filePath of filePaths) {
+            const analysisResult = await analyzeImports(filePath);
+            analysisResults.push({
+                file: filePath,
+                success: analysisResult.success,
+                packages: analysisResult.success ? analysisResult.data.external_packages : []
+            });
+
+            if (analysisResult.success) {
+                analysisResult.data.external_packages.forEach(pkg =>
+                    allExternalPackages.add(pkg)
+                );
+            }
+        }
+
+        const uniquePackages = Array.from(allExternalPackages);
+        debugLog("All unique external packages:", uniquePackages);
+
+        if (uniquePackages.length === 0) {
+            return {
+                success: true,
+                message: "No external packages required",
+                analysisResults: analysisResults,
+                installedPackages: []
+            };
+        }
+
+        const installResult = await installPackageList(uniquePackages);
+
+        return {
+            ...installResult,
+            analysisResults: analysisResults,
+            filesAnalyzed: filePaths.length
+        };
+
+    } catch (error) {
+        return {
+            success: false,
+            error: error.message,
+            details: error
+        };
+    }
+}

package/src/ai_based/pip_package_lookup.js

@@ -0,0 +1,197 @@
+import dotenv from "dotenv";
+import { request, getModelForProvider } from "../system/ai_request.js";
+import { safeReadFile, safeWriteFile } from '../util/safe_fs.js';
+import { join } from 'path';
+import { CONFIG_DIR, ensureConfigDirectory } from "../util/config.js";
+import { createDebugLogger } from "../util/debug_log.js";
+
+const debugLog = createDebugLogger('pip_package_lookup.log', 'pip_package_lookup');
+
+dotenv.config({ quiet: true });
+
+// 이 파일은 import에 쓰인 이름을 실제 pip 설치 이름과 연결해 줍니다.
+// pip_package_installer가 정확한 패키지를 설치할 수 있도록 모든 모듈이 같은 이름을 공유하게 만듭니다.
+// Package name cache file path
+const CACHE_FILE = join(CONFIG_DIR, 'package_name_store.json');
+
+// 캐시 파일에서 미리 확인해 둔 패키지 매핑을 읽어옵니다.
+async function loadPackageStore() {
+    try {
+        await ensureConfigDirectory();
+        const data = await safeReadFile(CACHE_FILE, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        // Return empty object if file doesn't exist or can't be read
+        return {};
+    }
+}
+
+// 새로 찾은 패키지 정보를 캐시 파일에 저장합니다.
+async function savePackageStore(store) {
+    try {
+        await ensureConfigDirectory();
+        await safeWriteFile(CACHE_FILE, JSON.stringify(store, null, 2), 'utf8');
+        debugLog(`✓ Package cache saved to ${CACHE_FILE}`);
+    } catch (error) {
+        debugLog('Failed to save package cache:', error);
+    }
+}
+
+
+const pythonPackageNameListSchema = {
+    "type": "object",
+    "properties": {
+        "package_mappings": {
+            "type": "array",
+            "description": "List of mappings between import names and pip install package names.",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "import_name": {
+                        "type": "string",
+                        "description": "Python module import name.",
+                        "minLength": 1
+                    },
+                    "pip_name": {
+                        "type": "string",
+                        "description": "Package name used for pip install.",
+                        "minLength": 1
+                    }
+                },
+                "required": [
+                    "import_name",
+                    "pip_name"
+                ],
+                "additionalProperties": false
+            }
+        }
+    },
+    "required": [
+        "package_mappings"
+    ],
+    "additionalProperties": false
+};
+
+// AI에게 전달할 대화 형식 메시지 묶음을 만들어 줍니다.
+function buildConversationHistory(systemMessage, dialogHistory) {
+    const messages = [
+        {
+            role: "system",
+            content: [{
+                type: "input_text",
+                text: systemMessage
+            }]
+        }
+    ];
+
+    for (const dialog of dialogHistory) {
+        messages.push({
+            role: dialog.role,
+            content: [{
+                type: "input_text",
+                text: dialog.content
+            }]
+        });
+    }
+
+    return messages;
+}
+
+// import 이름 목록을 받아 실제 pip 패키지 이름을 알려줍니다.
+export async function checkValidPackageName(pkgList) {
+    const taskName = 'pip_package_lookup';
+    
+    // 1. 캐시 파일에서 패키지 매핑 로드
+    const packageStore = await loadPackageStore();
+    
+    // 2. 캐시에서 확인할 수 있는 패키지들과 AI 요청이 필요한 패키지들 분리
+    const cachedResults = [];
+    const uncachedPackages = [];
+    
+    for (const pkg of pkgList) {
+        if (packageStore.hasOwnProperty(pkg)) {
+            debugLog(`✓ Found in cache: ${pkg} -> ${packageStore[pkg]}`);
+            // 캐시된 값이 null이 아닌 경우만 결과에 추가 (표준 라이브러리는 null로 저장됨)
+            if (packageStore[pkg] !== null) {
+                cachedResults.push(packageStore[pkg]);
+            }
+        } else {
+            uncachedPackages.push(pkg);
+        }
+    }
+    
+    // 3. 캐시되지 않은 패키지가 없으면 캐시 결과만 반환
+    if (uncachedPackages.length === 0) {
+        debugLog("All packages found in cache, no AI request needed");
+        return cachedResults;
+    }
+    
+    debugLog(`Cache miss for packages: ${uncachedPackages.join(', ')}`);
+    debugLog("Making AI request for uncached packages...");
+    
+    // 4. AI에게 캐시되지 않은 패키지들만 요청
+    const codeGenerationTemplate = [
+        "You are an expert in validating PyPI Python package names.",
+        "The user will provide package names used in imports.",
+        "Respond with the correct package names for pip install.",
+        "For example: 'PIL' should be 'Pillow', 'cv2' should be 'opencv-python'.",
+        "If a package is part of Python standard library, exclude it from the list."
+    ].join("\n");
+
+    const dialogHistory = [{
+        role: 'user',
+        content: `Package names to validate: ${uncachedPackages.join(', ')}`
+    }];
+
+    const conversationHistory = buildConversationHistory(codeGenerationTemplate, dialogHistory);
+
+    try {
+        const model = await getModelForProvider();
+        const response = await request(taskName, {
+            model: model,
+            input: conversationHistory,
+            text: {
+                "format": {
+                    "type": "json_schema",
+                    "name": "pip_package_name_list",
+                    "strict": true,
+                    "schema": pythonPackageNameListSchema
+                }
+            },
+            reasoning: {},
+            max_output_tokens: 2048,
+            store: true
+        });
+        const codeResponse = JSON.parse(response.output_text);
+
+        // 5. AI 응답 결과를 캐시에 저장
+        const aiResults = [];
+        const receivedMappings = new Set();
+        
+        for (const { import_name, pip_name } of codeResponse.package_mappings) {
+            packageStore[import_name] = pip_name;
+            aiResults.push(pip_name);
+            receivedMappings.add(import_name);
+            debugLog(`✓ Cached: ${import_name} -> ${pip_name}`);
+        }
+        
+        // 6. AI 응답에 포함되지 않은 패키지들은 표준 라이브러리로 간주하여 null로 캐시
+        for (const pkg of uncachedPackages) {
+            if (!receivedMappings.has(pkg)) {
+                packageStore[pkg] = null;
+                debugLog(`✓ Cached as standard library: ${pkg} -> null`);
+            }
+        }
+
+        // 7. 업데이트된 캐시를 파일에 저장
+        await savePackageStore(packageStore);
+
+        // 8. 캐시 결과와 AI 결과 합쳐서 반환
+        return [...cachedResults, ...aiResults];
+        
+    } catch (error) {
+        debugLog("Error validating package names:", error);
+        // 에러 발생 시 캐시 결과와 원본 패키지명 반환
+        return [...cachedResults, ...uncachedPackages];
+    }
+}

package/src/cli/mcp_cli.js

@@ -0,0 +1,70 @@
+// MCP CLI 명령어 등록
+// CLI 환경에서 MCP 서버 설정을 관리하는 명령어들을 등록
+import { Command } from 'commander';
+import {
+    addMcpServer,
+    listMcpServers,
+    getMcpServer,
+    removeMcpServer,
+    addMcpServerFromJson
+} from './mcp_commands.js';
+
+/**
+ * MCP 관련 CLI 명령어를 commander 프로그램에 등록
+ * 사용자가 터미널에서 'aiexecode mcp ...' 명령으로 MCP 서버를 관리할 수 있게 함
+ * @param {Command} program - Commander 프로그램 인스턴스
+ */
+export function registerMcpCliCommands(program) {
+    // 'mcp' 상위 명령어 생성 (aiexecode mcp ...)
+    const mcp = program
+        .command('mcp')
+        .description('Manage MCP (Model Context Protocol) servers');
+
+    // 'aiexecode mcp add' - MCP 서버 추가 명령어
+    // stdio, http, sse 등 다양한 전송 방식을 지원
+    mcp.command('add')
+        .description('Add an MCP server')
+        .option('--transport <type>', 'Transport type: stdio, http, or sse', 'stdio')
+        .option('--env <key=value>', 'Environment variable (repeatable)', collect, [])
+        .option('--header <key:value>', 'HTTP header (repeatable)', collect, [])
+        .argument('<name>', 'Server name')
+        .argument('[args...]', 'Command and arguments (for stdio) or URL (for http/sse)')
+        .action(addMcpServer);
+
+    // 'aiexecode mcp list' - 설정된 모든 MCP 서버 목록 조회
+    mcp.command('list')
+        .description('List all configured MCP servers')
+        .action(listMcpServers);
+
+    // 'aiexecode mcp get <name>' - 특정 MCP 서버의 상세 정보 조회
+    mcp.command('get')
+        .description('Get details of a specific MCP server')
+        .argument('<name>', 'Server name')
+        .action(getMcpServer);
+
+    // 'aiexecode mcp remove <name>' - MCP 서버 설정 제거
+    mcp.command('remove')
+        .description('Remove an MCP server')
+        .argument('<name>', 'Server name')
+        .action(removeMcpServer);
+
+    // 'aiexecode mcp add-json <name> <json>' - JSON 형식으로 MCP 서버 추가
+    // 복잡한 설정을 한 번에 추가할 때 유용
+    mcp.command('add-json')
+        .description('Add an MCP server from JSON configuration')
+        .argument('<name>', 'Server name')
+        .argument('<json>', 'JSON configuration string')
+        .action(addMcpServerFromJson);
+}
+
+/**
+ * 반복 가능한 옵션 수집 헬퍼 함수
+ * Commander.js에서 --env, --header 같은 옵션을 여러 번 사용할 수 있게 함
+ * 예: --env KEY1=val1 --env KEY2=val2
+ * @param {string} value - 새 값
+ * @param {Array} previous - 이전 값들
+ * @returns {Array} 누적된 값 배열
+ */
+function collect(value, previous) {
+    return previous.concat([value]);
+}

package/src/cli/mcp_commands.js

@@ -0,0 +1,255 @@
+// MCP CLI 명령어 핸들러
+// 각 CLI 명령어의 실제 동작을 구현
+import chalk from 'chalk';
+import {
+    addServerToScope,
+    getMcpConfigPath,
+    loadMergedMcpConfig,
+    removeServerFromScope,
+    findServerScope
+} from '../util/mcp_config_manager.js';
+
+/**
+ * MCP 서버 추가 명령어 핸들러
+ * 사용자가 입력한 정보를 바탕으로 MCP 서버 설정을 생성하고 저장
+ */
+export async function addMcpServer(name, args, options) {
+    const { transport, env, header } = options;
+
+    try {
+        // 전송 방식에 따른 서버 설정 객체 생성
+        let serverConfig = { type: transport };
+
+        if (transport === 'stdio') {
+            // stdio 방식: 로컬 프로세스를 실행하여 stdin/stdout으로 MCP 통신
+            // 예: npx -y @modelcontextprotocol/server-github
+            if (args.length === 0) {
+                console.error(chalk.red('Error: stdio transport requires command'));
+                console.error(chalk.gray('\nExample:'));
+                console.error(chalk.cyan('  aiexecode mcp add --transport stdio github -- npx -y @modelcontextprotocol/server-github'));
+                process.exit(1);
+            }
+
+            serverConfig.command = args[0];
+            serverConfig.args = args.slice(1);
+
+            // 환경 변수 파싱 및 추가 (KEY=VALUE 형식)
+            if (env.length > 0) {
+                serverConfig.env = {};
+                env.forEach(item => {
+                    const [key, value] = item.split('=');
+                    if (!key || value === undefined) {
+                        console.error(chalk.red(`Error: Invalid env format '${item}'. Use KEY=VALUE`));
+                        process.exit(1);
+                    }
+                    serverConfig.env[key] = value;
+                });
+            }
+
+        } else if (transport === 'http' || transport === 'sse') {
+            // http/sse 방식: 원격 HTTP(S) 서버와 통신
+            // http: 일반 HTTP 요청/응답
+            // sse: Server-Sent Events (실시간 스트리밍)
+            if (args.length === 0) {
+                console.error(chalk.red(`Error: ${transport} transport requires URL`));
+                console.error(chalk.gray('\nExample:'));
+                console.error(chalk.cyan(`  aiexecode mcp add --transport ${transport} notion https://mcp.notion.com/mcp`));
+                process.exit(1);
+            }
+
+            serverConfig.url = args[0];
+
+            // HTTP 헤더 파싱 및 추가 (KEY:VALUE 형식)
+            // 인증 토큰 등을 전달할 때 사용
+            if (header.length > 0) {
+                serverConfig.headers = {};
+                header.forEach(item => {
+                    const colonIndex = item.indexOf(':');
+                    if (colonIndex === -1) {
+                        console.error(chalk.red(`Error: Invalid header format '${item}'. Use KEY:VALUE`));
+                        process.exit(1);
+                    }
+                    const key = item.substring(0, colonIndex).trim();
+                    const value = item.substring(colonIndex + 1).trim();
+                    serverConfig.headers[key] = value;
+                });
+            }
+        } else {
+            console.error(chalk.red(`Error: Unknown transport type '${transport}'`));
+            console.error(chalk.gray('Valid types: stdio, http, sse'));
+            process.exit(1);
+        }
+
+        // 생성된 서버 설정을 ~/.aiexe/mcp_config.json에 저장
+        const configPath = await addServerToScope(name, serverConfig);
+
+        console.log(chalk.green(`\n✓ MCP server '${name}' added successfully`));
+        console.log(chalk.gray(`  Config: ${configPath}`));
+
+        // 설정 요약 표시
+        console.log(chalk.gray('\n  Configuration:'));
+        console.log(chalk.gray(`    Type: ${transport}`));
+        if (transport === 'stdio') {
+            console.log(chalk.gray(`    Command: ${serverConfig.command} ${serverConfig.args?.join(' ') || ''}`));
+        } else {
+            console.log(chalk.gray(`    URL: ${serverConfig.url}`));
+        }
+
+        console.log(chalk.yellow('\nTo test the connection, start aiexecode and use /mcp'));
+        process.exit(0);
+
+    } catch (error) {
+        console.error(chalk.red(`\nError: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+/**
+ * MCP 서버 목록 표시 명령어 핸들러
+ * ~/.aiexe/mcp_config.json에 저장된 모든 MCP 서버 설정을 조회하여 표시
+ */
+export async function listMcpServers() {
+    try {
+        // 저장된 모든 MCP 서버 설정 로드
+        const servers = await loadMergedMcpConfig();
+        const serverNames = Object.keys(servers);
+
+        if (serverNames.length === 0) {
+            console.log(chalk.yellow('\nNo MCP servers configured'));
+            console.log(chalk.gray('\nTo add a server, run:'));
+            console.log(chalk.cyan('  aiexecode mcp add --transport stdio <name> -- <command>'));
+            console.log(chalk.cyan('  aiexecode mcp add --transport http <name> <url>'));
+            console.log(chalk.cyan('  aiexecode mcp add --transport sse <name> <url>'));
+            process.exit(0);
+        }
+
+        console.log(chalk.bold(`\nConfigured MCP Servers (${serverNames.length}):\n`));
+
+        serverNames.forEach(name => {
+            const config = servers[name];
+
+            console.log(chalk.bold(`  ${name}`));
+
+            // command가 있으면 stdio 타입으로 간주
+            if (config.command) {
+                console.log(chalk.gray(`    Type: ${config.type || 'stdio'}`));
+                console.log(chalk.gray(`    Command: ${config.command} ${config.args?.join(' ') || ''}`));
+                if (config.env && Object.keys(config.env).length > 0) {
+                    console.log(chalk.gray(`    Env vars: ${Object.keys(config.env).join(', ')}`));
+                }
+            } else {
+                // url이 있으면 http/sse 타입
+                console.log(chalk.gray(`    Type: ${config.type || 'http'}`));
+                console.log(chalk.gray(`    URL: ${config.url}`));
+                if (config.headers) {
+                    console.log(chalk.gray(`    Headers: ${Object.keys(config.headers).join(', ')}`));
+                }
+            }
+            console.log();
+        });
+
+        process.exit(0);
+
+    } catch (error) {
+        console.error(chalk.red(`\nError: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+/**
+ * 특정 MCP 서버 상세 정보 표시 명령어 핸들러
+ * 서버 이름으로 조회하여 전체 설정을 JSON 형식으로 출력
+ */
+export async function getMcpServer(name) {
+    try {
+        const servers = await loadMergedMcpConfig();
+        const server = servers[name];
+
+        if (!server) {
+            console.error(chalk.red(`\nServer '${name}' not found`));
+            console.error(chalk.gray('\nUse "aiexecode mcp list" to see all configured servers'));
+            process.exit(1);
+        }
+
+        console.log(chalk.bold(`\nMCP Server: ${name}`));
+        console.log(chalk.gray('─'.repeat(50)));
+
+        console.log(JSON.stringify(server, null, 2));
+
+        const configPath = getMcpConfigPath();
+        console.log(chalk.gray('\nConfiguration file:'));
+        console.log(chalk.gray(`  ${configPath}\n`));
+        process.exit(0);
+
+    } catch (error) {
+        console.error(chalk.red(`\nError: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+/**
+ * MCP 서버 제거 명령어 핸들러
+ * ~/.aiexe/mcp_config.json에서 지정된 서버 설정을 삭제
+ */
+export async function removeMcpServer(name) {
+    try {
+        // 서버 존재 여부 확인
+        const exists = await findServerScope(name);
+        if (!exists) {
+            console.error(chalk.red(`\nServer '${name}' not found`));
+            console.error(chalk.gray('\nUse "aiexecode mcp list" to see all configured servers'));
+            process.exit(1);
+        }
+
+        // 설정 파일에서 서버 제거
+        const result = await removeServerFromScope(name);
+
+        if (result.success) {
+            console.log(chalk.green(`\n✓ ${result.message}`));
+            process.exit(0);
+        } else {
+            console.error(chalk.red(`\n${result.message}`));
+            process.exit(1);
+        }
+
+    } catch (error) {
+        console.error(chalk.red(`\nError: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+/**
+ * JSON으로부터 MCP 서버 추가 명령어 핸들러
+ * 복잡한 설정을 JSON 문자열로 직접 전달받아 서버 추가
+ * CLI 옵션으로 표현하기 어려운 고급 설정에 유용
+ */
+export async function addMcpServerFromJson(name, jsonString) {
+    try {
+        // JSON 문자열을 파싱하여 서버 설정 객체 생성
+        const serverConfig = JSON.parse(jsonString);
+
+        // 기본 필수 필드 검증
+        if (!serverConfig.type) {
+            console.error(chalk.red('Error: JSON must include "type" field (stdio, http, or sse)'));
+            process.exit(1);
+        }
+
+        // 설정 저장
+        const configPath = await addServerToScope(name, serverConfig);
+
+        console.log(chalk.green(`\n✓ MCP server '${name}' added from JSON`));
+        console.log(chalk.gray(`  Config: ${configPath}\n`));
+        process.exit(0);
+
+    } catch (error) {
+        if (error instanceof SyntaxError) {
+            console.error(chalk.red('\nError: Invalid JSON'));
+            console.error(chalk.gray('Make sure to escape quotes properly in your shell'));
+            console.error(chalk.gray('\nExample:'));
+            console.error(chalk.cyan('  aiexecode mcp add-json weather \'{"type":"http","url":"https://api.example.com"}\''));
+        } else {
+            console.error(chalk.red(`\nError: ${error.message}`));
+        }
+        process.exit(1);
+    }
+}