intention-coding 0.3.7 → 0.4.0

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

@@ -0,0 +1,295 @@
+"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.PlanningStage = void 0;
+const logger_1 = require("../../../utils/logger");
+const openai_1 = require("../../../utils/openai");
+const types_1 = require("../types");
+/**
+ * 计划阶段处理器
+ * 职责：将选定方案细化为详尽、有序、可执行的步骤清单
+ */
+class PlanningStage {
+    /**
+     * 执行计划阶段
+     */
+    execute(task, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始执行计划阶段', { taskId: task.id });
+                // 获取选定的方案
+                const selectedSolution = this.getSelectedSolution(task, input);
+                // 生成执行计划
+                const executionPlan = yield this.generateExecutionPlan(task, selectedSolution);
+                // 生成响应
+                const response = this.generateResponse(executionPlan);
+                logger_1.logger.info('计划阶段执行完成', {
+                    taskId: task.id,
+                    stepCount: executionPlan.steps.length
+                });
+                return response;
+            }
+            catch (error) {
+                logger_1.logger.error('计划阶段执行失败', { error, taskId: task.id });
+                throw new types_1.CodeGeneratorError('执行计划生成失败，请检查选定的方案', types_1.ErrorCodes.PLAN_CREATION_FAILED, types_1.WorkflowStage.PLANNING, { taskId: task.id, originalError: error });
+            }
+        });
+    }
+    /**
+     * 获取选定的方案
+     */
+    getSelectedSolution(task, input) {
+        var _a;
+        // 从之前的构思阶段获取方案
+        const ideationStage = task.stages.find(s => s.stage === types_1.WorkflowStage.IDEATION);
+        if (!((_a = ideationStage === null || ideationStage === void 0 ? void 0 : ideationStage.output) === null || _a === void 0 ? void 0 : _a.solutions)) {
+            throw new Error('未找到可用的解决方案');
+        }
+        const solutions = ideationStage.output.solutions;
+        // 如果用户指定了方案ID，使用指定的方案
+        if (input === null || input === void 0 ? void 0 : input.solutionId) {
+            const selected = solutions.find((s) => s.id === input.solutionId);
+            if (!selected) {
+                throw new Error(`未找到指定的方案: ${input.solutionId}`);
+            }
+            return selected;
+        }
+        // 否则使用评分最高的方案
+        return solutions[0];
+    }
+    /**
+     * 生成执行计划
+     */
+    generateExecutionPlan(task, solution) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { taskDescription, projectInfo } = task.context;
+            const prompt = `你是一位资深的项目经理，请为以下解决方案制定详细的执行计划。
+
+## 任务描述
+${taskDescription}
+
+## 选定方案
+**方案名称**: ${solution.name}
+**方案描述**: ${solution.description}
+**技术要求**: ${solution.techRequirements.join(', ')}
+**复杂度**: ${solution.complexity}
+**预估时间**: ${solution.estimatedTime}
+
+## 项目信息
+${projectInfo ? `
+- 技术栈：${projectInfo.techStack.join(', ')}
+- 框架：${projectInfo.frameworks.join(', ')}
+- 语言：${projectInfo.language}
+` : '- 通用项目'}
+
+请将方案分解为原子的、可执行的步骤，每个步骤应该包含：
+1. 明确的步骤名称和描述
+2. 具体的目标文件和操作
+3. 原子操作列表（文件创建、函数实现等）
+4. 预期结果
+5. 依赖关系
+6. 时间估算
+
+重要：生成的步骤将被转换为 MCP 客户端可执行的指令，请确保：
+- 文件路径准确且相对于项目根目录
+- 内容具体可执行，避免抽象描述
+- 依赖关系清晰，便于按序执行
+
+请以JSON格式返回：
+{
+  "id": "plan_id",
+  "solutionId": "${solution.id}",
+  "estimatedDuration": "总体时间估算",
+  "dependencies": ["依赖1", "依赖2"],
+  "riskAssessment": "风险评估",
+  "rollbackPlan": "回滚计划",
+  "steps": [
+    {
+      "id": "step_1",
+      "name": "步骤名称",
+      "description": "详细描述",
+      "type": "file_creation|file_modification|function_implementation|class_implementation|test_creation|configuration",
+      "targetFiles": ["文件路径1", "文件路径2"],
+      "atomicOperations": [
+        {
+          "type": "create_file|modify_file|create_function|create_class|add_import|install_dependency",
+          "target": "目标文件或函数名",
+          "content": "具体的文件内容或代码",
+          "parameters": {"key": "value"}
+        }
+      ],
+      "expectedResult": "预期结果",
+      "dependencies": ["依赖步骤ID"],
+      "estimatedTime": "时间估算"
+    }
+  ]
+}`;
+            try {
+                const result = yield openai_1.openAIService.generateText({
+                    prompt,
+                    system_prompt: "你是专业的项目经理，请严格按照JSON格式返回执行计划。"
+                });
+                const jsonMatch = result.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    try {
+                        const plan = JSON.parse(jsonMatch[0]);
+                        return Object.assign(Object.assign({}, plan), { id: plan.id || `plan_${Date.now()}`, solutionId: solution.id });
+                    }
+                    catch (parseError) {
+                        logger_1.logger.error('JSON解析失败', {
+                            error: parseError,
+                            jsonString: jsonMatch[0].substring(0, 200) + '...'
+                        });
+                        throw new Error('AI返回的JSON格式无效');
+                    }
+                }
+                throw new Error('无法从AI响应中提取JSON');
+            }
+            catch (error) {
+                logger_1.logger.error('执行计划生成失败', { error });
+                // 返回默认计划
+                return this.getDefaultExecutionPlan(solution, task);
+            }
+        });
+    }
+    /**
+     * 生成响应
+     */
+    generateResponse(executionPlan) {
+        return {
+            stage: types_1.WorkflowStage.PLANNING,
+            status: 'pending_approval',
+            message: this.formatPlanMessage(executionPlan),
+            data: { executionPlan },
+            nextActions: ['批准计划开始执行', '修改计划', '重新规划'],
+            requiresUserConfirmation: true
+        };
+    }
+    /**
+     * 格式化计划消息
+     */
+    formatPlanMessage(plan) {
+        const stepsText = plan.steps.map((step, index) => `
+### 步骤 ${index + 1}：${step.name}
+
+**描述**：${step.description}
+**类型**：${this.getStepTypeLabel(step.type)}
+**目标文件**：${step.targetFiles.join(', ')}
+**预期结果**：${step.expectedResult}
+**预估时间**：${step.estimatedTime}
+**依赖**：${step.dependencies.length > 0 ? step.dependencies.join(', ') : '无'}
+
+**原子操作**：
+${step.atomicOperations.map(op => `- ${this.getOperationLabel(op.type)}: ${op.target}`).join('\n')}
+    `).join('\n---\n');
+        return `
+# [模式：计划] 执行计划制定完成 📋
+
+## 📊 计划概览
+
+**方案ID**：${plan.solutionId}
+**总体时间**：${plan.estimatedDuration}
+**步骤数量**：${plan.steps.length}个
+
+## 🔍 风险评估
+
+${plan.riskAssessment}
+
+## 📝 详细步骤
+
+${stepsText}
+
+## 🔄 回滚计划
+
+${plan.rollbackPlan}
+
+## ⚠️ 重要提醒
+
+- 执行前将在项目根目录 \`.claude/plan/\` 中保存计划文档
+- 关键步骤完成后会请求您的反馈
+- 如需修改计划，请在批准前提出
+
+**请确认是否批准此执行计划？批准后将开始代码实施阶段。**
+    `.trim();
+    }
+    /**
+     * 获取默认执行计划
+     */
+    getDefaultExecutionPlan(solution, task) {
+        return {
+            id: `plan_${Date.now()}`,
+            solutionId: solution.id,
+            estimatedDuration: solution.estimatedTime,
+            dependencies: solution.techRequirements,
+            riskAssessment: `基于${solution.complexity}复杂度和${solution.riskLevel}风险等级的标准评估`,
+            rollbackPlan: '如遇问题，可回滚到当前代码状态，删除新增文件',
+            steps: [
+                {
+                    id: 'step_1',
+                    name: '环境准备',
+                    description: '检查和准备开发环境',
+                    type: 'configuration',
+                    targetFiles: ['package.json', 'tsconfig.json'],
+                    atomicOperations: [
+                        {
+                            type: 'install_dependency',
+                            target: 'dependencies',
+                            content: solution.techRequirements.join(', ')
+                        }
+                    ],
+                    expectedResult: '开发环境就绪',
+                    dependencies: [],
+                    estimatedTime: '30分钟'
+                },
+                {
+                    id: 'step_2',
+                    name: '核心功能实现',
+                    description: solution.description,
+                    type: 'function_implementation',
+                    targetFiles: ['src/main.ts'],
+                    atomicOperations: [
+                        {
+                            type: 'create_function',
+                            target: 'main function',
+                            content: '核心业务逻辑'
+                        }
+                    ],
+                    expectedResult: '核心功能完成',
+                    dependencies: ['step_1'],
+                    estimatedTime: '2-3小时'
+                }
+            ]
+        };
+    }
+    getStepTypeLabel(type) {
+        const labels = {
+            'file_creation': '📄 文件创建',
+            'file_modification': '✏️ 文件修改',
+            'function_implementation': '⚡ 函数实现',
+            'class_implementation': '🏗️ 类实现',
+            'test_creation': '🧪 测试创建',
+            'configuration': '⚙️ 配置设置'
+        };
+        return labels[type] || type;
+    }
+    getOperationLabel(type) {
+        const labels = {
+            'create_file': '创建文件',
+            'modify_file': '修改文件',
+            'create_function': '创建函数',
+            'create_class': '创建类',
+            'add_import': '添加导入',
+            'install_dependency': '安装依赖'
+        };
+        return labels[type] || type;
+    }
+}
+exports.PlanningStage = PlanningStage;

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

