intention-coding 0.3.7 → 0.4.0

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

@@ -0,0 +1,549 @@
+"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;