intention-coding 0.3.8 → 0.4.1

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

@@ -1,267 +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.IdeationStage = void 0;
-const logger_1 = require("../../../utils/logger");
-const openai_1 = require("../../../utils/openai");
-const types_1 = require("../types");
-/**
- * 构思阶段处理器
- * 职责：生成多个可行的解决方案并进行评估
- */
-class IdeationStage {
-    /**
-     * 执行构思阶段
-     */
-    execute(task, _input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                logger_1.logger.info('开始执行构思阶段', { taskId: task.id });
-                // 生成解决方案
-                const solutions = yield this.generateSolutions(task);
-                // 评估和排序方案
-                const evaluatedSolutions = yield this.evaluateSolutions(solutions, task);
-                // 生成响应
-                const response = this.generateResponse(evaluatedSolutions);
-                logger_1.logger.info('构思阶段执行完成', {
-                    taskId: task.id,
-                    solutionCount: evaluatedSolutions.length
-                });
-                return response;
-            }
-            catch (error) {
-                logger_1.logger.error('构思阶段执行失败', { error, taskId: task.id });
-                throw new types_1.CodeGeneratorError('方案生成过程中发生错误，请重试', types_1.ErrorCodes.SOLUTION_GENERATION_FAILED, types_1.WorkflowStage.IDEATION, { taskId: task.id, originalError: error });
-            }
-        });
-    }
-    /**
-     * 生成解决方案
-     */
-    generateSolutions(task) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { taskDescription, projectInfo, requirements } = task.context;
-            const prompt = `你是一位资深的软件架构师，请为以下任务生成多个可行的解决方案。
-
-## 任务描述
-${taskDescription}
-
-## 项目信息
-${projectInfo ? `
-- 技术栈：${projectInfo.techStack.join(', ')}
-- 框架：${projectInfo.frameworks.join(', ')}
-- 语言：${projectInfo.language}
-` : '- 通用项目'}
-
-## 需求分析
-- 完整性评分：${requirements.completenessScore}/10
-- 目标明确性：${requirements.targetClarity}/3
-- 预期结果：${requirements.expectedResults}/3
-
-请生成至少2-3个不同的解决方案，每个方案应该：
-1. 有明确的名称和描述
-2. 列出优缺点
-3. 评估复杂度和风险
-4. 估算开发时间
-5. 说明技术要求
-
-请以JSON格式返回：
-{
-  "solutions": [
-    {
-      "id": "solution_1",
-      "name": "方案名称",
-      "description": "详细描述",
-      "pros": ["优点1", "优点2"],
-      "cons": ["缺点1", "缺点2"],
-      "complexity": "low|medium|high",
-      "estimatedTime": "时间估算",
-      "techRequirements": ["技术要求1", "技术要求2"],
-      "riskLevel": "low|medium|high"
-    }
-  ]
-}`;
-            try {
-                const result = yield openai_1.openAIService.generateText({
-                    prompt,
-                    system_prompt: "你是专业的软件架构师，请严格按照JSON格式返回解决方案。"
-                });
-                const jsonMatch = result.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    const data = JSON.parse(jsonMatch[0]);
-                    return data.solutions.map((sol, index) => (Object.assign(Object.assign({}, sol), { id: sol.id || `solution_${index + 1}`, score: 0 // 初始评分，后续计算
-                     })));
-                }
-                throw new Error('无法解析AI生成的解决方案');
-            }
-            catch (error) {
-                logger_1.logger.error('解决方案生成失败', { error });
-                // 返回默认方案
-                return this.getDefaultSolutions(task);
-            }
-        });
-    }
-    /**
-     * 评估解决方案
-     */
-    evaluateSolutions(solutions, task) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const evaluatedSolutions = solutions.map(solution => {
-                // 计算综合评分
-                let score = 0;
-                // 复杂度评分 (复杂度越低分数越高)
-                switch (solution.complexity) {
-                    case 'low':
-                        score += 30;
-                        break;
-                    case 'medium':
-                        score += 20;
-                        break;
-                    case 'high':
-                        score += 10;
-                        break;
-                }
-                // 风险评分 (风险越低分数越高)
-                switch (solution.riskLevel) {
-                    case 'low':
-                        score += 25;
-                        break;
-                    case 'medium':
-                        score += 15;
-                        break;
-                    case 'high':
-                        score += 5;
-                        break;
-                }
-                // 技术匹配度评分
-                if (task.context.projectInfo) {
-                    const techMatch = solution.techRequirements.some(req => task.context.projectInfo.techStack.some(tech => req.toLowerCase().includes(tech.toLowerCase())));
-                    if (techMatch)
-                        score += 20;
-                }
-                // 优缺点平衡评分
-                const prosCount = solution.pros.length;
-                const consCount = solution.cons.length;
-                if (prosCount > consCount)
-                    score += 15;
-                else if (prosCount === consCount)
-                    score += 10;
-                else
-                    score += 5;
-                // 时间估算合理性评分
-                if (solution.estimatedTime.includes('天') || solution.estimatedTime.includes('小时')) {
-                    score += 10;
-                }
-                return Object.assign(Object.assign({}, solution), { score });
-            });
-            // 按评分排序
-            return evaluatedSolutions.sort((a, b) => b.score - a.score);
-        });
-    }
-    /**
-     * 生成响应
-     */
-    generateResponse(solutions) {
-        return {
-            stage: types_1.WorkflowStage.IDEATION,
-            status: 'success',
-            message: this.formatSolutionsMessage(solutions),
-            data: { solutions },
-            nextActions: ['选择方案进入计划阶段', '修改方案', '重新生成方案'],
-            requiresUserConfirmation: true
-        };
-    }
-    /**
-     * 格式化方案消息
-     */
-    formatSolutionsMessage(solutions) {
-        const solutionsText = solutions.map((solution, index) => `
-## 方案 ${index + 1}：${solution.name} (评分: ${solution.score})
-
-**描述**：${solution.description}
-
-**优点**：
-${solution.pros.map(pro => `- ✅ ${pro}`).join('\n')}
-
-**缺点**：
-${solution.cons.map(con => `- ❌ ${con}`).join('\n')}
-
-**技术要求**：${solution.techRequirements.join(', ')}
-**复杂度**：${this.getComplexityLabel(solution.complexity)}
-**风险等级**：${this.getRiskLabel(solution.riskLevel)}
-**预估时间**：${solution.estimatedTime}
-    `).join('\n---\n');
-        return `
-# [模式：构思] 解决方案生成完成 💡
-
-已生成 ${solutions.length} 个可行的解决方案，按推荐度排序：
-
-${solutionsText}
-
-## 📊 推荐方案
-
-**推荐选择方案 1：${solutions[0].name}**
-- 综合评分最高 (${solutions[0].score}分)
-- 在复杂度、风险和技术匹配度方面表现最佳
-
-**请选择您偏好的方案，或提出修改建议。确认后将进入详细规划阶段。**
-    `.trim();
-    }
-    /**
-     * 获取默认方案
-     */
-    getDefaultSolutions(task) {
-        var _a, _b;
-        return [
-            {
-                id: 'solution_1',
-                name: '标准实现方案',
-                description: '使用项目现有技术栈的标准实现方式',
-                pros: ['技术栈匹配', '开发风险低', '维护成本低'],
-                cons: ['可能缺乏创新性', '性能优化空间有限'],
-                complexity: 'medium',
-                estimatedTime: '3-5天',
-                techRequirements: ((_a = task.context.projectInfo) === null || _a === void 0 ? void 0 : _a.techStack) || ['通用技术'],
-                riskLevel: 'low',
-                score: 0
-            },
-            {
-                id: 'solution_2',
-                name: '优化实现方案',
-                description: '在标准方案基础上进行性能和架构优化',
-                pros: ['性能更好', '架构更清晰', '扩展性强'],
-                cons: ['开发时间较长', '复杂度较高'],
-                complexity: 'high',
-                estimatedTime: '5-8天',
-                techRequirements: ((_b = task.context.projectInfo) === null || _b === void 0 ? void 0 : _b.techStack) || ['通用技术'],
-                riskLevel: 'medium',
-                score: 0
-            }
-        ];
-    }
-    getComplexityLabel(complexity) {
-        const labels = {
-            'low': '🟢 低',
-            'medium': '🟡 中',
-            'high': '🔴 高'
-        };
-        return labels[complexity] || complexity;
-    }
-    getRiskLabel(risk) {
-        const labels = {
-            'low': '🟢 低风险',
-            'medium': '🟡 中风险',
-            'high': '🔴 高风险'
-        };
-        return labels[risk] || risk;
-    }
-}
-exports.IdeationStage = IdeationStage;

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

