intention-coding 0.6.3 → 0.6.5

package/dist/index.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
     return 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
@@ -11115,6 +11116,1559 @@ ${requirement_description}
     function getTechSpecOutputDir(projectPath) {
         return `${projectPath}/${TECH_SPEC_OUTPUT_DIR}`;
     }
+    const FILE_TYPE_PATTERNS = {
+        controller: [
+            /Controller\.(ts|js|java)$/i,
+            /controller\.(ts|js|java)$/i,
+            /@Controller/,
+            /@RestController/
+        ],
+        service: [
+            /Service\.(ts|js|java)$/i,
+            /service\.(ts|js|java)$/i,
+            /@Service/,
+            /ServiceImpl\.(ts|js|java)$/i
+        ],
+        entity: [
+            /Entity\.(ts|js|java)$/i,
+            /entity\.(ts|js|java)$/i,
+            /Model\.(ts|js|java)$/i,
+            /model\.(ts|js|java)$/i,
+            /@Entity/,
+            /@Table/
+        ],
+        dto: [
+            /DTO\.(ts|js|java)$/i,
+            /dto\.(ts|js|java)$/i,
+            /Vo\.(ts|js|java)$/i,
+            /vo\.(ts|js|java)$/i,
+            /Bo\.(ts|js|java)$/i,
+            /bo\.(ts|js|java)$/i,
+            /Request\.(ts|js|java)$/i,
+            /Response\.(ts|js|java)$/i,
+            /Query\.(ts|js|java)$/i,
+            /Form\.(ts|js|java)$/i
+        ],
+        config: [
+            /Config\.(ts|js|java)$/i,
+            /config\.(ts|js|java)$/i,
+            /Configuration\.(ts|js|java)$/i,
+            /@Configuration/
+        ]
+    };
+    const IGNORE_PATTERNS = [
+        "node_modules",
+        ".git",
+        ".svn",
+        "target",
+        "build",
+        "dist",
+        ".idea",
+        ".vscode",
+        "logs",
+        "temp",
+        "tmp",
+        ".DS_Store",
+        "Thumbs.db",
+        "*.log",
+        "*.tmp",
+        "*.bak"
+    ];
+    function shouldIgnore(filePath) {
+        const fileName = external_path_namespaceObject.basename(filePath);
+        const dirName = external_path_namespaceObject.dirname(filePath);
+        return IGNORE_PATTERNS.some((pattern)=>{
+            if (pattern.includes("*")) {
+                const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+                return regex.test(fileName);
+            }
+            return fileName === pattern || dirName.includes(pattern) || filePath.includes(pattern);
+        });
+    }
+    async function identifyFileType(filePath) {
+        const fileName = external_path_namespaceObject.basename(filePath);
+        for (const [type, patterns] of Object.entries(FILE_TYPE_PATTERNS))for (const pattern of patterns)if (pattern instanceof RegExp) {
+            if (pattern.test(fileName)) return type;
+        }
+        try {
+            const stats = await promises_namespaceObject.stat(filePath);
+            if (stats.size < 51200) {
+                const content = await promises_namespaceObject.readFile(filePath, "utf-8");
+                for (const [type, patterns] of Object.entries(FILE_TYPE_PATTERNS))for (const pattern of patterns)if (pattern instanceof RegExp && pattern.test(content)) return type;
+            }
+        } catch (error) {}
+        return "other";
+    }
+    async function scanDirectory(dirPath, projectPath, currentModule) {
+        const files = [];
+        try {
+            const entries = await promises_namespaceObject.readdir(dirPath, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                const fullPath = external_path_namespaceObject.join(dirPath, entry.name);
+                const relativePath = external_path_namespaceObject.relative(projectPath, fullPath);
+                if (!shouldIgnore(fullPath)) {
+                    if (entry.isDirectory()) {
+                        const subFiles = await scanDirectory(fullPath, projectPath, currentModule);
+                        files.push(...subFiles);
+                    } else if (entry.isFile()) {
+                        const ext = external_path_namespaceObject.extname(entry.name).toLowerCase();
+                        if ([
+                            ".ts",
+                            ".js",
+                            ".java",
+                            ".kt",
+                            ".py",
+                            ".go",
+                            ".cs"
+                        ].includes(ext)) {
+                            const fileType = await identifyFileType(fullPath);
+                            files.push({
+                                path: fullPath,
+                                name: entry.name,
+                                type: fileType,
+                                relativePath,
+                                module: currentModule
+                            });
+                        }
+                    }
+                }
+            }
+        } catch (error) {
+            logger.warn(`\u{626B}\u{63CF}\u{76EE}\u{5F55}\u{5931}\u{8D25}: ${dirPath}`, {
+                error
+            });
+        }
+        return files;
+    }
+    function identifyModules(files, projectPath) {
+        const moduleMap = new Map();
+        for (const file of files){
+            const pathParts = file.relativePath.split(external_path_namespaceObject.sep);
+            let moduleName = "default";
+            if (pathParts.includes("src") && pathParts.includes("main") && pathParts.includes("java")) {
+                const javaIndex = pathParts.indexOf("java");
+                if (javaIndex + 3 < pathParts.length) moduleName = pathParts[javaIndex + 3];
+            } else if (pathParts.includes("modules") || pathParts.includes("packages")) {
+                const moduleIndex = pathParts.findIndex((p)=>"modules" === p || "packages" === p);
+                if (moduleIndex + 1 < pathParts.length) moduleName = pathParts[moduleIndex + 1];
+            } else if (pathParts.length > 1) moduleName = pathParts[0];
+            if (!moduleMap.has(moduleName)) moduleMap.set(moduleName, []);
+            moduleMap.get(moduleName).push({
+                ...file,
+                module: moduleName
+            });
+        }
+        const modules = [];
+        for (const [moduleName, moduleFiles] of moduleMap.entries()){
+            if (0 === moduleFiles.length) continue;
+            const modulePaths = moduleFiles.map((f)=>external_path_namespaceObject.dirname(f.path));
+            const commonPath = findCommonPath(modulePaths);
+            modules.push({
+                name: moduleName,
+                path: commonPath,
+                relativePath: external_path_namespaceObject.relative(projectPath, commonPath),
+                files: moduleFiles,
+                subModules: []
+            });
+        }
+        return modules;
+    }
+    function findCommonPath(paths) {
+        if (0 === paths.length) return "";
+        if (1 === paths.length) return external_path_namespaceObject.dirname(paths[0]);
+        const parts = paths[0].split(external_path_namespaceObject.sep);
+        let commonLength = parts.length;
+        for(let i = 1; i < paths.length; i++){
+            const currentParts = paths[i].split(external_path_namespaceObject.sep);
+            commonLength = Math.min(commonLength, currentParts.length);
+            for(let j = 0; j < commonLength; j++)if (parts[j] !== currentParts[j]) {
+                commonLength = j;
+                break;
+            }
+        }
+        return parts.slice(0, commonLength).join(external_path_namespaceObject.sep);
+    }
+    async function analyzeProject(projectPath) {
+        logger.info(`\u{5F00}\u{59CB}\u{5206}\u{6790}\u{9879}\u{76EE}: ${projectPath}`);
+        try {
+            const stats = await promises_namespaceObject.stat(projectPath);
+            if (!stats.isDirectory()) throw new Error(`\u{9879}\u{76EE}\u{8DEF}\u{5F84}\u{4E0D}\u{662F}\u{76EE}\u{5F55}: ${projectPath}`);
+            const allFiles = await scanDirectory(projectPath, projectPath);
+            const modules = identifyModules(allFiles, projectPath);
+            const statistics = {
+                totalFiles: allFiles.length,
+                controllerFiles: allFiles.filter((f)=>"controller" === f.type).length,
+                serviceFiles: allFiles.filter((f)=>"service" === f.type).length,
+                entityFiles: allFiles.filter((f)=>"entity" === f.type).length,
+                dtoFiles: allFiles.filter((f)=>"dto" === f.type).length,
+                moduleCount: modules.length
+            };
+            const projectName = external_path_namespaceObject.basename(projectPath);
+            const result = {
+                projectName,
+                projectPath,
+                modules,
+                allFiles,
+                statistics
+            };
+            logger.info(`\u{9879}\u{76EE}\u{5206}\u{6790}\u{5B8C}\u{6210}`, {
+                projectName,
+                moduleCount: modules.length,
+                totalFiles: allFiles.length
+            });
+            return result;
+        } catch (error) {
+            logger.error(`\u{9879}\u{76EE}\u{5206}\u{6790}\u{5931}\u{8D25}: ${projectPath}`, {
+                error: error.message
+            });
+            throw error;
+        }
+    }
+    function getModuleNames(analysis) {
+        return analysis.modules.map((m)=>m.name);
+    }
+    function extractComments(content) {
+        const comments = new Map();
+        const lines = content.split("\n");
+        let currentComment = "";
+        let commentStartLine = -1;
+        for(let i = 0; i < lines.length; i++){
+            const line = lines[i].trim();
+            if (line.startsWith("/**")) {
+                currentComment = "";
+                commentStartLine = i;
+            } else if (line.startsWith("*") && commentStartLine >= 0) {
+                const commentText = line.replace(/^\*\s?/, "");
+                if (commentText && !commentText.startsWith("@")) currentComment += (currentComment ? " " : "") + commentText;
+            } else if (line.startsWith("*/") && commentStartLine >= 0) {
+                if (currentComment) comments.set(i + 1, currentComment);
+                currentComment = "";
+                commentStartLine = -1;
+            } else if (line.startsWith("//")) {
+                const commentText = line.replace(/^\/\/\s?/, "");
+                if (commentText) comments.set(i + 1, commentText);
+            }
+        }
+        return comments;
+    }
+    function extractAnnotations(content, lineNumber) {
+        const lines = content.split("\n");
+        const annotations = [];
+        for(let i = Math.max(0, lineNumber - 10); i < lineNumber; i++){
+            const line = lines[i]?.trim();
+            if (line && line.startsWith("@")) annotations.push(line);
+        }
+        return annotations;
+    }
+    async function analyzeJavaController(file) {
+        try {
+            const content = await promises_namespaceObject.readFile(file.path, "utf-8");
+            const comments = extractComments(content);
+            const lines = content.split("\n");
+            let className = "";
+            let classDescription = "";
+            let classLineNumber = -1;
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                if (line.includes("class ") && (line.includes("Controller") || line.includes("@RestController") || line.includes("@Controller"))) {
+                    const match = line.match(/class\s+(\w+)/);
+                    if (match) {
+                        className = match[1];
+                        classLineNumber = i;
+                        classDescription = comments.get(i) || className;
+                        break;
+                    }
+                }
+            }
+            if (!className) return null;
+            const methods = [];
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                const methodMatch = line.match(/public\s+(\w+(?:<[^>]+>)?)\s+(\w+)\s*\([^)]*\)/);
+                if (methodMatch) {
+                    const returnType = methodMatch[1];
+                    const methodName = methodMatch[2];
+                    const methodDescription = comments.get(i) || methodName;
+                    const annotations = extractAnnotations(content, i);
+                    let httpMethod = "";
+                    let path = "";
+                    for (const annotation of annotations){
+                        if (annotation.includes("@GetMapping") || annotation.includes("@RequestMapping") && annotation.includes("GET")) httpMethod = "GET";
+                        else if (annotation.includes("@PostMapping") || annotation.includes("@RequestMapping") && annotation.includes("POST")) httpMethod = "POST";
+                        else if (annotation.includes("@PutMapping")) httpMethod = "PUT";
+                        else if (annotation.includes("@DeleteMapping")) httpMethod = "DELETE";
+                        const pathMatch = annotation.match(/["\']([^"']+)["\']/);
+                        if (pathMatch) path = pathMatch[1];
+                    }
+                    const parameters = [];
+                    const paramMatch = line.match(/\(([^)]+)\)/);
+                    if (paramMatch) {
+                        const paramStr = paramMatch[1];
+                        const params = paramStr.split(",").map((p)=>p.trim()).filter((p)=>p);
+                        params.forEach((param, index)=>{
+                            const parts = param.split(/\s+/);
+                            if (parts.length >= 2) {
+                                const type = parts[parts.length - 2];
+                                const name = parts[parts.length - 1];
+                                parameters.push({
+                                    id: String(index + 1),
+                                    propertyType: type,
+                                    propertyName: name,
+                                    required: "\u662F",
+                                    propertyDesc: `${name}\u{53C2}\u{6570}`
+                                });
+                            }
+                        });
+                    }
+                    methods.push({
+                        name: methodName,
+                        description: methodDescription,
+                        parameters,
+                        returnType,
+                        returnDescription: `${methodName}\u{8FD4}\u{56DE}\u{7ED3}\u{679C}`,
+                        httpMethod,
+                        path
+                    });
+                }
+            }
+            return {
+                name: className,
+                description: classDescription,
+                type: "controller",
+                methods,
+                fields: [],
+                annotations: extractAnnotations(content, classLineNumber)
+            };
+        } catch (error) {
+            logger.warn(`\u{5206}\u{6790}Controller\u{6587}\u{4EF6}\u{5931}\u{8D25}: ${file.path}`, {
+                error
+            });
+            return null;
+        }
+    }
+    async function analyzeJavaService(file) {
+        try {
+            const content = await promises_namespaceObject.readFile(file.path, "utf-8");
+            const comments = extractComments(content);
+            const lines = content.split("\n");
+            let className = "";
+            let classDescription = "";
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                if (line.includes("class ") && (line.includes("Service") || line.includes("ServiceImpl"))) {
+                    const match = line.match(/class\s+(\w+)/);
+                    if (match) {
+                        className = match[1];
+                        classDescription = comments.get(i) || className;
+                        break;
+                    }
+                }
+            }
+            if (!className) return null;
+            const methods = [];
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                const methodMatch = line.match(/public\s+(\w+(?:<[^>]+>)?)\s+(\w+)\s*\([^)]*\)/);
+                if (methodMatch) {
+                    const returnType = methodMatch[1];
+                    const methodName = methodMatch[2];
+                    const methodDescription = comments.get(i) || methodName;
+                    methods.push({
+                        name: methodName,
+                        description: methodDescription,
+                        parameters: [],
+                        returnType,
+                        returnDescription: `${methodName}\u{8FD4}\u{56DE}\u{7ED3}\u{679C}`
+                    });
+                }
+            }
+            return {
+                name: className,
+                description: classDescription,
+                type: "service",
+                methods,
+                fields: [],
+                annotations: []
+            };
+        } catch (error) {
+            logger.warn(`\u{5206}\u{6790}Service\u{6587}\u{4EF6}\u{5931}\u{8D25}: ${file.path}`, {
+                error
+            });
+            return null;
+        }
+    }
+    async function analyzeJavaEntity(file) {
+        try {
+            const content = await promises_namespaceObject.readFile(file.path, "utf-8");
+            const comments = extractComments(content);
+            const lines = content.split("\n");
+            let className = "";
+            let classDescription = "";
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                if (line.includes("@Table")) {
+                    const tableMatch = line.match(/name\s*=\s*["\']([^"']+)["\']/);
+                    if (tableMatch) tableMatch[1];
+                }
+                if (line.includes("class ") && (line.includes("Entity") || content.includes("@Entity"))) {
+                    const match = line.match(/class\s+(\w+)/);
+                    if (match) {
+                        className = match[1];
+                        classDescription = comments.get(i) || className;
+                        break;
+                    }
+                }
+            }
+            if (!className) return null;
+            const fields = [];
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                const fieldMatch = line.match(/private\s+(\w+(?:<[^>]+>)?)\s+(\w+);?/);
+                if (fieldMatch) {
+                    const fieldType = fieldMatch[1];
+                    const fieldName = fieldMatch[2];
+                    const fieldDescription = comments.get(i) || fieldName;
+                    const annotations = extractAnnotations(content, i);
+                    fields.push({
+                        name: fieldName,
+                        type: fieldType,
+                        description: fieldDescription,
+                        annotations
+                    });
+                }
+            }
+            return {
+                name: className,
+                description: classDescription,
+                type: "entity",
+                methods: [],
+                fields,
+                annotations: []
+            };
+        } catch (error) {
+            logger.warn(`\u{5206}\u{6790}Entity\u{6587}\u{4EF6}\u{5931}\u{8D25}: ${file.path}`, {
+                error
+            });
+            return null;
+        }
+    }
+    async function analyzeTypeScriptFile(file) {
+        try {
+            const content = await promises_namespaceObject.readFile(file.path, "utf-8");
+            const comments = extractComments(content);
+            const lines = content.split("\n");
+            let className = "";
+            let classDescription = "";
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i].trim();
+                const classMatch = line.match(/(?:export\s+)?(?:class|interface)\s+(\w+)/);
+                if (classMatch) {
+                    className = classMatch[1];
+                    classDescription = comments.get(i) || className;
+                    break;
+                }
+            }
+            if (!className) return null;
+            return {
+                name: className,
+                description: classDescription,
+                type: file.type,
+                methods: [],
+                fields: [],
+                annotations: []
+            };
+        } catch (error) {
+            logger.warn(`\u{5206}\u{6790}TypeScript\u{6587}\u{4EF6}\u{5931}\u{8D25}: ${file.path}`, {
+                error
+            });
+            return null;
+        }
+    }
+    async function analyzeCodeFile(file) {
+        const supportedTypes = [
+            "controller",
+            "service",
+            "entity",
+            "dto"
+        ];
+        if (!supportedTypes.includes(file.type)) return null;
+        const ext = external_path_namespaceObject.extname(file.path).toLowerCase();
+        switch(ext){
+            case ".java":
+                if ("controller" === file.type) return analyzeJavaController(file);
+                if ("service" === file.type) return analyzeJavaService(file);
+                if ("entity" === file.type) return analyzeJavaEntity(file);
+                break;
+            case ".ts":
+            case ".js":
+                return analyzeTypeScriptFile(file);
+            default:
+                break;
+        }
+        return null;
+    }
+    function classInfoToServiceInterface(classInfo, index) {
+        const interfaceDetailList = classInfo.methods.map((method, methodIndex)=>({
+                id: String(methodIndex + 1),
+                functionDescription: method.description,
+                serviceName: classInfo.name,
+                methodName: method.name
+            }));
+        return {
+            id: String(index + 1),
+            serviceType: "controller" === classInfo.type ? "REST" : "Service",
+            serviceEnglishName: classInfo.name,
+            serviceChineseName: classInfo.description,
+            serviceDescription: classInfo.description,
+            interfaceDetailList
+        };
+    }
+    function classInfoToDesignDetail(classInfo) {
+        const interfaceDesignDetailList = classInfo.methods.map((method)=>({
+                functionName: method.name,
+                interfaceDesc: method.description,
+                className: classInfo.name,
+                methodName: method.name,
+                parameterList: method.parameters,
+                returnResultList: [
+                    {
+                        id: "1",
+                        propertyType: method.returnType,
+                        propertyName: "result",
+                        propertyDesc: method.returnDescription
+                    }
+                ],
+                implementLogic: `${method.description}\u{7684}\u{5177}\u{4F53}\u{5B9E}\u{73B0}\u{903B}\u{8F91}`
+            }));
+        return {
+            serviceName: classInfo.name,
+            serviceDesc: classInfo.description,
+            interfaceDesignDetailList
+        };
+    }
+    function classInfoToTableInfo(classInfo, index) {
+        const tableDetailList = classInfo.fields.map((field, fieldIndex)=>({
+                id: String(fieldIndex + 1),
+                fieldName: field.name,
+                fieldType: field.type,
+                fieldDescription: field.description,
+                fieldLength: getFieldLength(field.type)
+            }));
+        return {
+            id: String(index + 1),
+            tableName: camelToSnakeCase(classInfo.name),
+            entityName: classInfo.name,
+            tableDescription: classInfo.description,
+            tableDetailList
+        };
+    }
+    function getFieldLength(fieldType) {
+        const type = fieldType.toLowerCase();
+        if (type.includes("string") || type.includes("varchar")) return "255";
+        if (type.includes("text")) return "65535";
+        if (type.includes("int") || type.includes("integer")) return "11";
+        if (type.includes("long")) return "20";
+        if (type.includes("decimal") || type.includes("double")) return "10,2";
+        else if (type.includes("date") || type.includes("time")) return "-";
+        else return "255";
+    }
+    function camelToSnakeCase(str) {
+        return str.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+    }
+    async function analyzeProjectCode(analysis, options = {}) {
+        logger.info(`\u{5F00}\u{59CB}\u{5206}\u{6790}\u{9879}\u{76EE}\u{4EE3}\u{7801}: ${analysis.projectName}`);
+        let filesToAnalyze = analysis.allFiles;
+        if (options.includeModules && options.includeModules.length > 0) filesToAnalyze = filesToAnalyze.filter((f)=>f.module && options.includeModules.includes(f.module));
+        if (options.excludeModules && options.excludeModules.length > 0) filesToAnalyze = filesToAnalyze.filter((f)=>!f.module || !options.excludeModules.includes(f.module));
+        if (options.includeFileTypes && options.includeFileTypes.length > 0) filesToAnalyze = filesToAnalyze.filter((f)=>options.includeFileTypes.includes(f.type));
+        logger.info(`\u{9700}\u{8981}\u{5206}\u{6790}\u{7684}\u{6587}\u{4EF6}\u{6570}\u{91CF}: ${filesToAnalyze.length}`);
+        const classInfoList = [];
+        for (const file of filesToAnalyze)try {
+            const classInfo = await analyzeCodeFile(file);
+            if (classInfo) classInfoList.push(classInfo);
+        } catch (error) {
+            logger.warn(`\u{5206}\u{6790}\u{6587}\u{4EF6}\u{5931}\u{8D25}: ${file.path}`, {
+                error
+            });
+        }
+        logger.info(`\u{6210}\u{529F}\u{5206}\u{6790}\u{7684}\u{7C7B}\u{6570}\u{91CF}: ${classInfoList.length}`);
+        const serviceInterfaceList = [];
+        const designDetailList = [];
+        const tableInfoList = [];
+        let serviceIndex = 0;
+        let tableIndex = 0;
+        for (const classInfo of classInfoList)if ("controller" === classInfo.type || "service" === classInfo.type) {
+            serviceInterfaceList.push(classInfoToServiceInterface(classInfo, serviceIndex++));
+            designDetailList.push(classInfoToDesignDetail(classInfo));
+        } else if ("entity" === classInfo.type) tableInfoList.push(classInfoToTableInfo(classInfo, tableIndex++));
+        logger.info(`\u{4EE3}\u{7801}\u{5206}\u{6790}\u{5B8C}\u{6210}`, {
+            serviceCount: serviceInterfaceList.length,
+            designCount: designDetailList.length,
+            tableCount: tableInfoList.length
+        });
+        return {
+            serviceInterfaceList,
+            designDetailList,
+            tableInfoList
+        };
+    }
+    class TechSpecStorage {
+        dataDir;
+        projectsFile;
+        chaptersFile;
+        modulesFile;
+        filesFile;
+        constructor(){
+            try {
+                const storageDir = getStorageDir();
+                this.dataDir = external_path_namespaceObject.join(storageDir, "tech-spec");
+                this.projectsFile = external_path_namespaceObject.join(this.dataDir, "projects.json");
+                this.chaptersFile = external_path_namespaceObject.join(this.dataDir, "chapters.json");
+                this.modulesFile = external_path_namespaceObject.join(this.dataDir, "modules.json");
+                this.filesFile = external_path_namespaceObject.join(this.dataDir, "files.json");
+                this.ensureDataDir();
+            } catch (error) {
+                console.warn("TechSpecStorage\u521D\u59CB\u5316\u5931\u8D25\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u8DEF\u5F84:", error);
+                const defaultDir = external_path_namespaceObject.join(process.cwd(), ".aico");
+                this.dataDir = external_path_namespaceObject.join(defaultDir, "tech-spec");
+                this.projectsFile = external_path_namespaceObject.join(this.dataDir, "projects.json");
+                this.chaptersFile = external_path_namespaceObject.join(this.dataDir, "chapters.json");
+                this.modulesFile = external_path_namespaceObject.join(this.dataDir, "modules.json");
+                this.filesFile = external_path_namespaceObject.join(this.dataDir, "files.json");
+                this.ensureDataDir();
+            }
+        }
+        ensureDataDir() {
+            if (!external_fs_namespaceObject.existsSync(this.dataDir)) external_fs_namespaceObject.mkdirSync(this.dataDir, {
+                recursive: true
+            });
+            if (!external_fs_namespaceObject.existsSync(this.projectsFile)) external_fs_namespaceObject.writeFileSync(this.projectsFile, "[]", "utf8");
+            if (!external_fs_namespaceObject.existsSync(this.chaptersFile)) external_fs_namespaceObject.writeFileSync(this.chaptersFile, "[]", "utf8");
+            if (!external_fs_namespaceObject.existsSync(this.modulesFile)) external_fs_namespaceObject.writeFileSync(this.modulesFile, "[]", "utf8");
+            if (!external_fs_namespaceObject.existsSync(this.filesFile)) external_fs_namespaceObject.writeFileSync(this.filesFile, "[]", "utf8");
+        }
+        getNextId(items) {
+            return items.length > 0 ? Math.max(...items.map((i)=>i.id)) + 1 : 1;
+        }
+        readProjects() {
+            try {
+                const data = external_fs_namespaceObject.readFileSync(this.projectsFile, "utf8");
+                return JSON.parse(data).map((p)=>({
+                        ...p,
+                        createdAt: new Date(p.createdAt),
+                        updatedAt: new Date(p.updatedAt),
+                        completedAt: p.completedAt ? new Date(p.completedAt) : void 0
+                    }));
+            } catch (error) {
+                logger.error("Error reading tech spec projects file", error);
+                return [];
+            }
+        }
+        writeProjects(projects) {
+            external_fs_namespaceObject.writeFileSync(this.projectsFile, JSON.stringify(projects, null, 2), "utf8");
+        }
+        async createTechSpecProject(data) {
+            const projects = this.readProjects();
+            const newProject = {
+                id: this.getNextId(projects),
+                uuid: data.uuid,
+                projectName: data.projectName,
+                moduleName: data.moduleName,
+                projectPath: data.projectPath,
+                status: "analyzing",
+                totalModules: data.totalModules,
+                processedModules: 0,
+                totalFiles: data.totalFiles,
+                processedFiles: 0,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            projects.push(newProject);
+            this.writeProjects(projects);
+            return newProject;
+        }
+        async getTechSpecProject(uuid) {
+            const projects = this.readProjects();
+            return projects.find((p)=>p.uuid === uuid) || null;
+        }
+        async getAllTechSpecProjects() {
+            return this.readProjects();
+        }
+        async updateTechSpecProject(uuid, data) {
+            const projects = this.readProjects();
+            const projectIndex = projects.findIndex((p)=>p.uuid === uuid);
+            if (projectIndex >= 0) {
+                projects[projectIndex] = {
+                    ...projects[projectIndex],
+                    ...data,
+                    updatedAt: new Date()
+                };
+                this.writeProjects(projects);
+            }
+        }
+        readChapters() {
+            try {
+                const data = external_fs_namespaceObject.readFileSync(this.chaptersFile, "utf8");
+                return JSON.parse(data).map((c)=>({
+                        ...c,
+                        createdAt: new Date(c.createdAt),
+                        updatedAt: new Date(c.updatedAt)
+                    }));
+            } catch (error) {
+                logger.error("Error reading tech spec chapters file", error);
+                return [];
+            }
+        }
+        writeChapters(chapters) {
+            external_fs_namespaceObject.writeFileSync(this.chaptersFile, JSON.stringify(chapters, null, 2), "utf8");
+        }
+        async createTechSpecChapter(data) {
+            const chapters = this.readChapters();
+            const newChapter = {
+                id: this.getNextId(chapters),
+                uuid: data.uuid,
+                projectUuid: data.projectUuid,
+                chapterType: data.chapterType,
+                chapterTitle: data.chapterTitle,
+                chapterOrder: data.chapterOrder,
+                content: data.content,
+                moduleSource: data.moduleSource,
+                fileCount: data.fileCount,
+                status: "completed",
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            chapters.push(newChapter);
+            this.writeChapters(chapters);
+            return newChapter;
+        }
+        async getTechSpecChapters(projectUuid) {
+            const chapters = this.readChapters();
+            return chapters.filter((c)=>c.projectUuid === projectUuid).sort((a, b)=>a.chapterOrder - b.chapterOrder);
+        }
+        async getTechSpecChaptersByType(projectUuid, chapterType) {
+            const chapters = this.readChapters();
+            return chapters.filter((c)=>c.projectUuid === projectUuid && c.chapterType === chapterType).sort((a, b)=>a.chapterOrder - b.chapterOrder);
+        }
+        async updateTechSpecChapter(uuid, data) {
+            const chapters = this.readChapters();
+            const chapterIndex = chapters.findIndex((c)=>c.uuid === uuid);
+            if (chapterIndex >= 0) {
+                chapters[chapterIndex] = {
+                    ...chapters[chapterIndex],
+                    ...data,
+                    updatedAt: new Date()
+                };
+                this.writeChapters(chapters);
+            }
+        }
+        readModules() {
+            try {
+                const data = external_fs_namespaceObject.readFileSync(this.modulesFile, "utf8");
+                return JSON.parse(data).map((m)=>({
+                        ...m,
+                        createdAt: new Date(m.createdAt),
+                        updatedAt: new Date(m.updatedAt),
+                        startedAt: m.startedAt ? new Date(m.startedAt) : void 0,
+                        completedAt: m.completedAt ? new Date(m.completedAt) : void 0
+                    }));
+            } catch (error) {
+                logger.error("Error reading tech spec modules file", error);
+                return [];
+            }
+        }
+        writeModules(modules) {
+            external_fs_namespaceObject.writeFileSync(this.modulesFile, JSON.stringify(modules, null, 2), "utf8");
+        }
+        async createModuleProcessStatus(data) {
+            const modules = this.readModules();
+            const newModule = {
+                id: this.getNextId(modules),
+                uuid: data.uuid,
+                projectUuid: data.projectUuid,
+                moduleName: data.moduleName,
+                moduleType: data.moduleType,
+                totalFiles: data.totalFiles,
+                processedFiles: 0,
+                status: "pending",
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            modules.push(newModule);
+            this.writeModules(modules);
+            return newModule;
+        }
+        async getModuleProcessStatuses(projectUuid) {
+            const modules = this.readModules();
+            return modules.filter((m)=>m.projectUuid === projectUuid);
+        }
+        async updateModuleProcessStatus(uuid, data) {
+            const modules = this.readModules();
+            const moduleIndex = modules.findIndex((m)=>m.uuid === uuid);
+            if (moduleIndex >= 0) {
+                modules[moduleIndex] = {
+                    ...modules[moduleIndex],
+                    ...data,
+                    updatedAt: new Date()
+                };
+                this.writeModules(modules);
+            }
+        }
+        readFiles() {
+            try {
+                const data = external_fs_namespaceObject.readFileSync(this.filesFile, "utf8");
+                return JSON.parse(data).map((f)=>({
+                        ...f,
+                        createdAt: new Date(f.createdAt),
+                        updatedAt: new Date(f.updatedAt)
+                    }));
+            } catch (error) {
+                logger.error("Error reading tech spec files file", error);
+                return [];
+            }
+        }
+        writeFiles(files) {
+            external_fs_namespaceObject.writeFileSync(this.filesFile, JSON.stringify(files, null, 2), "utf8");
+        }
+        async createFileProcessRecord(data) {
+            const files = this.readFiles();
+            const newFile = {
+                id: this.getNextId(files),
+                uuid: data.uuid,
+                projectUuid: data.projectUuid,
+                moduleUuid: data.moduleUuid,
+                filePath: data.filePath,
+                fileName: data.fileName,
+                fileType: data.fileType,
+                extractedData: data.extractedData,
+                status: "completed",
+                processingTime: data.processingTime,
+                createdAt: new Date(),
+                updatedAt: new Date()
+            };
+            files.push(newFile);
+            this.writeFiles(files);
+            return newFile;
+        }
+        async getFileProcessRecords(projectUuid) {
+            const files = this.readFiles();
+            return files.filter((f)=>f.projectUuid === projectUuid);
+        }
+        async getFileProcessRecordsByModule(moduleUuid) {
+            const files = this.readFiles();
+            return files.filter((f)=>f.moduleUuid === moduleUuid);
+        }
+        async mergeChaptersByType(projectUuid, chapterType) {
+            const chapters = await this.getTechSpecChaptersByType(projectUuid, chapterType);
+            if (0 === chapters.length) return null;
+            switch(chapterType){
+                case "service_interface_list":
+                    return this.mergeServiceInterfaceChapters(chapters);
+                case "interface_design":
+                    return this.mergeInterfaceDesignChapters(chapters);
+                case "database_design":
+                    return this.mergeDatabaseDesignChapters(chapters);
+                case "tech_solution":
+                    return this.mergeTechSolutionChapters(chapters);
+                case "business_exception":
+                    return this.mergeBusinessExceptionChapters(chapters);
+                case "appendix":
+                    return this.mergeAppendixChapters(chapters);
+                default:
+                    return {
+                        content: chapters.map((c)=>JSON.parse(c.content)).join("\n\n"),
+                        totalModules: chapters.length,
+                        totalFiles: chapters.reduce((sum, c)=>sum + c.fileCount, 0)
+                    };
+            }
+        }
+        mergeServiceInterfaceChapters(chapters) {
+            const allInterfaces = [];
+            let idCounter = 1;
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (Array.isArray(chapterData)) {
+                    const interfaces = chapterData.map((item)=>({
+                            ...item,
+                            id: String(idCounter++),
+                            moduleSource: chapter.moduleSource
+                        }));
+                    allInterfaces.push(...interfaces);
+                }
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return allInterfaces;
+        }
+        mergeInterfaceDesignChapters(chapters) {
+            const allDesigns = [];
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (Array.isArray(chapterData)) {
+                    const designs = chapterData.map((item)=>({
+                            ...item,
+                            moduleSource: chapter.moduleSource
+                        }));
+                    allDesigns.push(...designs);
+                }
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return allDesigns;
+        }
+        mergeDatabaseDesignChapters(chapters) {
+            const allTables = [];
+            let idCounter = 1;
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (Array.isArray(chapterData)) {
+                    const tables = chapterData.map((item)=>({
+                            ...item,
+                            id: String(idCounter++),
+                            moduleSource: chapter.moduleSource
+                        }));
+                    allTables.push(...tables);
+                }
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return allTables;
+        }
+        mergeTechSolutionChapters(chapters) {
+            const contents = [];
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (chapterData.content) contents.push(`## ${chapter.moduleSource || "\u6A21\u5757"}\n${chapterData.content}`);
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return {
+                content: contents.join("\n\n")
+            };
+        }
+        mergeBusinessExceptionChapters(chapters) {
+            const contents = [];
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (chapterData.content) contents.push(`## ${chapter.moduleSource || "\u6A21\u5757"}\n${chapterData.content}`);
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return {
+                content: contents.join("\n\n")
+            };
+        }
+        mergeAppendixChapters(chapters) {
+            const allExceptionCodes = [];
+            const allCodeValues = [];
+            let idCounter = 1;
+            for (const chapter of chapters)try {
+                const chapterData = JSON.parse(chapter.content);
+                if (chapterData.exceptionCodeList && Array.isArray(chapterData.exceptionCodeList)) {
+                    const codes = chapterData.exceptionCodeList.map((item)=>({
+                            ...item,
+                            id: String(idCounter++),
+                            moduleSource: chapter.moduleSource
+                        }));
+                    allExceptionCodes.push(...codes);
+                }
+                if (chapterData.codeValueList && Array.isArray(chapterData.codeValueList)) {
+                    const values = chapterData.codeValueList.map((item)=>({
+                            ...item,
+                            id: String(idCounter++),
+                            moduleSource: chapter.moduleSource
+                        }));
+                    allCodeValues.push(...values);
+                }
+            } catch (error) {
+                logger.warn(`\u{89E3}\u{6790}\u{7AE0}\u{8282}\u{5185}\u{5BB9}\u{5931}\u{8D25}: ${chapter.uuid}`, error);
+            }
+            return {
+                exceptionCodeList: allExceptionCodes,
+                codeValueList: allCodeValues
+            };
+        }
+        async cleanupProject(projectUuid) {
+            const chapters = this.readChapters();
+            const filteredChapters = chapters.filter((c)=>c.projectUuid !== projectUuid);
+            this.writeChapters(filteredChapters);
+            const modules = this.readModules();
+            const filteredModules = modules.filter((m)=>m.projectUuid !== projectUuid);
+            this.writeModules(filteredModules);
+            const files = this.readFiles();
+            const filteredFiles = files.filter((f)=>f.projectUuid !== projectUuid);
+            this.writeFiles(filteredFiles);
+            logger.info(`\u{5DF2}\u{6E05}\u{7406}\u{9879}\u{76EE} ${projectUuid} \u{7684}\u{6240}\u{6709}\u{76F8}\u{5173}\u{6570}\u{636E}`);
+        }
+        async getProjectStatistics(projectUuid) {
+            const chapters = await this.getTechSpecChapters(projectUuid);
+            const modules = await this.getModuleProcessStatuses(projectUuid);
+            const files = await this.getFileProcessRecords(projectUuid);
+            const chaptersByType = {
+                project_overview: 0,
+                service_interface_list: 0,
+                interface_design: 0,
+                database_design: 0,
+                tech_solution: 0,
+                business_exception: 0,
+                appendix: 0
+            };
+            chapters.forEach((chapter)=>{
+                chaptersByType[chapter.chapterType]++;
+            });
+            return {
+                totalChapters: chapters.length,
+                completedChapters: chapters.filter((c)=>"completed" === c.status).length,
+                totalModules: modules.length,
+                completedModules: modules.filter((m)=>"completed" === m.status).length,
+                totalFiles: files.length,
+                completedFiles: files.filter((f)=>"completed" === f.status).length,
+                chaptersByType
+            };
+        }
+    }
+    const techSpecStorage = new TechSpecStorage();
+    const techSpecDbOperations = {
+        createTechSpecProject: techSpecStorage.createTechSpecProject.bind(techSpecStorage),
+        getTechSpecProject: techSpecStorage.getTechSpecProject.bind(techSpecStorage),
+        getAllTechSpecProjects: techSpecStorage.getAllTechSpecProjects.bind(techSpecStorage),
+        updateTechSpecProject: techSpecStorage.updateTechSpecProject.bind(techSpecStorage),
+        createTechSpecChapter: techSpecStorage.createTechSpecChapter.bind(techSpecStorage),
+        getTechSpecChapters: techSpecStorage.getTechSpecChapters.bind(techSpecStorage),
+        getTechSpecChaptersByType: techSpecStorage.getTechSpecChaptersByType.bind(techSpecStorage),
+        updateTechSpecChapter: techSpecStorage.updateTechSpecChapter.bind(techSpecStorage),
+        createModuleProcessStatus: techSpecStorage.createModuleProcessStatus.bind(techSpecStorage),
+        getModuleProcessStatuses: techSpecStorage.getModuleProcessStatuses.bind(techSpecStorage),
+        updateModuleProcessStatus: techSpecStorage.updateModuleProcessStatus.bind(techSpecStorage),
+        createFileProcessRecord: techSpecStorage.createFileProcessRecord.bind(techSpecStorage),
+        getFileProcessRecords: techSpecStorage.getFileProcessRecords.bind(techSpecStorage),
+        getFileProcessRecordsByModule: techSpecStorage.getFileProcessRecordsByModule.bind(techSpecStorage),
+        mergeChaptersByType: techSpecStorage.mergeChaptersByType.bind(techSpecStorage),
+        cleanupProject: techSpecStorage.cleanupProject.bind(techSpecStorage),
+        getProjectStatistics: techSpecStorage.getProjectStatistics.bind(techSpecStorage)
+    };
+    const DEFAULT_CONFIG = {
+        maxFilesPerBatch: 50,
+        maxModulesPerChapter: 10,
+        enableParallelProcessing: true,
+        skipEmptyModules: true
+    };
+    class ChapterProcessor {
+        config;
+        constructor(config = {}){
+            this.config = {
+                ...DEFAULT_CONFIG,
+                ...config
+            };
+        }
+        async processFullProject(projectAnalysis, options = {}) {
+            const startTime = Date.now();
+            const projectUuid = (0, external_crypto_namespaceObject.randomUUID)();
+            try {
+                logger.info(`\u{5F00}\u{59CB}\u{5206}\u{7AE0}\u{8282}\u{5904}\u{7406}\u{9879}\u{76EE}: ${projectAnalysis.projectName}`, {
+                    projectUuid
+                });
+                const techSpecProject = await this.createProjectRecord(projectUuid, projectAnalysis, options);
+                const filteredModules = this.filterModules(projectAnalysis.modules, options);
+                if (0 === filteredModules.length) throw new Error("\u6CA1\u6709\u627E\u5230\u7B26\u5408\u6761\u4EF6\u7684\u6A21\u5757");
+                const batches = this.createModuleBatches(filteredModules);
+                logger.info(`\u{9879}\u{76EE}\u{5206}\u{4E3A} ${batches.length} \u{4E2A}\u{6279}\u{6B21}\u{5904}\u{7406}`, {
+                    projectUuid,
+                    totalModules: filteredModules.length,
+                    totalBatches: batches.length
+                });
+                let totalProcessedFiles = 0;
+                let totalServiceInterfaces = 0;
+                let totalDesignDetails = 0;
+                let totalTableInfo = 0;
+                for(let i = 0; i < batches.length; i++){
+                    const batch = batches[i];
+                    logger.info(`\u{5904}\u{7406}\u{6279}\u{6B21} ${i + 1}/${batches.length}`, {
+                        projectUuid,
+                        batchId: batch.batchId,
+                        moduleCount: batch.modules.length,
+                        fileCount: batch.totalFiles
+                    });
+                    try {
+                        const batchResult = await this.processBatch(projectUuid, batch);
+                        totalProcessedFiles += batchResult.processedFiles;
+                        totalServiceInterfaces += batchResult.serviceInterfaceCount;
+                        totalDesignDetails += batchResult.designDetailCount;
+                        totalTableInfo += batchResult.tableInfoCount;
+                        await techSpecDbOperations.updateTechSpecProject(projectUuid, {
+                            processedModules: (i + 1) * this.config.maxModulesPerChapter,
+                            processedFiles: totalProcessedFiles,
+                            status: "generating"
+                        });
+                    } catch (error) {
+                        logger.error(`\u{6279}\u{6B21}\u{5904}\u{7406}\u{5931}\u{8D25}: ${batch.batchId}`, {
+                            error: error.message
+                        });
+                    }
+                }
+                await this.generateProjectOverviewChapter(projectUuid, techSpecProject, projectAnalysis);
+                await techSpecDbOperations.updateTechSpecProject(projectUuid, {
+                    status: "completed",
+                    completedAt: new Date(),
+                    processedModules: filteredModules.length,
+                    processedFiles: totalProcessedFiles
+                });
+                const processingTime = Date.now() - startTime;
+                logger.info(`\u{9879}\u{76EE}\u{5904}\u{7406}\u{5B8C}\u{6210}`, {
+                    projectUuid,
+                    processingTime,
+                    totalModules: filteredModules.length,
+                    totalFiles: totalProcessedFiles
+                });
+                return {
+                    success: true,
+                    projectUuid,
+                    totalChapters: batches.length + 1,
+                    processedChapters: batches.length + 1,
+                    totalModules: filteredModules.length,
+                    processedModules: filteredModules.length,
+                    totalFiles: projectAnalysis.allFiles.length,
+                    processedFiles: totalProcessedFiles,
+                    statistics: {
+                        serviceInterfaceCount: totalServiceInterfaces,
+                        designDetailCount: totalDesignDetails,
+                        tableInfoCount: totalTableInfo,
+                        processingTime
+                    }
+                };
+            } catch (error) {
+                logger.error(`\u{9879}\u{76EE}\u{5904}\u{7406}\u{5931}\u{8D25}: ${projectAnalysis.projectName}`, {
+                    error: error.message,
+                    projectUuid
+                });
+                await techSpecDbOperations.updateTechSpecProject(projectUuid, {
+                    status: "failed"
+                });
+                return {
+                    success: false,
+                    projectUuid,
+                    totalChapters: 0,
+                    processedChapters: 0,
+                    totalModules: 0,
+                    processedModules: 0,
+                    totalFiles: 0,
+                    processedFiles: 0,
+                    errorMessage: error.message,
+                    statistics: {
+                        serviceInterfaceCount: 0,
+                        designDetailCount: 0,
+                        tableInfoCount: 0,
+                        processingTime: Date.now() - startTime
+                    }
+                };
+            }
+        }
+        async createProjectRecord(projectUuid, projectAnalysis, options) {
+            const projectName = options.projectName || projectAnalysis.projectName;
+            const moduleName = options.moduleName || projectName;
+            return await techSpecDbOperations.createTechSpecProject({
+                uuid: projectUuid,
+                projectName,
+                moduleName,
+                projectPath: projectAnalysis.projectPath,
+                totalModules: projectAnalysis.modules.length,
+                totalFiles: projectAnalysis.allFiles.length
+            });
+        }
+        filterModules(modules, options) {
+            let filteredModules = [
+                ...modules
+            ];
+            if (options.includeModules && options.includeModules.length > 0) filteredModules = filteredModules.filter((m)=>options.includeModules.includes(m.name));
+            if (options.excludeModules && options.excludeModules.length > 0) filteredModules = filteredModules.filter((m)=>!options.excludeModules.includes(m.name));
+            if (this.config.skipEmptyModules) filteredModules = filteredModules.filter((m)=>m.files.length > 0);
+            return filteredModules;
+        }
+        createModuleBatches(modules) {
+            const batches = [];
+            let currentBatch = [];
+            let currentFileCount = 0;
+            for (const module of modules){
+                if (currentBatch.length >= this.config.maxModulesPerChapter || currentFileCount + module.files.length > this.config.maxFilesPerBatch) {
+                    if (currentBatch.length > 0) batches.push({
+                        batchId: (0, external_crypto_namespaceObject.randomUUID)(),
+                        modules: [
+                            ...currentBatch
+                        ],
+                        totalFiles: currentFileCount,
+                        chapterType: this.determineChapterType(currentBatch)
+                    });
+                    currentBatch = [];
+                    currentFileCount = 0;
+                }
+                currentBatch.push(module);
+                currentFileCount += module.files.length;
+            }
+            if (currentBatch.length > 0) batches.push({
+                batchId: (0, external_crypto_namespaceObject.randomUUID)(),
+                modules: currentBatch,
+                totalFiles: currentFileCount,
+                chapterType: this.determineChapterType(currentBatch)
+            });
+            return batches;
+        }
+        determineChapterType(modules) {
+            const fileTypes = modules.flatMap((m)=>m.files.map((f)=>f.type));
+            if (fileTypes.includes("controller") || fileTypes.includes("service")) return "service_interface_list";
+            if (fileTypes.includes("entity")) return "database_design";
+            return "interface_design";
+        }
+        async processBatch(projectUuid, batch) {
+            logger.info(`\u{5F00}\u{59CB}\u{5904}\u{7406}\u{6279}\u{6B21}: ${batch.batchId}`, {
+                moduleCount: batch.modules.length,
+                fileCount: batch.totalFiles
+            });
+            const moduleStatuses = [];
+            for (const module of batch.modules){
+                const moduleUuid = (0, external_crypto_namespaceObject.randomUUID)();
+                const moduleStatus = await techSpecDbOperations.createModuleProcessStatus({
+                    uuid: moduleUuid,
+                    projectUuid,
+                    moduleName: module.name,
+                    moduleType: this.detectModuleType(module),
+                    totalFiles: module.files.length
+                });
+                moduleStatuses.push(moduleStatus);
+            }
+            const batchAnalysis = {
+                projectName: `batch-${batch.batchId}`,
+                projectPath: "",
+                modules: batch.modules,
+                allFiles: batch.modules.flatMap((m)=>m.files),
+                statistics: {
+                    totalFiles: batch.totalFiles,
+                    controllerFiles: 0,
+                    serviceFiles: 0,
+                    entityFiles: 0,
+                    dtoFiles: 0,
+                    moduleCount: batch.modules.length
+                }
+            };
+            const codeAnalysis = await analyzeProjectCode(batchAnalysis, {
+                includeFileTypes: [
+                    "controller",
+                    "service",
+                    "entity",
+                    "dto"
+                ]
+            });
+            await this.storeChapterContent(projectUuid, batch, codeAnalysis);
+            for (const moduleStatus of moduleStatuses)await techSpecDbOperations.updateModuleProcessStatus(moduleStatus.uuid, {
+                status: "completed",
+                processedFiles: moduleStatus.totalFiles,
+                completedAt: new Date()
+            });
+            return {
+                processedFiles: batch.totalFiles,
+                serviceInterfaceCount: codeAnalysis.serviceInterfaceList.length,
+                designDetailCount: codeAnalysis.designDetailList.length,
+                tableInfoCount: codeAnalysis.tableInfoList.length
+            };
+        }
+        detectModuleType(module) {
+            const javaFiles = module.files.filter((f)=>f.path.endsWith(".java"));
+            const tsFiles = module.files.filter((f)=>f.path.endsWith(".ts") || f.path.endsWith(".js"));
+            if (javaFiles.length > tsFiles.length) return "java";
+            if (tsFiles.length > 0) return "typescript";
+            return "other";
+        }
+        async storeChapterContent(projectUuid, batch, codeAnalysis) {
+            const moduleNames = batch.modules.map((m)=>m.name).join(", ");
+            if (codeAnalysis.serviceInterfaceList.length > 0) await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "service_interface_list",
+                chapterTitle: `\u{670D}\u{52A1}\u{63A5}\u{53E3}\u{6E05}\u{5355} - ${moduleNames}`,
+                chapterOrder: this.getChapterOrder("service_interface_list"),
+                content: JSON.stringify(codeAnalysis.serviceInterfaceList),
+                moduleSource: moduleNames,
+                fileCount: batch.totalFiles
+            });
+            if (codeAnalysis.designDetailList.length > 0) await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "interface_design",
+                chapterTitle: `\u{63A5}\u{53E3}\u{8BBE}\u{8BA1}\u{8BE6}\u{60C5} - ${moduleNames}`,
+                chapterOrder: this.getChapterOrder("interface_design"),
+                content: JSON.stringify(codeAnalysis.designDetailList),
+                moduleSource: moduleNames,
+                fileCount: batch.totalFiles
+            });
+            if (codeAnalysis.tableInfoList.length > 0) await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "database_design",
+                chapterTitle: `\u{6570}\u{636E}\u{5E93}\u{8BBE}\u{8BA1} - ${moduleNames}`,
+                chapterOrder: this.getChapterOrder("database_design"),
+                content: JSON.stringify(codeAnalysis.tableInfoList),
+                moduleSource: moduleNames,
+                fileCount: batch.totalFiles
+            });
+            const techSolutionContent = this.generateTechSolutionContent(batch, codeAnalysis);
+            if (techSolutionContent) await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "tech_solution",
+                chapterTitle: `\u{6280}\u{672F}\u{65B9}\u{6848} - ${moduleNames}`,
+                chapterOrder: this.getChapterOrder("tech_solution"),
+                content: JSON.stringify(techSolutionContent),
+                moduleSource: moduleNames,
+                fileCount: batch.totalFiles
+            });
+            const businessExceptionContent = this.generateBusinessExceptionContent(batch, codeAnalysis);
+            if (businessExceptionContent) await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "business_exception",
+                chapterTitle: `\u{4E1A}\u{52A1}\u{5F02}\u{5E38}\u{5904}\u{7406} - ${moduleNames}`,
+                chapterOrder: this.getChapterOrder("business_exception"),
+                content: JSON.stringify(businessExceptionContent),
+                moduleSource: moduleNames,
+                fileCount: batch.totalFiles
+            });
+        }
+        getChapterOrder(chapterType) {
+            const orderMap = {
+                project_overview: 1,
+                service_interface_list: 2,
+                interface_design: 3,
+                database_design: 4,
+                tech_solution: 5,
+                business_exception: 6,
+                appendix: 7
+            };
+            return orderMap[chapterType] || 99;
+        }
+        generateTechSolutionContent(batch, codeAnalysis) {
+            const moduleNames = batch.modules.map((m)=>m.name).join(", ");
+            return {
+                content: `
+## ${moduleNames} \u{6A21}\u{5757}\u{6280}\u{672F}\u{65B9}\u{6848}
+
+### \u{6D41}\u{91CF}\u{4F30}\u{7B97}
+\u{6839}\u{636E} ${moduleNames} \u{6A21}\u{5757}\u{7684} ${codeAnalysis.serviceInterfaceList.length} \u{4E2A}\u{670D}\u{52A1}\u{63A5}\u{53E3}\u{FF0C}\u{9884}\u{4F30}\u{65E5}\u{5747}\u{8BF7}\u{6C42}\u{91CF}\u{3002}
+
+### \u{6280}\u{672F}\u{67B6}\u{6784}
+\u{6A21}\u{5757}\u{5305}\u{542B} ${codeAnalysis.tableInfoList.length} \u{4E2A}\u{6570}\u{636E}\u{8868}\u{FF0C}${codeAnalysis.designDetailList.length} \u{4E2A}\u{63A5}\u{53E3}\u{8BBE}\u{8BA1}\u{3002}
+
+### \u{4E2D}\u{95F4}\u{4EF6}\u{9009}\u{578B}
+\u{57FA}\u{4E8E}\u{6A21}\u{5757}\u{7279}\u{70B9}\u{FF0C}\u{5EFA}\u{8BAE}\u{4F7F}\u{7528}\u{76F8}\u{5E94}\u{7684}\u{4E2D}\u{95F4}\u{4EF6}\u{8FDB}\u{884C}\u{652F}\u{6491}\u{3002}
+            `.trim()
+            };
+        }
+        generateBusinessExceptionContent(batch, codeAnalysis) {
+            const moduleNames = batch.modules.map((m)=>m.name).join(", ");
+            return {
+                content: `
+## ${moduleNames} \u{6A21}\u{5757}\u{4E1A}\u{52A1}\u{5F02}\u{5E38}\u{5904}\u{7406}
+
+### \u{5F02}\u{5E38}\u{5206}\u{7C7B}
+\u{6A21}\u{5757}\u{4E2D}\u{7684}\u{4E1A}\u{52A1}\u{5F02}\u{5E38}\u{6309}\u{7167}\u{7EDF}\u{4E00}\u{7684}\u{5206}\u{7C7B}\u{6807}\u{51C6}\u{8FDB}\u{884C}\u{5904}\u{7406}\u{3002}
+
+### \u{5F02}\u{5E38}\u{5904}\u{7406}\u{7B56}\u{7565}
+\u{9488}\u{5BF9} ${codeAnalysis.serviceInterfaceList.length} \u{4E2A}\u{670D}\u{52A1}\u{63A5}\u{53E3}\u{7684}\u{5F02}\u{5E38}\u{5904}\u{7406}\u{7B56}\u{7565}\u{3002}
+
+### \u{5F02}\u{5E38}\u{7801}\u{5B9A}\u{4E49}
+\u{6A21}\u{5757}\u{76F8}\u{5173}\u{7684}\u{5F02}\u{5E38}\u{7801}\u{5B9A}\u{4E49}\u{548C}\u{5904}\u{7406}\u{89C4}\u{8303}\u{3002}
+            `.trim()
+            };
+        }
+        async generateProjectOverviewChapter(projectUuid, project, projectAnalysis) {
+            const statistics = await techSpecDbOperations.getProjectStatistics(projectUuid);
+            const overviewContent = {
+                projectName: project.projectName,
+                moduleName: project.moduleName,
+                projectPath: project.projectPath,
+                totalModules: statistics.totalModules,
+                totalFiles: statistics.totalFiles,
+                summary: `
+\u{9879}\u{76EE} ${project.projectName} \u{5305}\u{542B} ${statistics.totalModules} \u{4E2A}\u{4E1A}\u{52A1}\u{6A21}\u{5757}\u{FF0C}
+\u{5171}\u{8BA1} ${statistics.totalFiles} \u{4E2A}\u{4EE3}\u{7801}\u{6587}\u{4EF6}\u{3002}
+
+\u{901A}\u{8FC7}\u{81EA}\u{52A8}\u{5316}\u{5206}\u{6790}\u{FF0C}\u{751F}\u{6210}\u{4E86} ${statistics.totalChapters} \u{4E2A}\u{6280}\u{672F}\u{89C4}\u{683C}\u{7AE0}\u{8282}\u{FF0C}
+\u{5305}\u{62EC}\u{670D}\u{52A1}\u{63A5}\u{53E3}\u{6E05}\u{5355}\u{3001}\u{63A5}\u{53E3}\u{8BBE}\u{8BA1}\u{8BE6}\u{60C5}\u{3001}\u{6570}\u{636E}\u{5E93}\u{8BBE}\u{8BA1}\u{7B49}\u{5B8C}\u{6574}\u{5185}\u{5BB9}\u{3002}
+            `.trim(),
+                moduleList: projectAnalysis.modules.map((m)=>({
+                        name: m.name,
+                        path: m.relativePath,
+                        fileCount: m.files.length
+                    }))
+            };
+            await techSpecDbOperations.createTechSpecChapter({
+                uuid: (0, external_crypto_namespaceObject.randomUUID)(),
+                projectUuid,
+                chapterType: "project_overview",
+                chapterTitle: "\u9879\u76EE\u6982\u8FF0",
+                chapterOrder: this.getChapterOrder("project_overview"),
+                content: JSON.stringify(overviewContent),
+                moduleSource: "all",
+                fileCount: projectAnalysis.allFiles.length
+            });
+        }
+    }
+    const DEFAULT_MERGE_CONFIG = {
+        includeEmptyChapters: false,
+        generateDefaultContent: true,
+        maxItemsPerChapter: 1000,
+        enableChapterSummary: true
+    };
+    class DocumentMerger {
+        config;
+        constructor(config = {}){
+            this.config = {
+                ...DEFAULT_MERGE_CONFIG,
+                ...config
+            };
+        }
+        async mergeAndRenderDocument(projectUuid, outputDir) {
+            const startTime = Date.now();
+            try {
+                const project = await techSpecDbOperations.getTechSpecProject(projectUuid);
+                if (!project) throw new Error(`\u{9879}\u{76EE}\u{4E0D}\u{5B58}\u{5728}: ${projectUuid}`);
+                const statistics = await techSpecDbOperations.getProjectStatistics(projectUuid);
+                const techSpecData = await this.mergeAllChapters(projectUuid, project);
+                const finalOutputDir = outputDir || getTechSpecOutputDir(project.projectPath);
+                const renderResult = await renderTechSpecDoc(techSpecData, finalOutputDir);
+                if (!renderResult.success) throw new Error(renderResult.error || "\u6587\u6863\u6E32\u67D3\u5931\u8D25");
+                await techSpecDbOperations.updateTechSpecProject(projectUuid, {
+                    status: "completed",
+                    completedAt: new Date()
+                });
+                return {
+                    success: true,
+                    outputPath: renderResult.outputPath,
+                    techSpecData,
+                    statistics: {
+                        totalChapters: statistics.totalChapters,
+                        mergedChapters: statistics.completedChapters,
+                        totalServiceInterfaces: techSpecData.serviceInterfaceList.length,
+                        totalDesignDetails: techSpecData.designDetailList.length,
+                        totalTables: techSpecData.tableInfoList.length,
+                        processingTime: Date.now() - startTime
+                    }
+                };
+            } catch (error) {
+                await techSpecDbOperations.updateTechSpecProject(projectUuid, {
+                    status: "failed"
+                });
+                return {
+                    success: false,
+                    statistics: {
+                        totalChapters: 0,
+                        mergedChapters: 0,
+                        totalServiceInterfaces: 0,
+                        totalDesignDetails: 0,
+                        totalTables: 0,
+                        processingTime: Date.now() - startTime
+                    },
+                    errorMessage: error.message
+                };
+            }
+        }
+        async mergeAllChapters(projectUuid, project) {
+            const now = new Date();
+            const techSpecData = {
+                projectName: project.projectName,
+                moduleName: project.moduleName,
+                year: String(now.getFullYear()),
+                month: String(now.getMonth() + 1).padStart(2, "0"),
+                referDoc: "\u9879\u76EE\u4EE3\u7801\u81EA\u52A8\u5206\u6790\u751F\u6210",
+                serviceInterfaceList: [],
+                designDetailList: [],
+                tableInfoList: []
+            };
+            const serviceInterfaces = await techSpecDbOperations.mergeChaptersByType(projectUuid, "service_interface_list");
+            if (serviceInterfaces && Array.isArray(serviceInterfaces)) techSpecData.serviceInterfaceList = this.limitAndReindex(serviceInterfaces, this.config.maxItemsPerChapter);
+            const designDetails = await techSpecDbOperations.mergeChaptersByType(projectUuid, "interface_design");
+            if (designDetails && Array.isArray(designDetails)) techSpecData.designDetailList = designDetails.slice(0, this.config.maxItemsPerChapter);
+            const tableInfos = await techSpecDbOperations.mergeChaptersByType(projectUuid, "database_design");
+            if (tableInfos && Array.isArray(tableInfos)) techSpecData.tableInfoList = this.limitAndReindex(tableInfos, this.config.maxItemsPerChapter);
+            const techSolution = await techSpecDbOperations.mergeChaptersByType(projectUuid, "tech_solution");
+            if (techSolution && techSolution.content) techSpecData.techSolution = {
+                content: techSolution.content
+            };
+            else if (this.config.generateDefaultContent) techSpecData.techSolution = this.generateDefaultTechSolution(techSpecData);
+            const businessException = await techSpecDbOperations.mergeChaptersByType(projectUuid, "business_exception");
+            if (businessException && businessException.content) techSpecData.businessException = {
+                content: businessException.content
+            };
+            else if (this.config.generateDefaultContent) techSpecData.businessException = this.generateDefaultBusinessException();
+            const appendix = await techSpecDbOperations.mergeChaptersByType(projectUuid, "appendix");
+            if (appendix) techSpecData.appendix = {
+                exceptionCodeList: appendix.exceptionCodeList || [],
+                codeValueList: appendix.codeValueList || []
+            };
+            else if (this.config.generateDefaultContent) techSpecData.appendix = this.generateDefaultAppendix();
+            return techSpecData;
+        }
+        limitAndReindex(items, maxItems) {
+            const limitedItems = items.slice(0, maxItems);
+            return limitedItems.map((item, index)=>({
+                    ...item,
+                    id: String(index + 1)
+                }));
+        }
+        generateDefaultTechSolution(techSpecData) {
+            const serviceCount = techSpecData.serviceInterfaceList.length;
+            const tableCount = techSpecData.tableInfoList.length;
+            return {
+                content: `\u{6839}\u{636E}\u{9879}\u{76EE}\u{89C4}\u{6A21}\u{5206}\u{6790}\u{FF0C}\u{7CFB}\u{7EDF}\u{5305}\u{542B} ${serviceCount} \u{4E2A}\u{670D}\u{52A1}\u{63A5}\u{53E3}\u{FF0C}${tableCount} \u{4E2A}\u{6570}\u{636E}\u{8868}\u{3002}\u{5EFA}\u{8BAE}\u{91C7}\u{7528}\u{5FAE}\u{670D}\u{52A1}\u{67B6}\u{6784}\u{3002}`
+            };
+        }
+        generateDefaultBusinessException() {
+            return {
+                content: `\u{9879}\u{76EE}\u{91C7}\u{7528}\u{7EDF}\u{4E00}\u{5F02}\u{5E38}\u{5904}\u{7406}\u{673A}\u{5236}\u{FF0C}\u{5305}\u{62EC}\u{7CFB}\u{7EDF}\u{5F02}\u{5E38}\u{548C}\u{4E1A}\u{52A1}\u{5F02}\u{5E38}\u{4E24}\u{5927}\u{7C7B}\u{3002}`
+            };
+        }
+        generateDefaultAppendix() {
+            return {
+                exceptionCodeList: [
+                    {
+                        id: "1",
+                        exceptionCode: "SYS0001",
+                        exceptionDescription: "\u7CFB\u7EDF\u5185\u90E8\u9519\u8BEF"
+                    }
+                ],
+                codeValueList: [
+                    {
+                        id: "1",
+                        propertyName: "\u7528\u6237\u72B6\u6001",
+                        codeValue: "1-\u6B63\u5E38\uFF0C0-\u7981\u7528"
+                    }
+                ]
+            };
+        }
+        async getProjectProgress(projectUuid) {
+            const project = await techSpecDbOperations.getTechSpecProject(projectUuid);
+            const statistics = await techSpecDbOperations.getProjectStatistics(projectUuid);
+            if (!project) throw new Error(`\u{9879}\u{76EE}\u{4E0D}\u{5B58}\u{5728}: ${projectUuid}`);
+            const totalSteps = 7;
+            const completedSteps = statistics.completedChapters;
+            const percentage = Math.round(completedSteps / totalSteps * 100);
+            let currentStep = "\u51C6\u5907\u4E2D";
+            if ("analyzing" === project.status) currentStep = "\u5206\u6790\u9879\u76EE\u7ED3\u6784";
+            else if ("generating" === project.status) currentStep = `\u{751F}\u{6210}\u{7AE0}\u{8282}\u{5185}\u{5BB9} (${completedSteps}/${totalSteps})`;
+            else if ("completed" === project.status) currentStep = "\u5DF2\u5B8C\u6210";
+            else if ("failed" === project.status) currentStep = "\u5904\u7406\u5931\u8D25";
+            return {
+                project,
+                statistics,
+                progress: {
+                    totalSteps,
+                    completedSteps,
+                    currentStep,
+                    percentage
+                }
+            };
+        }
+    }
     const TableFieldDetailSchema = objectType({
         id: stringType().describe("\u5E8F\u53F7"),
         fieldName: stringType().describe("\u5B57\u6BB5\u540D"),
@@ -11724,7 +13278,430 @@ ${requirement_description}
             }
         }
     };
