intention-coding 0.4.0 → 0.4.3

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

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

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

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

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