intention-coding 0.3.7 → 0.4.0

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

@@ -0,0 +1,191 @@
+"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.RequirementAnalyzerService = void 0;
+const fs = __importStar(require("fs/promises"));
+const logger_1 = require("../../../utils/logger");
+const common_1 = require("../../../utils/common");
+const file_reader_1 = require("../utils/file-reader");
+const types_1 = require("./types");
+const project_analyzer_1 = require("./project-analyzer");
+const intelligent_analyzer_1 = require("./intelligent-analyzer");
+const document_generator_1 = require("./document-generator");
+/**
+ * 需求分析器服务
+ * 职责：协调各个组件完成需求分析流程
+ */
+class RequirementAnalyzerService {
+    constructor() {
+        this.projectAnalyzer = new project_analyzer_1.ProjectAnalyzer();
+        this.intelligentAnalyzer = new intelligent_analyzer_1.IntelligentAnalyzer();
+        this.documentGenerator = new document_generator_1.DocumentGenerator();
+    }
+    /**
+     * 执行需求分析
+     */
+    analyzeRequirements(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.info('开始需求分析流程', {
+                    featureName: params.feature_name,
+                    inputType: params.input_type
+                });
+                // 1. 验证和准备输入内容
+                const { inputContent, sourceInfo } = yield this.prepareInput(params);
+                // 2. 分析项目基本情况
+                const projectInfo = yield this.projectAnalyzer.analyzeProject();
+                // 3. 执行智能需求分析
+                const requirementAnalysis = yield this.intelligentAnalyzer.analyzeRequirements(inputContent, projectInfo, params.custom_prompt);
+                // 4. 处理不同类型的分析结果
+                if (this.isMultiFeatureAnalysis(requirementAnalysis)) {
+                    return yield this.handleMultiFeatureAnalysis(requirementAnalysis, projectInfo, params, sourceInfo);
+                }
+                else {
+                    return yield this.handleSingleFeatureAnalysis(requirementAnalysis, projectInfo, params, sourceInfo);
+                }
+            }
+            catch (error) {
+                if (error instanceof types_1.RequirementAnalysisError) {
+                    throw error;
+                }
+                logger_1.logger.error('需求分析流程失败', { error, params });
+                throw new types_1.RequirementAnalysisError('需求分析过程中发生未知错误，请检查输入参数和系统状态', types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED, { params, originalError: error });
+            }
+        });
+    }
+    /**
+     * 准备输入内容
+     */
+    prepareInput(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let inputContent;
+            let sourceInfo;
+            try {
+                if (params.input_type === 'text') {
+                    if (!params.content) {
+                        throw new types_1.RequirementAnalysisError('文本输入模式下content参数不能为空', types_1.ErrorCodes.INVALID_INPUT);
+                    }
+                    inputContent = params.content;
+                    sourceInfo = '用户直接输入';
+                }
+                else if (params.input_type === 'md_file') {
+                    if (!params.md_file_path) {
+                        throw new types_1.RequirementAnalysisError('MD文件模式下md_file_path参数不能为空', types_1.ErrorCodes.INVALID_INPUT);
+                    }
+                    const resolvedPath = yield (0, common_1.validateAndResolvePath)(params.md_file_path);
+                    const stats = yield fs.stat(resolvedPath);
+                    const fileSizeInMB = stats.size / (1024 * 1024);
+                    logger_1.logger.info('读取MD文件', {
+                        file: params.md_file_path,
+                        size: `${fileSizeInMB.toFixed(2)} MB`,
+                        useStreaming: params.use_streaming
+                    });
+                    // 根据文件大小选择读取方式
+                    if (fileSizeInMB > 1 || params.use_streaming) {
+                        const chunkSize = params.chunk_size || 100;
+                        inputContent = yield (0, file_reader_1.readLargeFileContent)(resolvedPath, chunkSize);
+                    }
+                    else {
+                        inputContent = yield fs.readFile(resolvedPath, 'utf8');
+                    }
+                    sourceInfo = `MD文件: ${params.md_file_path}`;
+                    logger_1.logger.info('MD文件读取成功', {
+                        file: params.md_file_path,
+                        contentLength: inputContent.length
+                    });
+                }
+                else {
+                    throw new types_1.RequirementAnalysisError(`不支持的输入类型: ${params.input_type}`, types_1.ErrorCodes.INVALID_INPUT);
+                }
+                // 验证内容长度
+                if (!inputContent || inputContent.trim().length < 10) {
+                    throw new types_1.RequirementAnalysisError('输入内容过短，请提供更详细的需求描述', types_1.ErrorCodes.INVALID_INPUT);
+                }
+                return { inputContent, sourceInfo };
+            }
+            catch (error) {
+                if (error instanceof types_1.RequirementAnalysisError) {
+                    throw error;
+                }
+                logger_1.logger.error('输入内容准备失败', { error, params });
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                    throw new types_1.RequirementAnalysisError(`指定的文件不存在: ${params.md_file_path}`, types_1.ErrorCodes.FILE_NOT_FOUND, { filePath: params.md_file_path });
+                }
+                throw new types_1.RequirementAnalysisError('读取输入内容时发生错误，请检查文件路径和权限', types_1.ErrorCodes.INVALID_INPUT, { originalError: error });
+            }
+        });
+    }
+    /**
+     * 判断是否为多功能点分析
+     */
+    isMultiFeatureAnalysis(analysis) {
+        return analysis.analysisType === 'multi_specific_features' ||
+            analysis.requirements.length > 1;
+    }
+    /**
+     * 处理多功能点分析
+     */
+    handleMultiFeatureAnalysis(analysis, projectInfo, params, sourceInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.logger.info('执行多功能点统一分析', {
+                featureName: params.feature_name,
+                requirementCount: analysis.requirements.length
+            });
+            return yield this.documentGenerator.generateUnifiedDocument(analysis, projectInfo, params.feature_name, sourceInfo, params.custom_prompt);
+        });
+    }
+    /**
+     * 处理单功能点分析
+     */
+    handleSingleFeatureAnalysis(analysis, projectInfo, params, sourceInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.logger.info('执行单功能点分析', {
+                featureName: params.feature_name,
+                requirementType: analysis.requirementType
+            });
+            return yield this.documentGenerator.generateUnifiedDocument(analysis, projectInfo, params.feature_name, sourceInfo, params.custom_prompt);
+        });
+    }
+}
+exports.RequirementAnalyzerService = RequirementAnalyzerService;

