intention-coding 0.3.7 → 0.4.0

package/dist/services/requirement-analyzer/core/document-generator.js

@@ -0,0 +1,254 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentGenerator = void 0;
+const fs = __importStar(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const openai_1 = require("../../../utils/openai");
+const logger_1 = require("../../../utils/logger");
+const config_1 = require("../../../utils/config");
+const common_1 = require("../../../utils/common");
+const types_1 = require("./types");
+const template_selector_1 = require("./template-selector");
+/**
+ * 文档生成器
+ * 职责：生成统一的技术需求文档
+ */
+class DocumentGenerator {
+    constructor() {
+        this.templateSelector = new template_selector_1.TemplateSelector();
+    }
+    /**
+     * 生成统一的技术需求文档
+     */
+    generateUnifiedDocument(analysis, projectInfo, featureName, sourceInfo, customPrompt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始生成统一技术文档', {
+                    featureName,
+                    requirementType: analysis.requirementType,
+                    featureCount: analysis.requirements.length
+                });
+                // 准备输出目录和文件路径
+                const { outputPath, requirementDir } = yield this.prepareOutputPath(featureName);
+                // 构建统一的文档内容
+                const unifiedContent = this.buildUnifiedContent(analysis, projectInfo, featureName, sourceInfo);
+                // 选择合适的模板并生成文档
+                const document = yield this.generateDocument(unifiedContent, featureName, analysis.requirementType, projectInfo, customPrompt);
+                // 保存文档
+                yield fs.writeFile(outputPath, document, 'utf8');
+                // 构建结果
+                const result = this.buildAnalysisResult(analysis, projectInfo, outputPath, sourceInfo);
+                logger_1.logger.info('统一技术文档生成完成', {
+                    outputPath,
+                    documentLength: document.length
+                });
+                return result;
+            }
+            catch (error) {
+                if (error instanceof types_1.RequirementAnalysisError) {
+                    throw error;
+                }
+                logger_1.logger.error('文档生成失败', { error, featureName });
+                throw new types_1.RequirementAnalysisError('技术文档生成过程中发生错误，请检查需求内容和项目配置', types_1.ErrorCodes.DOCUMENT_GENERATION_FAILED, { featureName, originalError: error });
+            }
+        });
+    }
+    /**
+     * 准备输出路径
+     */
+    prepareOutputPath(featureName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requirementDir = path_1.default.join((0, config_1.getStorageDir)(), 'requirements', (0, common_1.sanitizeFileName)(featureName));
+            yield fs.mkdir(requirementDir, { recursive: true });
+            const sanitizedFeatureName = (0, common_1.sanitizeFileName)(featureName);
+            const outputFileName = `${sanitizedFeatureName}.md`;
+            const outputPath = path_1.default.join(requirementDir, outputFileName);
+            return { outputPath, requirementDir };
+        });
+    }
+    /**
+     * 构建统一的文档内容
+     */
+    buildUnifiedContent(analysis, projectInfo, featureName, sourceInfo) {
+        var _a, _b, _c;
+        // 获取功能点列表
+        const featuresToProcess = ((_a = analysis.featureDependencies) === null || _a === void 0 ? void 0 : _a.mergedFeatures) ||
+            analysis.requirements;
+        // 合并所有功能点内容
+        const combinedFeatureContent = featuresToProcess.map((feature, index) => {
+            const featureTitle = 'title' in feature ? feature.title : feature.featureName;
+            const featureContent = 'fullContent' in feature ? feature.fullContent : feature.description;
+            return `## 功能点${index + 1}：${featureTitle}\n\n${featureContent}`;
+        }).join('\n\n');
+        return `# ${featureName} - 统一需求分析
+
+## 项目基本信息
+- **项目类型**: ${(projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectType) || '通用项目'}
+- **主要技术栈**: ${((_b = projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.techStack) === null || _b === void 0 ? void 0 : _b.join(', ')) || '待确定'}
+- **开发框架**: ${((_c = projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.frameworks) === null || _c === void 0 ? void 0 : _c.join(', ')) || '待确定'}
+- **编程语言**: ${(projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.language) || '待确定'}
+
+## 需求类型分析
+- **识别类型**: ${analysis.requirementType}
+- **推荐模板**: ${analysis.templateRecommendation.primaryTemplate}
+- **功能点数量**: ${featuresToProcess.length}个
+- **置信度**: ${analysis.confidence || 'medium'}
+
+## 功能点详细描述
+
+${combinedFeatureContent}
+
+## 数据来源
+- **输入来源**: ${sourceInfo}
+- **分析时间**: ${new Date().toISOString()}
+`;
+    }
+    /**
+     * 生成技术文档
+     */
+    generateDocument(content, title, requirementType, projectInfo, customPrompt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 选择合适的模板
+                const template = this.templateSelector.selectTemplate(requirementType);
+                this.templateSelector.validateTemplate(template, requirementType);
+                // 构建完整的prompt
+                const fullPrompt = this.buildDocumentPrompt(template, content, title, projectInfo, customPrompt);
+                // 调用AI服务生成文档
+                const document = yield openai_1.openAIService.generateText({
+                    prompt: fullPrompt,
+                    system_prompt: "你是一位专业的技术文档编写专家，请生成完整、详细的技术需求文档。"
+                });
+                this.validateGeneratedDocument(document, title);
+                return document;
+            }
+            catch (error) {
+                logger_1.logger.error('技术文档生成失败', { error, requirementType });
+                throw new types_1.RequirementAnalysisError(`无法生成${requirementType}类型的技术文档，请检查需求描述是否完整`, types_1.ErrorCodes.DOCUMENT_GENERATION_FAILED, { requirementType, originalError: error });
+            }
+        });
+    }
+    /**
+     * 构建文档生成prompt
+     */
+    buildDocumentPrompt(template, content, title, projectInfo, customPrompt) {
+        let prompt = template
+            .replace(/\{featureName\}/g, title)
+            .replace(/\{inputContent\}/g, content)
+            .replace(/\{currentTime\}/g, new Date().toISOString())
+            .replace(/\{businessDomain\}/g, (projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectType) || '通用业务')
+            .replace(/\{generateSequenceDiagram\}/g, 'true');
+        if (customPrompt) {
+            prompt += `\n\n## 自定义要求\n${customPrompt}`;
+        }
+        return prompt;
+    }
+    /**
+     * 验证生成的文档
+     */
+    validateGeneratedDocument(document, title) {
+        if (!document || document.trim().length < 100) {
+            throw new types_1.RequirementAnalysisError('生成的技术文档内容过短，可能存在问题', types_1.ErrorCodes.DOCUMENT_GENERATION_FAILED, { title, documentLength: (document === null || document === void 0 ? void 0 : document.length) || 0 });
+        }
+        if (!document.includes(title)) {
+            logger_1.logger.warn('生成的文档可能与需求标题不匹配', { title });
+        }
+    }
+    /**
+     * 构建分析结果
+     */
+    buildAnalysisResult(analysis, projectInfo, outputPath, sourceInfo) {
+        var _a;
+        const featuresToProcess = ((_a = analysis.featureDependencies) === null || _a === void 0 ? void 0 : _a.mergedFeatures) ||
+            analysis.requirements;
+        return {
+            success: true,
+            message: `
+# ✅ 统一技术文档生成完成
+
+## 📊 智能分析结果
+- **项目类型**: ${(projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectType) || '通用项目'}
+- **需求类型**: ${analysis.requirementType}
+- **推荐模板**: ${analysis.templateRecommendation.primaryTemplate}
+- **总计功能点**: ${featuresToProcess.length} 个
+- **输入来源**: ${sourceInfo}
+- **分析模式**: 统一技术文档生成
+- **生成文档**: 1 个统一技术需求文档
+
+## 🎯 功能点清单
+${featuresToProcess.map((f, i) => {
+                const featureTitle = 'title' in f ? f.title : f.featureName;
+                const priority = 'priority' in f ? f.priority : 'medium';
+                const complexity = 'complexity' in f ? f.complexity : f.estimatedComplexity;
+                const techType = 'technologyType' in f ? f.technologyType : analysis.requirementType;
+                return `- ${i + 1}. **${featureTitle}** (${priority}优先级, ${complexity}复杂度, ${techType}类型)`;
+            }).join('\n')}
+
+## 📁 生成文件
+- \`${path_1.default.resolve(outputPath)}\`
+
+## 💡 优化说明
+1. **项目分析**: 自动分析项目基本情况，提取技术栈、框架等信息
+2. **智能识别**: 根据需求内容智能识别为**${analysis.requirementType}**类型
+3. **模板匹配**: 自动选择**${analysis.templateRecommendation.primaryTemplate}**技术模板
+4. **统一文档**: 将多个功能点合并生成一个完整的技术需求文档
+
+您可以在上述路径查看统一的技术需求分析文档。
+      `.trim(),
+            outputPath,
+            generatedFiles: [path_1.default.resolve(outputPath)],
+            analysisInfo: {
+                requirementType: analysis.requirementType,
+                recommendedTemplate: analysis.templateRecommendation.primaryTemplate,
+                featureCount: featuresToProcess.length,
+                projectType: projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectType
+            }
+        };
+    }
+}
+exports.DocumentGenerator = DocumentGenerator;