@@ -1,334 +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.OptimizationStage = void 0;
-const logger_1 = require("../../../utils/logger");
-const openai_1 = require("../../../utils/openai");
-const types_1 = require("../types");
-/**
- * 优化阶段处理器
- * 职责：自动检查并分析已实现的代码，提出优化建议
- */
-class OptimizationStage {
-    /**
-     * 执行优化阶段
-     */
-    execute(task, _input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                logger_1.logger.info('开始执行优化阶段', { taskId: task.id });
-                // 获取执行结果
-                const executionResults = this.getExecutionResults(task);
-                // 分析代码并生成优化建议
-                const optimizationSuggestions = yield this.analyzeCodeAndGenerateSuggestions(task, executionResults);
-                // 生成响应
-                const response = this.generateResponse(optimizationSuggestions);
-                logger_1.logger.info('优化阶段执行完成', {
-                    taskId: task.id,
-                    suggestionCount: optimizationSuggestions.length
-                });
-                return response;
-            }
-            catch (error) {
-                logger_1.logger.error('优化阶段执行失败', { error, taskId: task.id });
-                throw new types_1.CodeGeneratorError('代码优化分析过程中发生错误', types_1.ErrorCodes.OPTIMIZATION_FAILED, types_1.WorkflowStage.OPTIMIZATION, { taskId: task.id, originalError: error });
-            }
-        });
-    }
-    /**
-     * 获取执行结果
-     */
-    getExecutionResults(task) {
-        var _a;
-        const executionStage = task.stages.find(s => s.stage === types_1.WorkflowStage.EXECUTION);
-        if (!((_a = executionStage === null || executionStage === void 0 ? void 0 : executionStage.output) === null || _a === void 0 ? void 0 : _a.executionResults)) {
-            throw new Error('未找到执行结果');
-        }
-        return executionStage.output.executionResults;
-    }
-    /**
-     * 分析代码并生成优化建议
-     */
-    analyzeCodeAndGenerateSuggestions(task, executionResults) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { taskDescription, projectInfo } = task.context;
-            const prompt = `你是一位资深的代码审查专家，请分析以下代码实施结果并提出优化建议。
-
-## 任务描述
-${taskDescription}
-
-## 执行结果
-- 完成步骤: ${executionResults.completedSteps}/${executionResults.totalSteps}
-- 成功率: ${(executionResults.completedSteps / executionResults.totalSteps * 100).toFixed(1)}%
-
-## 已实现的功能
-${executionResults.stepResults.filter((r) => r.status === 'completed').map((r) => r.result).join('\n')}
-
-## 项目技术栈
-${projectInfo ? `${projectInfo.techStack.join(', ')}` : '通用技术栈'}
-
-请重点关注以下方面的优化：
-1. **冗余代码**: 识别重复或不必要的代码
-2. **性能优化**: 发现性能瓶颈和改进机会
-3. **可维护性**: 提升代码结构和可读性
-4. **安全性**: 识别潜在的安全问题
-5. **最佳实践**: 确保符合行业标准和最佳实践
-
-请以JSON格式返回优化建议：
-{
-  "suggestions": [
-    {
-      "id": "opt_1",
-      "type": "redundancy|performance|maintainability|security|best_practice",
-      "description": "优化建议描述",
-      "currentCode": "当前代码示例",
-      "optimizedCode": "优化后代码示例",
-      "reason": "优化理由",
-      "expectedBenefit": "预期收益",
-      "impact": "low|medium|high",
-      "effort": "low|medium|high"
-    }
-  ]
-}`;
-            try {
-                const result = yield openai_1.openAIService.generateText({
-                    prompt,
-                    system_prompt: "你是专业的代码审查专家，请严格按照JSON格式返回优化建议。"
-                });
-                const jsonMatch = result.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    try {
-                        const data = JSON.parse(jsonMatch[0]);
-                        return data.suggestions.map((suggestion, index) => (Object.assign(Object.assign({}, suggestion), { id: suggestion.id || `opt_${index + 1}` })));
-                    }
-                    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.getDefaultOptimizationSuggestions();
-            }
-        });
-    }
-    /**
-     * 生成响应
-     */
-    generateResponse(suggestions) {
-        if (suggestions.length === 0) {
-            return {
-                stage: types_1.WorkflowStage.OPTIMIZATION,
-                status: 'success',
-                message: this.formatNoOptimizationMessage(),
-                data: { suggestions: [] },
-                nextActions: ['进入评审阶段', '手动检查代码', '重新分析'],
-                requiresUserConfirmation: true
-            };
-        }
-        // 生成优化执行指令
-        const optimizationInstructions = this.generateOptimizationInstructions(suggestions);
-        return {
-            stage: types_1.WorkflowStage.OPTIMIZATION,
-            status: 'success',
-            message: this.formatOptimizationMessage(suggestions),
-            data: { suggestions },
-            nextActions: ['应用优化建议', '选择部分优化', '跳过优化进入评审', '重新分析'],
-            requiresUserConfirmation: true,
-            executionInstructions: optimizationInstructions
-        };
-    }
-    /**
-     * 格式化无优化建议消息
-     */
-    formatNoOptimizationMessage() {
-        return `
-# [模式：优化] 代码质量检查完成 ✅
-
-## 🎉 优秀的代码质量
-
-经过全面的代码质量分析，未发现明显的优化点：
-
-- ✅ **冗余代码**: 无发现重复或不必要的代码
-- ✅ **性能优化**: 无明显性能瓶颈
-- ✅ **可维护性**: 代码结构清晰，可读性良好
-- ✅ **安全性**: 无发现安全隐患
-- ✅ **最佳实践**: 符合行业标准和最佳实践
-
-## 🚀 建议
-
-代码质量已达到生产标准，可以直接进入评审阶段。
-
-**准备进入最终评审阶段...**
-    `.trim();
-    }
-    /**
-     * 格式化优化建议消息
-     */
-    formatOptimizationMessage(suggestions) {
-        // 按影响程度分组
-        const highImpact = suggestions.filter(s => s.impact === 'high');
-        const mediumImpact = suggestions.filter(s => s.impact === 'medium');
-        const lowImpact = suggestions.filter(s => s.impact === 'low');
-        const formatSuggestions = (suggestions) => suggestions.map((suggestion, index) => `
-### ${index + 1}. ${suggestion.description}
-
-**类型**: ${this.getTypeLabel(suggestion.type)}
-**影响程度**: ${this.getImpactLabel(suggestion.impact)}
-**实施难度**: ${this.getEffortLabel(suggestion.effort)}
-
-**优化理由**: ${suggestion.reason}
-**预期收益**: ${suggestion.expectedBenefit}
-
-**当前代码**:
-\`\`\`
-${suggestion.currentCode}
-\`\`\`
-
-**优化后代码**:
-\`\`\`
-${suggestion.optimizedCode}
-\`\`\`
-      `).join('\n---\n');
-        return `
-# [模式：优化] 代码优化建议 🚀
-
-## 📊 优化概览
-
-发现 **${suggestions.length}** 个优化点：
-- 🔴 高影响: ${highImpact.length}个
-- 🟡 中影响: ${mediumImpact.length}个  
-- 🟢 低影响: ${lowImpact.length}个
-
-${highImpact.length > 0 ? `
-## 🔴 高影响优化建议 (强烈推荐)
-
-${formatSuggestions(highImpact)}
-` : ''}
-
-${mediumImpact.length > 0 ? `
-## 🟡 中影响优化建议 (建议考虑)
-
-${formatSuggestions(mediumImpact)}
-` : ''}
-
-${lowImpact.length > 0 ? `
-## 🟢 低影响优化建议 (可选)
-
-${formatSuggestions(lowImpact)}
-` : ''}
-
-## 💡 优化建议
-
-${highImpact.length > 0 ?
-            '**强烈建议先处理高影响的优化点**，这些改进将显著提升代码质量。' :
-            '建议根据项目时间安排选择性应用优化建议。'}
-
-**请选择要应用的优化建议，或确认跳过优化直接进入评审阶段。**
-    `.trim();
-    }
-    /**
-     * 获取默认优化建议
-     */
-    getDefaultOptimizationSuggestions() {
-        return [
-            {
-                id: 'opt_1',
-                type: 'best_practice',
-                description: '添加错误处理和日志记录',
-                currentCode: '// 基础实现，缺少错误处理',
-                optimizedCode: '// 添加 try-catch 和日志记录',
-                reason: '提高代码健壮性和可调试性',
-                expectedBenefit: '减少生产环境问题，便于问题排查',
-                impact: 'medium',
-                effort: 'low'
-            },
-            {
-                id: 'opt_2',
-                type: 'maintainability',
-                description: '添加代码注释和文档',
-                currentCode: '// 缺少注释的代码',
-                optimizedCode: '// 添加详细注释的代码',
-                reason: '提高代码可读性和可维护性',
-                expectedBenefit: '降低后续维护成本',
-                impact: 'low',
-                effort: 'low'
-            }
-        ];
-    }
-    getTypeLabel(type) {
-        const labels = {
-            'redundancy': '🔄 冗余代码',
-            'performance': '⚡ 性能优化',
-            'maintainability': '🔧 可维护性',
-            'security': '🔒 安全性',
-            'best_practice': '✨ 最佳实践'
-        };
-        return labels[type] || type;
-    }
-    getImpactLabel(impact) {
-        const labels = {
-            'high': '🔴 高',
-            'medium': '🟡 中',
-            'low': '🟢 低'
-        };
-        return labels[impact] || impact;
-    }
-    getEffortLabel(effort) {
-        const labels = {
-            'high': '🔴 高',
-            'medium': '🟡 中',
-            'low': '🟢 低'
-        };
-        return labels[effort] || effort;
-    }
-    /**
-     * 生成优化执行指令
-     */
-    generateOptimizationInstructions(suggestions) {
-        const instructions = [];
-        let priority = 1;
-        // 按影响程度排序，高影响的优先执行
-        const sortedSuggestions = suggestions.sort((a, b) => {
-            const impactOrder = { 'high': 3, 'medium': 2, 'low': 1 };
-            return impactOrder[b.impact] - impactOrder[a.impact];
-        });
-        for (const suggestion of sortedSuggestions) {
-            // 为每个优化建议生成文件修改指令
-            instructions.push({
-                id: `optimize_${suggestion.id}`,
-                type: 'file_operation',
-                operation: 'modify',
-                targetPath: this.extractFilePathFromCode(suggestion.currentCode),
-                sourceContent: suggestion.currentCode,
-                newContent: suggestion.optimizedCode,
-                description: `优化: ${suggestion.description}`,
-                priority: priority++
-            });
-        }
-        return instructions;
-    }
-    /**
-     * 从代码中提取文件路径（简化实现）
-     */
-    extractFilePathFromCode(code) {
-        // 这里可以根据实际情况实现更复杂的路径提取逻辑
-        // 目前返回一个通用路径，实际使用时需要根据具体情况调整
-        return 'src/main.ts';
-    }
-}
-exports.OptimizationStage = OptimizationStage;