package/dist/services/requirement-analyzer/core/template-selector.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateSelector = void 0;
+const logger_1 = require("../../../utils/logger");
+const types_1 = require("./types");
+// 导入所有模板
+const requirement_analysis_1 = require("../prompt/requirement-analysis");
+const pc_page_template_1 = require("../prompt/pc-page-template");
+const app_template_1 = require("../prompt/app-template");
+const sdk_template_1 = require("../prompt/sdk-template");
+const api_template_1 = require("../prompt/api-template");
+/**
+ * 模板选择器
+ * 职责：根据需求类型选择合适的技术模板
+ */
+class TemplateSelector {
+    constructor() {
+        this.templateMap = new Map([
+            ['PC页面', pc_page_template_1.pcPageTemplatePrompt],
+            ['APP', app_template_1.appTemplatePrompt],
+            ['SDK集成', sdk_template_1.sdkTemplatePrompt],
+            ['接口', api_template_1.apiTemplatePrompt],
+            ['api', api_template_1.apiTemplatePrompt],
+            ['pc', pc_page_template_1.pcPageTemplatePrompt],
+            ['app', app_template_1.appTemplatePrompt],
+            ['sdk', sdk_template_1.sdkTemplatePrompt]
+        ]);
+    }
+    /**
+     * 根据需求类型选择模板
+     */
+    selectTemplate(requirementType) {
+        logger_1.logger.info('开始选择技术模板', { requirementType });
+        // 精确匹配
+        if (this.templateMap.has(requirementType)) {
+            const template = this.templateMap.get(requirementType);
+            logger_1.logger.info('精确匹配模板成功', { requirementType });
+            return template;
+        }
+        // 模糊匹配
+        const fuzzyMatch = this.fuzzyMatchTemplate(requirementType);
+        if (fuzzyMatch) {
+            logger_1.logger.info('模糊匹配模板成功', {
+                requirementType,
+                matchedTemplate: fuzzyMatch.type
+            });
+            return fuzzyMatch.template;
+        }
+        // 如果都没有匹配，根据需求类型特征进行智能选择
+        const intelligentMatch = this.intelligentMatchTemplate(requirementType);
+        if (intelligentMatch) {
+            logger_1.logger.info('智能匹配模板成功', {
+                requirementType,
+                matchedTemplate: intelligentMatch.type
+            });
+            return intelligentMatch.template;
+        }
+        // 最后使用默认模板
+        logger_1.logger.warn('使用默认模板', { requirementType });
+        return requirement_analysis_1.requirementAnalysisPrompt;
+    }
+    /**
+     * 模糊匹配模板
+     */
+    fuzzyMatchTemplate(requirementType) {
+        const lowerType = requirementType.toLowerCase();
+        // PC页面相关关键词
+        if (this.containsAny(lowerType, ['页面', 'pc', 'web', '界面', 'ui', '网页', '浏览器', '前端'])) {
+            return { type: 'PC页面', template: pc_page_template_1.pcPageTemplatePrompt };
+        }
+        // APP相关关键词
+        if (this.containsAny(lowerType, ['app', '移动', 'ios', 'android', '小程序', '移动端'])) {
+            return { type: 'APP', template: app_template_1.appTemplatePrompt };
+        }
+        // SDK集成相关关键词
+        if (this.containsAny(lowerType, ['sdk', '第三方', '集成', '对接', '支付', '地图', '推送'])) {
+            return { type: 'SDK集成', template: sdk_template_1.sdkTemplatePrompt };
+        }
+        // 接口相关关键词
+        if (this.containsAny(lowerType, ['接口', 'api', 'rest', 'graphql', '微服务', '后端', '服务端'])) {
+            return { type: '接口', template: api_template_1.apiTemplatePrompt };
+        }
+        return null;
+    }
+    /**
+     * 智能匹配模板（基于需求内容特征）
+     */
+    intelligentMatchTemplate(requirementType) {
+        // 如果包含系统、平台等关键词，可能是综合性需求，使用默认模板
+        if (this.containsAny(requirementType.toLowerCase(), ['系统', '平台', '架构', '综合'])) {
+            return { type: '系统', template: requirement_analysis_1.requirementAnalysisPrompt };
+        }
+        return null;
+    }
+    /**
+     * 检查字符串是否包含任意一个关键词
+     */
+    containsAny(text, keywords) {
+        return keywords.some(keyword => text.includes(keyword));
+    }
+    /**
+     * 验证模板选择结果
+     */
+    validateTemplate(template, requirementType) {
+        if (!template || template.trim().length === 0) {
+            throw new types_1.RequirementAnalysisError(`无法为需求类型 "${requirementType}" 选择合适的模板`, types_1.ErrorCodes.TEMPLATE_SELECTION_FAILED, { requirementType });
+        }
+    }
+    /**
+     * 获取支持的需求类型列表
+     */
+    getSupportedTypes() {
+        return Array.from(this.templateMap.keys());
+    }
+    /**
+     * 检查需求类型是否受支持
+     */
+    isTypeSupported(requirementType) {
+        return this.templateMap.has(requirementType) ||
+            this.fuzzyMatchTemplate(requirementType) !== null ||
+            this.intelligentMatchTemplate(requirementType) !== null;
+    }
+}
+exports.TemplateSelector = TemplateSelector;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCodes = exports.RequirementAnalysisError = void 0;
+// 异常类型定义
+class RequirementAnalysisError extends Error {
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = 'RequirementAnalysisError';
+    }
+}
+exports.RequirementAnalysisError = RequirementAnalysisError;
+var ErrorCodes;
+(function (ErrorCodes) {
+    ErrorCodes["INVALID_INPUT"] = "INVALID_INPUT";
+    ErrorCodes["FILE_NOT_FOUND"] = "FILE_NOT_FOUND";
+    ErrorCodes["PROJECT_ANALYSIS_FAILED"] = "PROJECT_ANALYSIS_FAILED";
+    ErrorCodes["REQUIREMENT_PARSING_FAILED"] = "REQUIREMENT_PARSING_FAILED";
+    ErrorCodes["TEMPLATE_SELECTION_FAILED"] = "TEMPLATE_SELECTION_FAILED";
+    ErrorCodes["DOCUMENT_GENERATION_FAILED"] = "DOCUMENT_GENERATION_FAILED";
+    ErrorCodes["UNSUPPORTED_REQUIREMENT_TYPE"] = "UNSUPPORTED_REQUIREMENT_TYPE";
+})(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));