@@ -0,0 +1,283 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.ResearchStage = void 0;
+const logger_1 = require("../../../utils/logger");
+const openai_1 = require("../../../utils/openai");
+const pack_1 = require("../../../utils/pack");
+const types_1 = require("../types");
+/**
+ * 研究阶段处理器
+ * 职责：理解需求并评估完整性，收集项目上下文
+ */
+class ResearchStage {
+    /**
+     * 执行研究阶段
+     */
+    execute(task, _input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始执行研究阶段', { taskId: task.id });
+                // 1. 分析项目信息
+                const projectInfo = yield this.analyzeProject();
+                task.context.projectInfo = projectInfo;
+                // 2. 分析需求完整性
+                const requirements = yield this.analyzeRequirements(task.description, projectInfo);
+                task.context.requirements = requirements;
+                // 3. 生成响应
+                const response = this.generateResponse(requirements, projectInfo);
+                logger_1.logger.info('研究阶段执行完成', {
+                    taskId: task.id,
+                    completenessScore: requirements.completenessScore,
+                    needsClarification: requirements.completenessScore < 7
+                });
+                return response;
+            }
+            catch (error) {
+                logger_1.logger.error('研究阶段执行失败', { error, taskId: task.id });
+                throw new types_1.CodeGeneratorError('需求分析过程中发生错误，请检查任务描述', types_1.ErrorCodes.INCOMPLETE_REQUIREMENTS, types_1.WorkflowStage.RESEARCH, { taskId: task.id, originalError: error });
+            }
+        });
+    }
+    /**
+     * 分析项目信息
+     */
+    analyzeProject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始分析项目信息');
+                const projectAnalysisPath = yield (0, pack_1.packProject)();
+                const fs = yield Promise.resolve().then(() => __importStar(require('fs/promises')));
+                const projectAnalysisContent = yield fs.readFile(projectAnalysisPath, 'utf8');
+                // 解析项目信息
+                const projectInfo = this.parseProjectInfo(projectAnalysisContent);
+                logger_1.logger.info('项目信息分析完成', { projectInfo });
+                return projectInfo;
+            }
+            catch (error) {
+                logger_1.logger.warn('项目信息分析失败，使用默认配置', { error });
+                return undefined;
+            }
+        });
+    }
+    /**
+     * 解析项目信息
+     */
+    parseProjectInfo(content) {
+        // 提取技术栈
+        const techStackMatch = content.match(/技术栈[：:]\s*([^\n]+)/);
+        const techStack = techStackMatch ? techStackMatch[1].split(/[,，、]/).map(s => s.trim()) : [];
+        // 提取框架
+        const frameworkMatch = content.match(/框架[：:]\s*([^\n]+)/);
+        const frameworks = frameworkMatch ? frameworkMatch[1].split(/[,，、]/).map(s => s.trim()) : [];
+        // 提取编程语言
+        const languageMatch = content.match(/语言[：:]\s*([^\n]+)/);
+        const language = languageMatch ? languageMatch[1].trim() : '';
+        return {
+            name: 'current-project',
+            path: process.cwd(),
+            techStack,
+            frameworks,
+            language,
+            structure: {},
+            devCommands: []
+        };
+    }
+    /**
+     * 分析需求完整性
+     */
+    analyzeRequirements(taskDescription, projectInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const prompt = `你是一位专业的需求分析师，请分析以下任务描述的完整性。
+
+任务描述：${taskDescription}
+
+${projectInfo ? `项目信息：
+- 技术栈：${projectInfo.techStack.join(', ')}
+- 框架：${projectInfo.frameworks.join(', ')}
+- 语言：${projectInfo.language}` : ''}
+
+请按照以下维度评分（总分10分）：
+1. 目标明确性（0-3分）：任务目标是否清晰具体，要解决什么问题
+2. 预期结果（0-3分）：成功标准和交付物是否明确定义
+3. 边界范围（0-2分）：任务范围和边界是否清楚
+4. 约束条件（0-2分）：时间、性能、业务限制等是否说明
+
+请以JSON格式返回分析结果：
+{
+  "targetClarity": 数字,
+  "expectedResults": 数字,
+  "scopeBoundary": 数字,
+  "constraints": 数字,
+  "completenessScore": 总分,
+  "missingInfo": ["缺失信息1", "缺失信息2"],
+  "clarificationQuestions": ["问题1", "问题2"]
+}`;
+            try {
+                const result = yield openai_1.openAIService.generateText({
+                    prompt,
+                    system_prompt: "你是专业的需求分析师，请严格按照JSON格式返回分析结果。"
+                });
+                const jsonMatch = result.match(/\{[\s\S]*\}/);
+                if (jsonMatch) {
+                    const analysis = JSON.parse(jsonMatch[0]);
+                    return {
+                        completenessScore: analysis.completenessScore,
+                        targetClarity: analysis.targetClarity,
+                        expectedResults: analysis.expectedResults,
+                        scopeBoundary: analysis.scopeBoundary,
+                        constraints: analysis.constraints,
+                        missingInfo: analysis.missingInfo || [],
+                        clarificationQuestions: analysis.clarificationQuestions || []
+                    };
+                }
+                throw new Error('无法解析AI分析结果');
+            }
+            catch (error) {
+                logger_1.logger.error('需求分析失败', { error });
+                // 返回默认的低分分析
+                return {
+                    completenessScore: 3,
+                    targetClarity: 1,
+                    expectedResults: 1,
+                    scopeBoundary: 1,
+                    constraints: 0,
+                    missingInfo: ['任务目标不够明确', '缺少成功标准', '范围边界不清晰'],
+                    clarificationQuestions: [
+                        '请详细描述您要实现的具体功能或解决的问题？',
+                        '期望的最终结果是什么？如何判断任务成功完成？',
+                        '有什么时间、性能或业务限制需要考虑？'
+                    ]
+                };
+            }
+        });
+    }
+    /**
+     * 生成响应
+     */
+    generateResponse(requirements, projectInfo) {
+        const { completenessScore, clarificationQuestions } = requirements;
+        if (completenessScore < 7) {
+            // 需要补充信息
+            return {
+                stage: types_1.WorkflowStage.RESEARCH,
+                status: 'needs_clarification',
+                message: this.formatClarificationMessage(requirements),
+                data: { requirements, projectInfo },
+                nextActions: ['补充需求信息', '重新评估需求'],
+                requiresUserConfirmation: true,
+                clarificationQuestions
+            };
+        }
+        else {
+            // 需求完整，可以继续
+            return {
+                stage: types_1.WorkflowStage.RESEARCH,
+                status: 'success',
+                message: this.formatSuccessMessage(requirements, projectInfo),
+                data: { requirements, projectInfo },
+                nextActions: ['进入构思阶段', '重新分析需求'],
+                requiresUserConfirmation: true
+            };
+        }
+    }
+    /**
+     * 格式化需要澄清的消息
+     */
+    formatClarificationMessage(requirements) {
+        return `
+# [模式：研究] 需求分析结果
+
+## 📊 需求完整性评分：${requirements.completenessScore}/10
+
+### 评分详情：
+- **目标明确性**：${requirements.targetClarity}/3分
+- **预期结果**：${requirements.expectedResults}/3分  
+- **边界范围**：${requirements.scopeBoundary}/2分
+- **约束条件**：${requirements.constraints}/2分
+
+## ⚠️ 需要补充信息
+
+评分低于7分，需要补充关键信息才能继续：
+
+### 缺失信息：
+${requirements.missingInfo.map(info => `- ${info}`).join('\n')}
+
+### 需要澄清的问题：
+${requirements.clarificationQuestions.map((q, i) => `${i + 1}. ${q}`).join('\n')}
+
+**请补充上述信息后，我将重新评估需求完整性。**
+    `.trim();
+    }
+    /**
+     * 格式化成功消息
+     */
+    formatSuccessMessage(requirements, projectInfo) {
+        return `
+# [模式：研究] 需求分析完成 ✅
+
+## 📊 需求完整性评分：${requirements.completenessScore}/10
+
+### 评分详情：
+- **目标明确性**：${requirements.targetClarity}/3分
+- **预期结果**：${requirements.expectedResults}/3分
+- **边界范围**：${requirements.scopeBoundary}/2分
+- **约束条件**：${requirements.constraints}/2分
+
+## 🏗️ 项目信息：
+${projectInfo ? `
+- **技术栈**：${projectInfo.techStack.join(', ') || '待确定'}
+- **框架**：${projectInfo.frameworks.join(', ') || '待确定'}
+- **语言**：${projectInfo.language || '待确定'}
+` : '- 项目信息获取中...'}
+
+## ✅ 需求分析通过
+
+需求完整性评分达到${requirements.completenessScore}分，可以进入下一阶段。
+
+**准备进入构思阶段，生成解决方案...**
+    `.trim();
+    }
+}
+exports.ResearchStage = ResearchStage;