intention-coding 0.3.8 → 0.4.1

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

@@ -1,254 +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());
-    });
-};
-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

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

@@ -1,199 +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.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);
-}