package/dist/services/requirement-analyzer/index.js

@@ -0,0 +1,177 @@
+"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.ErrorCodes = exports.RequirementAnalysisError = exports.RequirementAnalyzerService = exports.requirementAnalyzerTool = void 0;
+const zod_1 = require("zod");
+const logger_1 = require("../../utils/logger");
+const requirement_analyzer_service_1 = require("./core/requirement-analyzer-service");
+const types_1 = require("./core/types");
+// 参数验证Schema
+const RequirementAnalyzerParamsSchema = zod_1.z
+    .object({
+    input_type: zod_1.z
+        .enum(["text", "md_file"])
+        .describe("输入类型：直接文本输入或引用已生成的MD文件"),
+    content: zod_1.z
+        .string()
+        .optional()
+        .describe("当input_type为text时，直接输入的需求内容"),
+    md_file_path: zod_1.z
+        .string()
+        .optional()
+        .describe("当input_type为md_file时，要分析的MD文件路径"),
+    feature_name: zod_1.z.string().describe("功能名称，用于生成输出文件名"),
+    custom_prompt: zod_1.z
+        .string()
+        .optional()
+        .describe("自定义提示词，用于指导AI生成特定风格的需求文档"),
+    analysis_depth: zod_1.z
+        .enum(["basic", "detailed", "comprehensive"])
+        .default("detailed")
+        .describe("分析深度：基础、详细、综合"),
+    use_streaming: zod_1.z
+        .boolean()
+        .default(false)
+        .describe("是否使用流式处理（适用于大文件）"),
+    chunk_size: zod_1.z
+        .number()
+        .min(10)
+        .max(1000)
+        .default(100)
+        .describe("分块大小（仅在use_streaming为true时有效）"),
+})
+    .refine((data) => {
+    if (data.input_type === "text") {
+        return data.content && data.content.trim().length > 0;
+    }
+    if (data.input_type === "md_file") {
+        return data.md_file_path && data.md_file_path.trim().length > 0;
+    }
+    return false;
+}, {
+    message: "当input_type为text时content必填，当input_type为md_file时md_file_path必填",
+});
+/**
+ * 需求分析智能体工具
+ */
+exports.requirementAnalyzerTool = {
+    name: "需求分析智能体",
+    description: "智能分析需求并生成统一的技术文档，支持项目情况感知和精确模板匹配",
+    parameters: RequirementAnalyzerParamsSchema,
+    execute: (args) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            logger_1.logger.info("开始执行需求分析", {
+                featureName: args.feature_name,
+                inputType: args.input_type,
+            });
+            // 转换参数格式
+            const analysisParams = {
+                input_type: args.input_type,
+                content: args.content,
+                md_file_path: args.md_file_path,
+                feature_name: args.feature_name,
+                custom_prompt: args.custom_prompt,
+                analysis_depth: args.analysis_depth,
+                use_streaming: args.use_streaming,
+                chunk_size: args.chunk_size,
+            };
+            // 创建服务实例并执行分析
+            const analyzerService = new requirement_analyzer_service_1.RequirementAnalyzerService();
+            const result = yield analyzerService.analyzeRequirements(analysisParams);
+            logger_1.logger.info("需求分析执行完成", {
+                success: result.success,
+                outputPath: result.outputPath,
+                featureCount: result.analysisInfo.featureCount,
+            });
+            return result.message;
+        }
+        catch (error) {
+            // 统一的错误处理
+            if (error instanceof types_1.RequirementAnalysisError) {
+                logger_1.logger.error("需求分析业务错误", {
+                    code: error.code,
+                    message: error.message,
+                    context: error.context,
+                });
+                return JSON.stringify(error);
+            }
+            // 未知错误
+            logger_1.logger.error("需求分析未知错误", { error });
+            return `
+# ❌ 需求分析失败
+
+## 错误信息
+系统发生未知错误，请稍后重试或联系技术支持。
+
+## 错误详情
+- **错误类型**: 系统异常
+- **时间**: ${new Date().toISOString()}
+- **建议**: 请检查输入参数是否正确，或稍后重试
+
+如果问题持续存在，请联系技术支持团队。
+      `.trim();
+        }
+    }),
+    /**
+     * 格式化错误消息
+     */
+    formatErrorMessage(error) {
+        const errorMessages = {
+            [types_1.ErrorCodes.INVALID_INPUT]: "输入参数错误",
+            [types_1.ErrorCodes.FILE_NOT_FOUND]: "文件未找到",
+            [types_1.ErrorCodes.PROJECT_ANALYSIS_FAILED]: "项目分析失败",
+            [types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED]: "需求解析失败",
+            [types_1.ErrorCodes.TEMPLATE_SELECTION_FAILED]: "模板选择失败",
+            [types_1.ErrorCodes.DOCUMENT_GENERATION_FAILED]: "文档生成失败",
+            [types_1.ErrorCodes.UNSUPPORTED_REQUIREMENT_TYPE]: "不支持的需求类型",
+        };
+        const errorTitle = errorMessages[error.code] || "未知错误";
+        return `
+# ❌ ${errorTitle}
+
+## 错误信息
+${error.message}
+
+## 错误代码
+${error.code}
+
+## 解决建议
+${this.getErrorSuggestion(error.code)}
+
+## 错误详情
+- **时间**: ${new Date().toISOString()}
+- **上下文**: ${error.context ? JSON.stringify(error.context, null, 2) : "无"}
+
+请根据上述信息调整输入参数后重试。
+    `.trim();
+    },
+    /**
+     * 获取错误解决建议
+     */
+    getErrorSuggestion(errorCode) {
+        const suggestions = {
+            [types_1.ErrorCodes.INVALID_INPUT]: "请检查输入参数是否完整和正确",
+            [types_1.ErrorCodes.FILE_NOT_FOUND]: "请确认文件路径是否正确，文件是否存在",
+            [types_1.ErrorCodes.PROJECT_ANALYSIS_FAILED]: "请检查项目结构是否完整，或手动指定项目信息",
+            [types_1.ErrorCodes.REQUIREMENT_PARSING_FAILED]: "请简化需求描述，确保内容清晰明确",
+            [types_1.ErrorCodes.TEMPLATE_SELECTION_FAILED]: "请明确指定需求类型（接口、PC页面、APP、SDK集成）",
+            [types_1.ErrorCodes.DOCUMENT_GENERATION_FAILED]: "请检查需求内容是否完整，或尝试使用自定义prompt",
+            [types_1.ErrorCodes.UNSUPPORTED_REQUIREMENT_TYPE]: "当前支持的类型：接口、PC页面、APP、SDK集成",
+        };
+        return (suggestions[errorCode] || "请检查输入参数并重试，如问题持续请联系技术支持");
+    },
+};
+// 导出主要类型和服务
+var requirement_analyzer_service_2 = require("./core/requirement-analyzer-service");
+Object.defineProperty(exports, "RequirementAnalyzerService", { enumerable: true, get: function () { return requirement_analyzer_service_2.RequirementAnalyzerService; } });
+var types_2 = require("./core/types");
+Object.defineProperty(exports, "RequirementAnalysisError", { enumerable: true, get: function () { return types_2.RequirementAnalysisError; } });
+Object.defineProperty(exports, "ErrorCodes", { enumerable: true, get: function () { return types_2.ErrorCodes; } });