+    const analyzeLargeProjectTool = {
+        name: "analyze_large_project",
+        description: "\u5206\u6790\u5927\u578B\u9879\u76EE\u5E76\u5206\u7AE0\u8282\u5B58\u50A8\u5230\u6570\u636E\u5E93\uFF0C\u652F\u6301\u5904\u7406\u5305\u542B\u6570\u767E\u4E2A\u6587\u4EF6\u7684\u5927\u578B\u9879\u76EE\u3002\u9002\u7528\u4E8E\u4F01\u4E1A\u7EA7\u9879\u76EE\u7684\u5B8C\u6574\u6280\u672F\u89C4\u683C\u8BF4\u660E\u4E66\u751F\u6210\u3002",
+        inputSchema: {
+            projectPath: stringType().min(1).describe(PROJECT_PATH_DESCRIPTION),
+            projectName: stringType().optional().describe("\u9879\u76EE\u540D\u79F0\uFF0C\u5982\u4E0D\u63D0\u4F9B\u5219\u4F7F\u7528\u76EE\u5F55\u540D"),
+            moduleName: stringType().optional().describe("\u6A21\u5757\u540D\u79F0\uFF0C\u5982\u4E0D\u63D0\u4F9B\u5219\u4F7F\u7528\u9879\u76EE\u540D"),
+            includeModules: arrayType(stringType()).optional().describe("\u8981\u5305\u542B\u7684\u6A21\u5757\u5217\u8868\uFF0C\u5982\u4E0D\u63D0\u4F9B\u5219\u5305\u542B\u6240\u6709\u6A21\u5757"),
+            excludeModules: arrayType(stringType()).optional().describe("\u8981\u6392\u9664\u7684\u6A21\u5757\u5217\u8868"),
+            maxFilesPerBatch: numberType().optional().default(50).describe("\u6BCF\u6279\u5904\u7406\u7684\u6700\u5927\u6587\u4EF6\u6570"),
+            maxModulesPerChapter: numberType().optional().default(10).describe("\u6BCF\u7AE0\u8282\u7684\u6700\u5927\u6A21\u5757\u6570")
+        },
+        handler: async (args)=>{
+            try {
+                const { projectPath, projectName, moduleName, includeModules, excludeModules, maxFilesPerBatch = 50, maxModulesPerChapter = 10 } = args;
+                if (!projectPath) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: "\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1AprojectPath"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+                logger.info(`\u{5F00}\u{59CB}\u{5206}\u{6790}\u{5927}\u{578B}\u{9879}\u{76EE}: ${projectPath}`);
+                const projectAnalysis = await analyzeProject(projectPath);
+                const chapterProcessor = new ChapterProcessor({
+                    maxFilesPerBatch,
+                    maxModulesPerChapter,
+                    enableParallelProcessing: true,
+                    skipEmptyModules: true
+                });
+                const result = await chapterProcessor.processFullProject(projectAnalysis, {
+                    projectName,
+                    moduleName,
+                    includeModules,
+                    excludeModules
+                });
+                if (result.success) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "\u5927\u578B\u9879\u76EE\u5206\u6790\u5B8C\u6210\uFF0C\u7AE0\u8282\u5DF2\u5B58\u50A8\u5230\u6570\u636E\u5E93",
+                                data: {
+                                    projectUuid: result.projectUuid,
+                                    projectAnalysis: {
+                                        projectName: projectAnalysis.projectName,
+                                        moduleCount: projectAnalysis.modules.length,
+                                        totalFiles: projectAnalysis.statistics.totalFiles,
+                                        modules: getModuleNames(projectAnalysis)
+                                    },
+                                    processingResult: {
+                                        totalChapters: result.totalChapters,
+                                        processedChapters: result.processedChapters,
+                                        totalModules: result.totalModules,
+                                        processedModules: result.processedModules,
+                                        totalFiles: result.totalFiles,
+                                        processedFiles: result.processedFiles
+                                    },
+                                    statistics: result.statistics,
+                                    nextStep: `\u{8C03}\u{7528} render_final_document \u{5DE5}\u{5177}\u{FF0C}\u{4F7F}\u{7528} projectUuid: ${result.projectUuid} \u{751F}\u{6210}\u{6700}\u{7EC8}\u{6587}\u{6863}`
+                                }
+                            })
+                        }
+                    ]
+                };
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: result.errorMessage || "\u5927\u578B\u9879\u76EE\u5206\u6790\u5931\u8D25",
+                                data: {
+                                    projectUuid: result.projectUuid,
+                                    statistics: result.statistics
+                                }
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            } catch (error) {
+                logger.error("\u5927\u578B\u9879\u76EE\u5206\u6790\u5931\u8D25", {
+                    error: error.message
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: error.message || "\u5206\u6790\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+    };
+    const renderFinalDocumentTool = {
+        name: "render_final_document",
+        description: "\u5C06\u6570\u636E\u5E93\u4E2D\u5B58\u50A8\u7684\u7AE0\u8282\u5408\u5E76\u5E76\u6E32\u67D3\u4E3A\u6700\u7EC8\u7684\u6280\u672F\u89C4\u683C\u8BF4\u660E\u4E66Word\u6587\u6863\u3002\u7528\u4E8E\u5927\u578B\u9879\u76EE\u7684\u6700\u7EC8\u6587\u6863\u751F\u6210\u3002",
+        inputSchema: {
+            projectUuid: stringType().min(1).describe("\u9879\u76EEUUID\uFF0C\u7531 analyze_large_project \u5DE5\u5177\u8FD4\u56DE"),
+            outputDir: stringType().optional().describe("\u8F93\u51FA\u76EE\u5F55\uFF0C\u5982\u4E0D\u63D0\u4F9B\u5219\u4F7F\u7528\u9879\u76EE\u9ED8\u8BA4\u76EE\u5F55"),
+            includeEmptyChapters: booleanType().optional().default(false).describe("\u662F\u5426\u5305\u542B\u7A7A\u7AE0\u8282"),
+            generateDefaultContent: booleanType().optional().default(true).describe("\u662F\u5426\u4E3A\u7A7A\u7AE0\u8282\u751F\u6210\u9ED8\u8BA4\u5185\u5BB9"),
+            maxItemsPerChapter: numberType().optional().default(1000).describe("\u6BCF\u7AE0\u8282\u6700\u5927\u6761\u76EE\u6570")
+        },
+        handler: async (args)=>{
+            try {
+                const { projectUuid, outputDir, includeEmptyChapters = false, generateDefaultContent = true, maxItemsPerChapter = 1000 } = args;
+                if (!projectUuid) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: "\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1AprojectUuid"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+                logger.info(`\u{5F00}\u{59CB}\u{6E32}\u{67D3}\u{6700}\u{7EC8}\u{6587}\u{6863}: ${projectUuid}`);
+                const project = await techSpecDbOperations.getTechSpecProject(projectUuid);
+                if (!project) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: `\u{9879}\u{76EE}\u{4E0D}\u{5B58}\u{5728}: ${projectUuid}`
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+                const documentMerger = new DocumentMerger({
+                    includeEmptyChapters,
+                    generateDefaultContent,
+                    maxItemsPerChapter,
+                    enableChapterSummary: true
+                });
+                const result = await documentMerger.mergeAndRenderDocument(projectUuid, outputDir);
+                if (result.success) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "\u6280\u672F\u89C4\u683C\u8BF4\u660E\u4E66\u751F\u6210\u6210\u529F",
+                                data: {
+                                    projectUuid,
+                                    outputPath: result.outputPath,
+                                    projectInfo: {
+                                        projectName: project.projectName,
+                                        moduleName: project.moduleName,
+                                        projectPath: project.projectPath
+                                    },
+                                    statistics: result.statistics,
+                                    techSpecSummary: {
+                                        serviceInterfaceCount: result.statistics.totalServiceInterfaces,
+                                        designDetailCount: result.statistics.totalDesignDetails,
+                                        tableCount: result.statistics.totalTables,
+                                        chapterCount: result.statistics.totalChapters
+                                    }
+                                }
+                            })
+                        }
+                    ]
+                };
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: result.errorMessage || "\u6587\u6863\u6E32\u67D3\u5931\u8D25",
+                                data: {
+                                    projectUuid,
+                                    statistics: result.statistics
+                                }
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            } catch (error) {
+                logger.error("\u6587\u6863\u6E32\u67D3\u5931\u8D25", {
+                    error: error.message
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: error.message || "\u6E32\u67D3\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+    };
+    const getProjectProgressTool = {
+        name: "get_project_progress",
+        description: "\u83B7\u53D6\u5927\u578B\u9879\u76EE\u5904\u7406\u8FDB\u5EA6\u548C\u72B6\u6001\u4FE1\u606F\u3002\u7528\u4E8E\u76D1\u63A7\u9879\u76EE\u5206\u6790\u548C\u6587\u6863\u751F\u6210\u7684\u8FDB\u5EA6\u3002",
+        inputSchema: {
+            projectUuid: stringType().min(1).describe("\u9879\u76EEUUID")
+        },
+        handler: async (args)=>{
+            try {
+                const { projectUuid } = args;
+                if (!projectUuid) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: "\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1AprojectUuid"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+                const documentMerger = new DocumentMerger();
+                const progressInfo = await documentMerger.getProjectProgress(projectUuid);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "\u9879\u76EE\u8FDB\u5EA6\u83B7\u53D6\u6210\u529F",
+                                data: {
+                                    projectUuid,
+                                    project: {
+                                        projectName: progressInfo.project.projectName,
+                                        moduleName: progressInfo.project.moduleName,
+                                        status: progressInfo.project.status,
+                                        createdAt: progressInfo.project.createdAt,
+                                        updatedAt: progressInfo.project.updatedAt,
+                                        completedAt: progressInfo.project.completedAt
+                                    },
+                                    progress: progressInfo.progress,
+                                    statistics: progressInfo.statistics,
+                                    isCompleted: "completed" === progressInfo.project.status,
+                                    canRender: progressInfo.statistics.completedChapters > 0
+                                }
+                            })
+                        }
+                    ]
+                };
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: error.message || "\u83B7\u53D6\u8FDB\u5EA6\u5931\u8D25"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+    };
+    const listTechSpecProjectsTool = {
+        name: "list_tech_spec_projects",
+        description: "\u5217\u51FA\u6240\u6709\u6280\u672F\u89C4\u683C\u8BF4\u660E\u4E66\u9879\u76EE\u53CA\u5176\u72B6\u6001\u3002\u7528\u4E8E\u67E5\u770B\u5386\u53F2\u9879\u76EE\u548C\u7BA1\u7406\u9879\u76EE\u3002",
+        inputSchema: {
+            status: stringType().optional().describe("\u8FC7\u6EE4\u72B6\u6001\uFF1Aanalyzing, generating, completed, failed"),
+            limit: numberType().optional().default(20).describe("\u8FD4\u56DE\u6570\u91CF\u9650\u5236")
+        },
+        handler: async (args)=>{
+            try {
+                const { status, limit = 20 } = args;
+                let projects = await techSpecDbOperations.getAllTechSpecProjects();
+                if (status) projects = projects.filter((p)=>p.status === status);
+                projects.sort((a, b)=>b.createdAt.getTime() - a.createdAt.getTime());
+                projects = projects.slice(0, limit);
+                const projectsWithStats = await Promise.all(projects.map(async (project)=>{
+                    try {
+                        const statistics = await techSpecDbOperations.getProjectStatistics(project.uuid);
+                        return {
+                            ...project,
+                            statistics
+                        };
+                    } catch (error) {
+                        return {
+                            ...project,
+                            statistics: null
+                        };
+                    }
+                }));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `\u{627E}\u{5230} ${projectsWithStats.length} \u{4E2A}\u{9879}\u{76EE}`,
+                                data: {
+                                    projects: projectsWithStats.map((p)=>({
+                                            uuid: p.uuid,
+                                            projectName: p.projectName,
+                                            moduleName: p.moduleName,
+                                            status: p.status,
+                                            totalModules: p.totalModules,
+                                            processedModules: p.processedModules,
+                                            totalFiles: p.totalFiles,
+                                            processedFiles: p.processedFiles,
+                                            createdAt: p.createdAt,
+                                            updatedAt: p.updatedAt,
+                                            completedAt: p.completedAt,
+                                            statistics: p.statistics
+                                        })),
+                                    totalCount: projectsWithStats.length
+                                }
+                            })
+                        }
+                    ]
+                };
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: error.message || "\u83B7\u53D6\u9879\u76EE\u5217\u8868\u5931\u8D25"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+    };
+    const analyzeProjectStructureTool = {
+        name: "analyze_project_structure",
+        description: "\u4EC5\u5206\u6790\u9879\u76EE\u7ED3\u6784\uFF0C\u4E0D\u751F\u6210\u6587\u6863\u3002\u7528\u4E8E\u4E86\u89E3\u9879\u76EE\u7684\u6A21\u5757\u548C\u6587\u4EF6\u7EC4\u7EC7\u60C5\u51B5\u3002",
+        inputSchema: {
+            projectPath: stringType().min(1).describe(PROJECT_PATH_DESCRIPTION)
+        },
+        handler: async (args)=>{
+            try {
+                const { projectPath } = args;
+                if (!projectPath) return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: "\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570\uFF1AprojectPath"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+                const analysis = await analyzeProject(projectPath);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "\u9879\u76EE\u7ED3\u6784\u5206\u6790\u5B8C\u6210",
+                                data: {
+                                    projectName: analysis.projectName,
+                                    projectPath: analysis.projectPath,
+                                    statistics: analysis.statistics,
+                                    modules: analysis.modules.map((m)=>({
+                                            name: m.name,
+                                            relativePath: m.relativePath,
+                                            fileCount: m.files.length,
+                                            fileTypes: {
+                                                controller: m.files.filter((f)=>"controller" === f.type).length,
+                                                service: m.files.filter((f)=>"service" === f.type).length,
+                                                entity: m.files.filter((f)=>"entity" === f.type).length,
+                                                dto: m.files.filter((f)=>"dto" === f.type).length,
+                                                other: m.files.filter((f)=>"other" === f.type).length
+                                            }
+                                        })),
+                                    availableModules: getModuleNames(analysis)
+                                }
+                            })
+                        }
+                    ]
+                };
+            } catch (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                message: error.message || "\u9879\u76EE\u7ED3\u6784\u5206\u6790\u5931\u8D25"
+                            })
+                        }
+                    ],
+                    isError: true
+                };
+            }
+        }
+    };
     const techSpecGeneratorTools = [
+        analyzeLargeProjectTool,
+        renderFinalDocumentTool,
+        getProjectProgressTool,
+        listTechSpecProjectsTool,
+        analyzeProjectStructureTool,
         analyzeProjectContextTool,
         collectServiceInterfacesTool,
         generateInterfaceDesignsTool,