intention-coding 0.3.8 → 0.4.1

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

@@ -1,295 +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.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

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