intention-coding 0.4.0 → 0.4.3

package/dist/services/code-generator/stages/execution-stage.js

@@ -1,549 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExecutionStage = void 0;
-const logger_1 = require("../../../utils/logger");
-const types_1 = require("../types");
-/**
- * 执行阶段处理器
- * 职责：根据批准的计划实施代码开发
- */
-class ExecutionStage {
-    /**
-     * 执行实施阶段
-     */
-    execute(task, _input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                logger_1.logger.info("开始执行实施阶段", { taskId: task.id });
-                // 检查用户批准
-                if (!(_input === null || _input === void 0 ? void 0 : _input.approval)) {
-                    return {
-                        stage: types_1.WorkflowStage.EXECUTION,
-                        status: "pending_approval",
-                        message: "⚠️ 需要用户批准才能开始执行代码实施。\n\n请确认批准执行计划？",
-                        data: {},
-                        nextActions: ["批准执行", "修改计划", "返回计划阶段"],
-                        requiresUserConfirmation: true,
-                    };
-                }
-                // 获取执行计划
-                const executionPlan = this.getExecutionPlan(task);
-                // 生成执行指令
-                const executionInstructions = yield this.generateExecutionInstructions(executionPlan);
-                // 生成响应
-                const response = this.generateResponse(executionInstructions);
-                logger_1.logger.info("实施阶段执行完成", {
-                    taskId: task.id,
-                    instructionCount: executionInstructions.length,
-                });
-                return response;
-            }
-            catch (error) {
-                logger_1.logger.error("实施阶段执行失败", { error, taskId: task.id });
-                throw new types_1.CodeGeneratorError("代码实施过程中发生错误，请检查执行环境", types_1.ErrorCodes.EXECUTION_FAILED, types_1.WorkflowStage.EXECUTION, { taskId: task.id, originalError: error });
-            }
-        });
-    }
-    /**
-     * 获取执行计划
-     */
-    getExecutionPlan(task) {
-        var _a;
-        const planningStage = task.stages.find((s) => s.stage === types_1.WorkflowStage.PLANNING);
-        if (!((_a = planningStage === null || planningStage === void 0 ? void 0 : planningStage.output) === null || _a === void 0 ? void 0 : _a.executionPlan)) {
-            throw new Error("未找到执行计划");
-        }
-        return planningStage.output.executionPlan;
-    }
-    /**
-     * 生成执行指令
-     */
-    generateExecutionInstructions(executionPlan) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            let priority = 1;
-            // 首先添加计划文档保存指令
-            instructions.push(this.createPlanDocumentInstruction(executionPlan, priority++));
-            // 为每个步骤生成对应的执行指令
-            for (const step of executionPlan.steps) {
-                const stepInstructions = yield this.generateStepInstructions(step, priority);
-                instructions.push(...stepInstructions);
-                priority += stepInstructions.length;
-            }
-            return instructions;
-        });
-    }
-    /**
-     * 创建计划文档保存指令
-     */
-    createPlanDocumentInstruction(executionPlan, priority) {
-        const planContent = this.generatePlanDocument(executionPlan);
-        const fileName = this.sanitizeFileName(executionPlan.solutionId || "execution-plan");
-        return {
-            id: `save_plan_${Date.now()}`,
-            type: "file_operation",
-            operation: "create",
-            targetPath: `.claude/plan/${fileName}.md`,
-            content: planContent,
-            description: "保存执行计划文档",
-            priority,
-        };
-    }
-    /**
-     * 为单个步骤生成执行指令
-     */
-    generateStepInstructions(step, startPriority) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const instructions = [];
-            let priority = startPriority;
-            switch (step.type) {
-                case "file_creation":
-                    instructions.push(...this.generateFileCreationInstructions(step, priority));
-                    break;
-                case "file_modification":
-                    instructions.push(...this.generateFileModificationInstructions(step, priority));
-                    break;
-                case "function_implementation":
-                    instructions.push(...this.generateFunctionImplementationInstructions(step, priority));
-                    break;
-                case "class_implementation":
-                    instructions.push(...this.generateClassImplementationInstructions(step, priority));
-                    break;
-                case "test_creation":
-                    instructions.push(...this.generateTestCreationInstructions(step, priority));
-                    break;
-                case "configuration":
-                    instructions.push(...this.generateConfigurationInstructions(step, priority));
-                    break;
-                default:
-                    logger_1.logger.warn(`不支持的步骤类型: ${step.type}`);
-            }
-            return instructions;
-        });
-    }
-    /**
-     * 生成文件创建指令
-     */
-    generateFileCreationInstructions(step, priority) {
-        const instructions = [];
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            // 从原子操作中获取文件内容
-            const createOperation = step.atomicOperations.find((op) => op.type === "create_file" && op.target.includes(targetFile));
-            instructions.push({
-                id: `create_file_${step.id}_${index}`,
-                type: "file_operation",
-                operation: "create",
-                targetPath: targetFile,
-                content: (createOperation === null || createOperation === void 0 ? void 0 : createOperation.content) ||
-                    this.generateDefaultFileContent(targetFile),
-                description: `创建文件: ${targetFile}`,
-                priority: priority + index,
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 生成文件修改指令
-     */
-    generateFileModificationInstructions(step, priority) {
-        const instructions = [];
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            const modifyOperation = step.atomicOperations.find((op) => op.type === "modify_file" && op.target.includes(targetFile));
-            instructions.push({
-                id: `modify_file_${step.id}_${index}`,
-                type: "file_operation",
-                operation: "modify",
-                targetPath: targetFile,
-                newContent: (modifyOperation === null || modifyOperation === void 0 ? void 0 : modifyOperation.content) || `// ${step.description}`,
-                description: `修改文件: ${targetFile}`,
-                priority: priority + index,
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 生成函数实现指令
-     */
-    generateFunctionImplementationInstructions(step, priority) {
-        const instructions = [];
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            const functionOperation = step.atomicOperations.find((op) => op.type === "create_function");
-            const functionContent = this.generateFunctionContent(functionOperation, step);
-            instructions.push({
-                id: `implement_function_${step.id}_${index}`,
-                type: "file_operation",
-                operation: targetFile.includes("new") ? "create" : "modify",
-                targetPath: targetFile,
-                content: functionContent,
-                description: `实现函数: ${step.name}`,
-                priority: priority + index,
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 生成类实现指令
-     */
-    generateClassImplementationInstructions(step, priority) {
-        const instructions = [];
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            const classOperation = step.atomicOperations.find((op) => op.type === "create_class");
-            const classContent = this.generateClassContent(classOperation, step);
-            instructions.push({
-                id: `implement_class_${step.id}_${index}`,
-                type: "file_operation",
-                operation: targetFile.includes("new") ? "create" : "modify",
-                targetPath: targetFile,
-                content: classContent,
-                description: `实现类: ${step.name}`,
-                priority: priority + index,
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 生成测试创建指令
-     */
-    generateTestCreationInstructions(step, priority) {
-        const instructions = [];
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            const testContent = this.generateTestContent(step);
-            instructions.push({
-                id: `create_test_${step.id}_${index}`,
-                type: "file_operation",
-                operation: "create",
-                targetPath: targetFile,
-                content: testContent,
-                description: `创建测试文件: ${targetFile}`,
-                priority: priority + index,
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 生成配置指令
-     */
-    generateConfigurationInstructions(step, priority) {
-        const instructions = [];
-        // 检查是否有依赖安装需求
-        const dependencyOperation = step.atomicOperations.find((op) => op.type === "install_dependency");
-        if (dependencyOperation) {
-            instructions.push({
-                id: `install_deps_${step.id}`,
-                type: "dependency_install",
-                packageManager: "npm", // 可以根据项目类型动态确定
-                packages: dependencyOperation.content.split(", "),
-                isDev: false,
-                description: `安装依赖: ${dependencyOperation.content}`,
-                priority: priority,
-            });
-        }
-        // 处理配置文件修改
-        for (const [index, targetFile] of step.targetFiles.entries()) {
-            if (targetFile.endsWith(".json")) {
-                instructions.push({
-                    id: `config_${step.id}_${index}`,
-                    type: "configuration",
-                    configType: this.getConfigType(targetFile),
-                    configPath: targetFile,
-                    changes: this.extractConfigChanges(step),
-                    description: `配置文件: ${targetFile}`,
-                    priority: priority + index + 1,
-                });
-            }
-        }
-        return instructions;
-    }
-    /**
-     * 生成响应 - MCP 架构版本
-     */
-    generateResponse(executionInstructions) {
-        return {
-            stage: types_1.WorkflowStage.EXECUTION,
-            status: "success",
-            message: this.formatExecutionMessage(executionInstructions),
-            data: {
-                instructionCount: executionInstructions.length,
-                executionInstructions: executionInstructions, // MCP 客户端将执行这些指令
-                mcpMode: true, // 标识为 MCP 模式
-            },
-            nextActions: [
-                "等待 MCP 客户端执行指令",
-                "查看指令详情",
-                "修改指令",
-                "跳过执行",
-            ],
-            requiresUserConfirmation: false,
-            executionInstructions: executionInstructions, // 直接提供给 MCP 客户端
-        };
-    }
-    /**
-     * 生成默认文件内容
-     */
-    generateDefaultFileContent(filePath) {
-        var _a, _b;
-        const ext = (_a = filePath.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
-        switch (ext) {
-            case "ts":
-            case "js":
-                return `// ${filePath}\n// 自动生成的文件\n\nexport {};\n`;
-            case "json":
-                return "{\n  \n}\n";
-            case "md":
-                return `# ${(_b = filePath.split("/").pop()) === null || _b === void 0 ? void 0 : _b.replace(".md", "")}\n\n`;
-            case "css":
-                return `/* ${filePath} */\n\n`;
-            case "html":
-                return `<!DOCTYPE html>\n<html>\n<head>\n  <title>${filePath}</title>\n</head>\n<body>\n  \n</body>\n</html>\n`;
-            default:
-                return `// ${filePath}\n`;
-        }
-    }
-    /**
-     * 生成函数内容
-     */
-    generateFunctionContent(operation, step) {
-        const functionName = (operation === null || operation === void 0 ? void 0 : operation.target) || "newFunction";
-        const description = step.description || "新函数";
-        return `
-/**
- * ${description}
- */
-export function ${functionName}() {
-  // TODO: 实现 ${description}
-  throw new Error('Function not implemented');
-}
-`.trim();
-    }
-    /**
-     * 生成类内容
-     */
-    generateClassContent(operation, step) {
-        const className = (operation === null || operation === void 0 ? void 0 : operation.target) || "NewClass";
-        const description = step.description || "新类";
-        return `
-/**
- * ${description}
- */
-export class ${className} {
-  constructor() {
-    // TODO: 实现构造函数
-  }
-
-  // TODO: 添加类方法
-}
-`.trim();
-    }
-    /**
-     * 生成测试内容
-     */
-    generateTestContent(step) {
-        const testName = step.name || "test";
-        return `
-import { describe, it, expect } from 'vitest';
-
-describe('${testName}', () => {
-  it('should work correctly', () => {
-    // TODO: 实现测试用例
-    expect(true).toBe(true);
-  });
-});
-`.trim();
-    }
-    /**
-     * 获取配置文件类型
-     */
-    getConfigType(filePath) {
-        if (filePath.includes("package.json"))
-            return "package.json";
-        if (filePath.includes("tsconfig.json"))
-            return "tsconfig.json";
-        if (filePath.includes("eslint"))
-            return "eslint";
-        if (filePath.includes("prettier"))
-            return "prettier";
-        return "custom";
-    }
-    /**
-     * 提取配置变更
-     */
-    extractConfigChanges(step) {
-        // 从步骤的原子操作中提取配置变更
-        const changes = {};
-        for (const operation of step.atomicOperations) {
-            if (operation.parameters) {
-                Object.assign(changes, operation.parameters);
-            }
-        }
-        return changes;
-    }
-    /**
-     * 格式化执行消息
-     */
-    formatExecutionMessage(instructions) {
-        const fileOps = instructions.filter((i) => i.type === "file_operation");
-        const shellCmds = instructions.filter((i) => i.type === "shell_command");
-        const depInstalls = instructions.filter((i) => i.type === "dependency_install");
-        const configs = instructions.filter((i) => i.type === "configuration");
-        return `
-# [模式：执行] 执行指令已生成 🚀
-
-## 📊 指令统计
-
-- **总指令数**: ${instructions.length}
-- **文件操作**: ${fileOps.length}个
-- **Shell命令**: ${shellCmds.length}个
-- **依赖安装**: ${depInstalls.length}个
-- **配置修改**: ${configs.length}个
-
-## 📋 执行指令概览
-
-${this.formatInstructionsByType(instructions)}
-
-## 🎯 执行说明
-
-这些指令将由 MCP 客户端按优先级顺序执行：
-
-1. **文件操作** - 创建、修改项目文件
-2. **依赖安装** - 安装必要的包和库
-3. **配置修改** - 更新配置文件
-4. **Shell命令** - 执行构建和测试命令
-
-## ⚡ MCP 客户端执行
-
-这些指令将由 MCP 客户端自动执行：
-
-1. **指令验证** - 客户端验证指令有效性
-2. **环境检查** - 确认执行环境就绪
-3. **按序执行** - 根据优先级顺序执行指令
-4. **结果报告** - 向服务器报告执行结果
-5. **错误处理** - 处理执行失败的指令
-
-**🔄 MCP 执行流程已启动，等待客户端处理...**
-    `.trim();
-    }
-    /**
-     * 按类型格式化指令
-     */
-    formatInstructionsByType(instructions) {
-        const sections = [];
-        // 文件操作
-        const fileOps = instructions.filter((i) => i.type === "file_operation");
-        if (fileOps.length > 0) {
-            sections.push(`
-### 📄 文件操作 (${fileOps.length}个)
-
-${fileOps
-                .map((inst, index) => `${index + 1}. **${inst.operation.toUpperCase()}** \`${inst.targetPath}\` - ${inst.description}`)
-                .join("\n")}
-      `.trim());
-        }
-        // 依赖安装
-        const depInstalls = instructions.filter((i) => i.type === "dependency_install");
-        if (depInstalls.length > 0) {
-            sections.push(`
-### 📦 依赖安装 (${depInstalls.length}个)
-
-${depInstalls
-                .map((inst, index) => `${index + 1}. **${inst.packageManager}** install ${inst.packages.join(" ")} - ${inst.description}`)
-                .join("\n")}
-      `.trim());
-        }
-        // 配置修改
-        const configs = instructions.filter((i) => i.type === "configuration");
-        if (configs.length > 0) {
-            sections.push(`
-### ⚙️ 配置修改 (${configs.length}个)
-
-${configs
-                .map((inst, index) => `${index + 1}. **${inst.configType}** \`${inst.configPath}\` - ${inst.description}`)
-                .join("\n")}
-      `.trim());
-        }
-        // Shell命令
-        const shellCmds = instructions.filter((i) => i.type === "shell_command");
-        if (shellCmds.length > 0) {
-            sections.push(`
-### 💻 Shell命令 (${shellCmds.length}个)
-
-${shellCmds
-                .map((inst, index) => `${index + 1}. \`${inst.command}\` - ${inst.description}`)
-                .join("\n")}
-      `.trim());
-        }
-        return sections.join("\n\n");
-    }
-    /**
-     * 生成计划文档
-     */
-    generatePlanDocument(executionPlan) {
-        return `
-# 执行计划文档
-
-## 方案信息
-
-- **方案ID**: ${executionPlan.solutionId}
-- **预估时间**: ${executionPlan.estimatedDuration}
-- **生成时间**: ${new Date().toISOString()}
-
-## 执行步骤
-
-${executionPlan.steps
-            .map((step, index) => `
-### ${index + 1}. ${step.name}
-
-- **类型**: ${step.type}
-- **描述**: ${step.description}
-- **目标文件**: ${step.targetFiles.join(", ")}
-- **预期结果**: ${step.expectedResult}
-- **预估时间**: ${step.estimatedTime}
-- **依赖**: ${step.dependencies.join(", ") || "无"}
-
-#### 原子操作
-${step.atomicOperations
-            .map((op) => `- ${op.type}: ${op.target}`)
-            .join("\n")}
-`)
-            .join("\n")}
-
-## 风险评估
-
-${executionPlan.riskAssessment}
-
-## 回滚计划
-
-${executionPlan.rollbackPlan}
-
-## 执行说明
-
-此计划将通过 MCP 客户端自动执行，包括：
-1. 文件创建和修改
-2. 依赖包安装
-3. 配置文件更新
-4. 必要的构建命令
-
----
-*此文档由代码生成智能体自动生成*
-    `.trim();
-    }
-    /**
-     * 清理文件名
-     */
-    sanitizeFileName(name) {
-        return name
-            .replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, "_")
-            .replace(/_+/g, "_")
-            .replace(/^_|_$/g, "")
-            .substring(0, 50);
-    }
-}
-exports.ExecutionStage = ExecutionStage;