package/dist/services/requirement-analyzer/core/intelligent-analyzer.js

@@ -0,0 +1,169 @@
+"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.IntelligentAnalyzer = void 0;
+const openai_1 = require("../../../utils/openai");
+const logger_1 = require("../../../utils/logger");
+const types_1 = require("./types");
+const intelligent_requirement_analysis_1 = require("../prompt/intelligent-requirement-analysis");
+/**
+ * 智能需求分析器
+ * 职责：使用AI进行智能需求分析，识别需求类型和功能点
+ */
+class IntelligentAnalyzer {
+    /**
+     * 执行智能需求分析
+     */
+    analyzeRequirements(inputContent, projectInfo, customPrompt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                logger_1.logger.info('开始智能需求分析', {
+                    contentLength: inputContent.length,
+                    hasProjectInfo: !!projectInfo,
+                    projectType: projectInfo === null || projectInfo === void 0 ? void 0 : projectInfo.projectType
+                });
+                // 构建增强的分析prompt
+                const enhancedPrompt = this.buildEnhancedPrompt(inputContent, projectInfo);
+                // 调用AI服务进行分析
+                const result = yield this.callAIService(enhancedPrompt);
+                // 解析和验证结果
+                const analysis = this.parseAnalysisResult(result);
+                this.validateAnalysisResult(analysis);
+                logger_1.logger.info('智能需求分析成功', {
+                    analysisType: analysis.analysisType,
+                    requirementType: analysis.requirementType,
+                    requirementCount: analysis.requirements.length,
+                    primaryTemplate: (_a = analysis.templateRecommendation) === null || _a === void 0 ? void 0 : _a.primaryTemplate
+                });
+                return analysis;
+            }
+            catch (error) {
+                if (error instanceof types_1.RequirementAnalysisError) {
+                    throw error;
+                }
+                logger_1.logger.error('智能需求分析失败', { error });
+                throw new types_1.RequirementAnalysisError('需求分析过程中发生错误，请检查输入内容是否完整', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED, { inputContent: inputContent.substring(0, 200) + '...' });
+            }
+        });
+    }
+    /**
+     * 构建包含项目信息的增强prompt
+     */
+    buildEnhancedPrompt(inputContent, projectInfo) {
+        let enhancedPrompt = intelligent_requirement_analysis_1.intelligentRequirementAnalysisPrompt.replace('{inputContent}', inputContent);
+        if (projectInfo && projectInfo.projectType !== '通用项目') {
+            const projectContext = this.buildProjectContext(projectInfo);
+            enhancedPrompt = enhancedPrompt.replace('## 输入内容', projectContext + '## 输入内容');
+        }
+        return enhancedPrompt;
+    }
+    /**
+     * 构建项目上下文信息
+     */
+    buildProjectContext(projectInfo) {
+        var _a, _b, _c;
+        return `
+## 项目基本信息
+- **项目类型**: ${projectInfo.projectType}
+- **主要技术栈**: ${((_a = projectInfo.techStack) === null || _a === void 0 ? void 0 : _a.join(', ')) || '待确定'}
+- **开发框架**: ${((_b = projectInfo.frameworks) === null || _b === void 0 ? void 0 : _b.join(', ')) || '待确定'}
+- **编程语言**: ${projectInfo.language || '待确定'}
+- **主要依赖**: ${((_c = projectInfo.dependencies) === null || _c === void 0 ? void 0 : _c.slice(0, 5).join(', ')) || '待确定'}
+
+请结合以上项目信息进行需求分析，确保生成的技术文档与项目技术栈匹配。
+
+`;
+    }
+    /**
+     * 调用AI服务
+     */
+    callAIService(prompt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield openai_1.openAIService.generateText({
+                    prompt,
+                    system_prompt: "你是一个专业的需求分析师，请严格按照JSON格式输出分析结果。"
+                });
+            }
+            catch (error) {
+                logger_1.logger.error('AI服务调用失败', { error });
+                throw new types_1.RequirementAnalysisError('AI分析服务暂时不可用，请稍后重试', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED, { originalError: error });
+            }
+        });
+    }
+    /**
+     * 解析AI分析结果
+     */
+    parseAnalysisResult(result) {
+        try {
+            const jsonMatch = result.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                throw new Error('未找到有效的JSON格式结果');
+            }
+            const analysis = JSON.parse(jsonMatch[0]);
+            // 如果是多功能点分析，构造依赖分析结果
+            if (analysis.analysisType === 'multi_general' || analysis.analysisType === 'multi_specific_features') {
+                analysis.featureDependencies = this.buildFeatureDependencies(analysis);
+            }
+            return analysis;
+        }
+        catch (parseError) {
+            logger_1.logger.error('解析AI分析结果失败', { parseError, result: result.substring(0, 500) });
+            throw new types_1.RequirementAnalysisError('分析结果格式异常，请重新尝试或简化需求描述', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED, { parseError });
+        }
+    }
+    /**
+     * 构建功能依赖关系
+     */
+    buildFeatureDependencies(analysis) {
+        var _a;
+        return {
+            requirementType: analysis.requirementType,
+            primaryTemplate: ((_a = analysis.templateRecommendation) === null || _a === void 0 ? void 0 : _a.primaryTemplate) || 'api',
+            mergedFeatures: analysis.requirements.map((req) => ({
+                featureName: req.title,
+                description: req.fullContent,
+                priority: req.priority,
+                estimatedComplexity: req.complexity,
+                type: '核心功能点',
+                businessValue: `${req.title}的业务价值`,
+                technologyType: req.type,
+                subFeatures: []
+            })),
+            dependencies: []
+        };
+    }
+    /**
+     * 验证分析结果
+     */
+    validateAnalysisResult(analysis) {
+        var _a;
+        // 验证必要字段
+        if (!analysis.analysisType) {
+            throw new types_1.RequirementAnalysisError('分析结果缺少分析类型信息', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED);
+        }
+        if (!analysis.requirements || analysis.requirements.length === 0) {
+            throw new types_1.RequirementAnalysisError('未能识别出有效的需求功能点，请检查需求描述是否清晰', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED);
+        }
+        if (!((_a = analysis.templateRecommendation) === null || _a === void 0 ? void 0 : _a.primaryTemplate)) {
+            throw new types_1.RequirementAnalysisError('无法确定合适的技术模板，请明确需求的技术类型', types_1.ErrorCodes.TEMPLATE_SELECTION_FAILED);
+        }
+        // 验证需求类型的合理性
+        const validTypes = ['接口', 'PC页面', 'APP', 'SDK集成', '混合类型'];
+        if (analysis.requirementType && !validTypes.includes(analysis.requirementType)) {
+            logger_1.logger.warn('检测到非标准需求类型', {
+                requirementType: analysis.requirementType
+            });
+        }
+    }
+}
+exports.IntelligentAnalyzer = IntelligentAnalyzer;

package/dist/services/requirement-analyzer/core/project-analyzer.js

@@ -0,0 +1,199 @@
+"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.ProjectAnalyzer = void 0;
+exports.extractProjectInfo = extractProjectInfo;
+const pack_1 = require("../../../utils/pack");
+const logger_1 = require("../../../utils/logger");
+const types_1 = require("./types");
+const fs = __importStar(require("fs/promises"));
+/**
+ * 项目分析服务
+ * 职责：分析项目基本情况，提取技术栈信息
+ */
+class ProjectAnalyzer {
+    /**
+     * 分析项目基本情况
+     */
+    analyzeProject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始分析项目基本情况');
+                const projectAnalysisPath = yield (0, pack_1.packProject)();
+                logger_1.logger.info('项目分析完成', { analysisPath: projectAnalysisPath });
+                const projectAnalysisContent = yield fs.readFile(projectAnalysisPath, 'utf8');
+                const projectInfo = this.extractProjectInfo(projectAnalysisContent);
+                logger_1.logger.info('项目信息提取完成', { projectInfo });
+                return projectInfo;
+            }
+            catch (error) {
+                logger_1.logger.warn('项目分析失败，使用默认配置', { error });
+                // 提供默认的项目信息而不是抛出异常
+                return this.getDefaultProjectInfo();
+            }
+        });
+    }
+    /**
+     * 从项目分析内容中提取关键信息
+     */
+    extractProjectInfo(projectAnalysis) {
+        const projectInfo = {
+            techStack: [],
+            frameworks: [],
+            language: '',
+            projectType: '',
+            dependencies: []
+        };
+        // 提取技术栈信息
+        const techStackKeywords = [
+            'React', 'Vue', 'Angular', 'Svelte',
+            'Node.js', 'Express', 'Koa', 'Fastify',
+            'Python', 'Django', 'Flask',
+            'Java', 'Spring', 'Spring Boot',
+            'TypeScript', 'JavaScript',
+            'PostgreSQL', 'MySQL', 'MongoDB', 'Redis',
+            'Docker', 'Kubernetes'
+        ];
+        // 提取框架信息
+        const frameworkKeywords = [
+            'React', 'Vue', 'Angular', 'Svelte',
+            'Express', 'Koa', 'Fastify',
+            'Django', 'Flask',
+            'Spring', 'Spring Boot',
+            'Next.js', 'Nuxt.js'
+        ];
+        // 提取编程语言
+        const languageKeywords = [
+            'TypeScript', 'JavaScript', 'Python', 'Java', 'Go', 'Rust', 'C#'
+        ];
+        // 在项目分析内容中查找匹配的关键词
+        for (const keyword of techStackKeywords) {
+            if (projectAnalysis.includes(keyword)) {
+                projectInfo.techStack.push(keyword);
+            }
+        }
+        for (const keyword of frameworkKeywords) {
+            if (projectAnalysis.includes(keyword)) {
+                projectInfo.frameworks.push(keyword);
+            }
+        }
+        for (const keyword of languageKeywords) {
+            if (projectAnalysis.includes(keyword)) {
+                projectInfo.language = keyword;
+                break;
+            }
+        }
+        // 判断项目类型
+        projectInfo.projectType = this.determineProjectType(projectAnalysis);
+        // 提取依赖信息
+        projectInfo.dependencies = this.extractDependencies(projectAnalysis);
+        return projectInfo;
+    }
+    /**
+     * 确定项目类型
+     */
+    determineProjectType(projectAnalysis) {
+        if (projectAnalysis.includes('package.json')) {
+            return 'Node.js项目';
+        }
+        else if (projectAnalysis.includes('requirements.txt') || projectAnalysis.includes('pyproject.toml')) {
+            return 'Python项目';
+        }
+        else if (projectAnalysis.includes('pom.xml') || projectAnalysis.includes('build.gradle')) {
+            return 'Java项目';
+        }
+        else if (projectAnalysis.includes('Cargo.toml')) {
+            return 'Rust项目';
+        }
+        else if (projectAnalysis.includes('go.mod')) {
+            return 'Go项目';
+        }
+        else {
+            return '通用项目';
+        }
+    }
+    /**
+     * 提取依赖信息
+     */
+    extractDependencies(projectAnalysis) {
+        const dependencyMatch = projectAnalysis.match(/## 依赖.*?```.*?\n([\s\S]*?)\n```/);
+        if (dependencyMatch && dependencyMatch[1]) {
+            return dependencyMatch[1]
+                .split('\n')
+                .filter(line => line.trim() !== '')
+                .map(line => line.trim())
+                .slice(0, 10); // 限制依赖数量
+        }
+        return [];
+    }
+    /**
+     * 获取默认项目信息
+     */
+    getDefaultProjectInfo() {
+        return {
+            techStack: [],
+            frameworks: [],
+            language: '',
+            projectType: '通用项目',
+            dependencies: []
+        };
+    }
+    /**
+     * 验证项目信息的完整性
+     */
+    validateProjectInfo(projectInfo) {
+        if (!projectInfo.projectType) {
+            throw new types_1.RequirementAnalysisError('无法确定项目类型，请检查项目结构', types_1.ErrorCodes.PROJECT_ANALYSIS_FAILED, { projectInfo });
+        }
+    }
+}
+exports.ProjectAnalyzer = ProjectAnalyzer;
+/**
+ * 从项目分析内容中提取项目信息的工具函数
+ * 保持向后兼容性
+ */
+function extractProjectInfo(projectAnalysis) {
+    const analyzer = new ProjectAnalyzer();
+    return analyzer.extractProjectInfo(projectAnalysis);
+}