pug-site-core 3.0.0 → 3.0.1

package/lib/ai/aiRouter.js

@@ -1,300 +1,628 @@
-import express from 'express';
-import fs from 'fs-extra';
+import { ChatOpenAI } from "@langchain/openai";
+import { PromptTemplate } from "@langchain/core/prompts";
+import { StructuredOutputParser } from "@langchain/core/output_parsers";
+import { z } from "zod";
+import { Document } from "@langchain/core/documents";
+import { DirectoryLoader } from "langchain/document_loaders/fs/directory";
+import { TextLoader } from "langchain/document_loaders/fs/text";
+import { RecursiveCharacterTextSplitter } from "langchain/text_splitter";
+import { FileManagementToolkit } from "@langchain/community/agent_toolkits";
+import { VectorStore } from "@langchain/core/vectorstores";
+import { MemoryVectorStore } from "langchain/vectorstores/memory";
+import { OpenAIEmbeddings } from "@langchain/openai";
+import { RunnableSequence } from "@langchain/core/runnables";
+import fs from 'fs/promises';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const router = express.Router();
 
-// 获取template-debug目录的绝对路径
-const templateDebugPath = path.join(process.cwd(), 'template-debug');
+// DeepSeek API 配置
+const llm = new ChatOpenAI({
+  model: "deepseek-chat",
+  temperature: 0.2, // 降低随机性，提高代码修改的准确性
+  openAIApiKey: process.env.DEEPSEEK_API_KEY || "your-api-key-here",
+  configuration: {
+    baseURL: "https://api.deepseek.com/v1"
+  }
+});
 
-// 检查是否设置了OpenAI API密钥
-const hasOpenAIKey = !!process.env.OPENAI_API_KEY;
+// 定义结构化输出模式
+const LocationSchema = z.object({
+  startLine: z.number().describe("修改开始行号"),
+  endLine: z.number().describe("修改结束行号"),
+  reason: z.string().describe("选择这个位置的原因"),
+  context: z.string().describe("相关的代码上下文")
+});
 
-let model = null;
-let agentExecutor = null;
+const AnalysisResultSchema = z.object({
+  locations: z.array(LocationSchema).describe("可能的修改位置列表"),
+  analysis: z.string().describe("整体分析说明"),
+  confidence: z.number().min(0).max(1).describe("分析结果的置信度")
+});
 
-// 动态导入langchain模块并初始化
-async function initializeAI() {
-    if (!hasOpenAIKey) {
-        console.warn('警告: 未设置OPENAI_API_KEY环境变量，AI功能将不可用');
-        return false;
+const ModificationResultSchema = z.object({
+  modifiedCode: z.string().describe("修改后的代码"),
+  explanation: z.string().describe("修改说明"),
+  changes: z.array(z.object({
+    type: z.enum(["added", "modified", "deleted"]).describe("修改类型"),
+    description: z.string().describe("具体的改动描述"),
+    lineNumbers: z.array(z.number()).describe("涉及的行号")
+  })).describe("修改详情列表"),
+  riskLevel: z.enum(["low", "medium", "high"]).describe("修改风险等级")
+});
+
+/**
+ * 使用LangChain优化的代码修改 Agent 类
+ */
+class EnhancedCodeModificationAgent {
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.fileManagementToolkit = new FileManagementToolkit({ 
+      rootDir: this.projectRoot 
+    });
+    this.vectorStore = null;
+    this.embeddings = new OpenAIEmbeddings({
+      openAIApiKey: process.env.OPENAI_API_KEY
+    });
+    this.textSplitter = new RecursiveCharacterTextSplitter({
+      chunkSize: 1000,
+      chunkOverlap: 200,
+    });
+    
+    // 设置结构化输出解析器
+    this.analysisParser = StructuredOutputParser.fromZodSchema(AnalysisResultSchema);
+    this.modificationParser = StructuredOutputParser.fromZodSchema(ModificationResultSchema);
+  }
+
+  /**
+   * 初始化项目上下文向量存储
+   */
+  async initializeProjectContext() {
+    try {
+      const loader = new DirectoryLoader(this.projectRoot, {
+        ".js": (path) => new TextLoader(path),
+        ".ts": (path) => new TextLoader(path),
+        ".jsx": (path) => new TextLoader(path),
+        ".tsx": (path) => new TextLoader(path),
+        ".vue": (path) => new TextLoader(path),
+        ".py": (path) => new TextLoader(path),
+        ".md": (path) => new TextLoader(path),
+      });
+
+      const docs = await loader.load();
+      const splitDocs = await this.textSplitter.splitDocuments(docs);
+      
+      this.vectorStore = await MemoryVectorStore.fromDocuments(
+        splitDocs,
+        this.embeddings
+      );
+      
+      console.log(`已加载 ${docs.length} 个文件，分割为 ${splitDocs.length} 个文档块`);
+    } catch (error) {
+      console.error('初始化项目上下文失败:', error);
+      throw error;
     }
+  }
 
+  /**
+   * 使用LangChain工具进行文件操作
+   */
+  async readFileWithLangChain(filePath) {
     try {
-        const { ChatOpenAI } = await import('@langchain/openai');
-        const { AgentExecutor, createOpenAIFunctionsAgent } = await import('langchain/agents');
-        const { ChatPromptTemplate, MessagesPlaceholder } = await import('@langchain/core/prompts');
-        const { HumanMessage, AIMessage } = await import('@langchain/core/messages');
-        const { DynamicTool } = await import('@langchain/core/tools');
-
-        // 初始化OpenAI模型
-        model = new ChatOpenAI({
-            modelName: "gpt-3.5-turbo",
-            temperature: 0.1,
-        });
+      const tools = this.fileManagementToolkit.getTools();
+      const readTool = tools.find(tool => tool.name === 'read_file');
+      
+      if (!readTool) {
+        throw new Error('Read file tool not found');
+      }
 
-        // 定义工具函数
-        const tools = [
-            new DynamicTool({
-                name: "read_file",
-                description: "读取template-debug目录下的文件内容。参数: filepath - 相对于template-debug的文件路径",
-                func: async (filepath) => {
-                    try {
-                        const fullPath = path.join(templateDebugPath, filepath);
-                        
-                        // 安全检查：确保文件在template-debug目录内
-                        if (!fullPath.startsWith(templateDebugPath)) {
-                            return "错误：只能访问template-debug目录下的文件";
-                        }
-                        
-                        if (!await fs.pathExists(fullPath)) {
-                            return `文件不存在: ${filepath}`;
-                        }
-                        
-                        const content = await fs.readFile(fullPath, 'utf-8');
-                        return `文件内容 (${filepath}):\n${content}`;
-                    } catch (error) {
-                        return `读取文件失败: ${error.message}`;
-                    }
-                }
-            }),
-
-            new DynamicTool({
-                name: "write_file",
-                description: "写入或修改template-debug目录下的文件。参数格式: filepath|content (用|分隔文件路径和内容)",
-                func: async (input) => {
-                    try {
-                        const [filepath, ...contentParts] = input.split('|');
-                        const content = contentParts.join('|');
-                        
-                        if (!filepath || content === undefined) {
-                            return "错误：请提供文件路径和内容，格式: filepath|content";
-                        }
-                        
-                        const fullPath = path.join(templateDebugPath, filepath);
-                        
-                        // 安全检查：确保文件在template-debug目录内
-                        if (!fullPath.startsWith(templateDebugPath)) {
-                            return "错误：只能修改template-debug目录下的文件";
-                        }
-                        
-                        // 确保目录存在
-                        await fs.ensureDir(path.dirname(fullPath));
-                        
-                        // 写入文件
-                        await fs.writeFile(fullPath, content, 'utf-8');
-                        
-                        return `文件已成功保存: ${filepath}`;
-                    } catch (error) {
-                        return `写入文件失败: ${error.message}`;
-                    }
-                }
-            }),
-
-            new DynamicTool({
-                name: "list_files",
-                description: "列出template-debug目录下的文件和文件夹。参数: dirpath - 相对于template-debug的目录路径（可选，默认为根目录）",
-                func: async (dirpath = '') => {
-                    try {
-                        const fullPath = path.join(templateDebugPath, dirpath);
-                        
-                        // 安全检查
-                        if (!fullPath.startsWith(templateDebugPath)) {
-                            return "错误：只能访问template-debug目录下的内容";
-                        }
-                        
-                        if (!await fs.pathExists(fullPath)) {
-                            return `目录不存在: ${dirpath || '/'}`;
-                        }
-                        
-                        const items = await fs.readdir(fullPath, { withFileTypes: true });
-                        const result = items.map(item => {
-                            const type = item.isDirectory() ? '[目录]' : '[文件]';
-                            return `${type} ${item.name}`;
-                        }).join('\n');
-                        
-                        return `目录内容 (${dirpath || '/'}):\n${result}`;
-                    } catch (error) {
-                        return `列出文件失败: ${error.message}`;
-                    }
-                }
-            }),
-
-            new DynamicTool({
-                name: "delete_file",
-                description: "删除template-debug目录下的文件。参数: filepath - 相对于template-debug的文件路径",
-                func: async (filepath) => {
-                    try {
-                        const fullPath = path.join(templateDebugPath, filepath);
-                        
-                        // 安全检查
-                        if (!fullPath.startsWith(templateDebugPath)) {
-                            return "错误：只能删除template-debug目录下的文件";
-                        }
-                        
-                        if (!await fs.pathExists(fullPath)) {
-                            return `文件不存在: ${filepath}`;
-                        }
-                        
-                        await fs.remove(fullPath);
-                        return `文件已删除: ${filepath}`;
-                    } catch (error) {
-                        return `删除文件失败: ${error.message}`;
-                    }
-                }
-            })
-        ];
-
-        // 创建prompt模板
-        const prompt = ChatPromptTemplate.fromMessages([
-            ["system", `你是一个专业的代码修改助手。你可以帮助用户修改template-debug目录下的代码文件。
-
-你有以下工具可以使用：
-1. read_file - 读取文件内容
-2. write_file - 写入或修改文件内容
-3. list_files - 列出目录内容
-4. delete_file - 删除文件
-
-请根据用户的需求，使用这些工具来完成代码修改任务。在修改代码时，请：
-- 仔细理解用户的需求
-- 先读取相关文件了解现有代码结构
-- 进行必要的修改
-- 确保代码语法正确
-- 提供清晰的修改说明
-
-始终用中文回复用户。`],
-            new MessagesPlaceholder("chat_history"),
-            ["human", "{input}"],
-            new MessagesPlaceholder("agent_scratchpad")
-        ]);
-
-        // 创建agent
-        const agent = await createOpenAIFunctionsAgent({
-            llm: model,
-            tools,
-            prompt
-        });
+      const result = await readTool.invoke({ file_path: filePath });
+      const lines = result.split('\n');
+      
+      return { 
+        success: true, 
+        content: result, 
+        lines,
+        metadata: {
+          lineCount: lines.length,
+          filePath: path.resolve(this.projectRoot, filePath)
+        }
+      };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: error.message,
+        filePath 
+      };
+    }
+  }
 
-        // 创建agent执行器
-        agentExecutor = new AgentExecutor({
-            agent,
-            tools,
-            verbose: true,
-            maxIterations: 10
-        });
+  /**
+   * 使用LangChain工具写入文件
+   */
+  async writeFileWithLangChain(filePath, content) {
+    try {
+      const tools = this.fileManagementToolkit.getTools();
+      const writeTool = tools.find(tool => tool.name === 'write_file');
+      
+      if (!writeTool) {
+        throw new Error('Write file tool not found');
+      }
 
-        console.log('AI代码修改助手初始化成功');
-        return true;
+      await writeTool.invoke({ 
+        file_path: filePath, 
+        text: content 
+      });
+      
+      return { 
+        success: true, 
+        message: `文件 ${filePath} 写入成功`,
+        timestamp: new Date().toISOString()
+      };
     } catch (error) {
-        console.error('初始化AI失败:', error);
-        return false;
+      return { 
+        success: false, 
+        error: error.message,
+        filePath 
+      };
     }
-}
+  }
 
-// 存储对话历史
-const chatHistories = new Map();
+  /**
+   * 使用向量搜索获取相关上下文
+   */
+  async getRelevantContext(description, filePath = null) {
+    if (!this.vectorStore) {
+      await this.initializeProjectContext();
+    }
 
-// API路由
-router.post('/chat', async (req, res) => {
     try {
-        const { message, sessionId = 'default' } = req.body;
-        
-        if (!message) {
-            return res.status(400).json({ error: '请提供消息内容' });
-        }
+      // 构建搜索查询
+      let searchQuery = description;
+      if (filePath) {
+        searchQuery += ` file:${path.basename(filePath)}`;
+      }
 
-        // 如果AI未初始化，尝试初始化
-        if (!agentExecutor) {
-            const initialized = await initializeAI();
-            if (!initialized) {
-                return res.status(500).json({
-                    success: false,
-                    error: 'AI服务不可用，请检查OPENAI_API_KEY环境变量是否设置'
-                });
-            }
-        }
+      const relevantDocs = await this.vectorStore.similaritySearch(searchQuery, 5);
+      
+      return {
+        success: true,
+        contexts: relevantDocs.map(doc => ({
+          content: doc.pageContent,
+          metadata: doc.metadata,
+          relevanceScore: doc.score || 0
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        contexts: []
+      };
+    }
+  }
 
-        // 获取或初始化对话历史
-        if (!chatHistories.has(sessionId)) {
-            chatHistories.set(sessionId, []);
-        }
-        const chatHistory = chatHistories.get(sessionId);
+  /**
+   * 使用结构化输出分析代码位置
+   */
+  async analyzeCodeLocationStructured(filePath, description) {
+    const fileResult = await this.readFileWithLangChain(filePath);
+    if (!fileResult.success) {
+      return { success: false, error: fileResult.error };
+    }
 
-        // 执行agent
-        const result = await agentExecutor.invoke({
-            input: message,
-            chat_history: chatHistory
-        });
+    // 获取相关上下文
+    const contextResult = await this.getRelevantContext(description, filePath);
+    const relevantContext = contextResult.success ? 
+      contextResult.contexts.map(ctx => ctx.content).join('\n\n') : '';
 
-        // 更新对话历史
-        chatHistory.push(new HumanMessage(message));
-        chatHistory.push(new AIMessage(result.output));
+    const analysisPrompt = PromptTemplate.fromTemplate(`
+你是一个专业的代码分析师。请分析以下代码文件，根据用户的描述找到需要修改的具体位置。
 
-        // 限制历史记录长度
-        if (chatHistory.length > 20) {
-            chatHistory.splice(0, chatHistory.length - 20);
-        }
+文件路径: {filePath}
+文件内容:
+\`\`\`
+{fileContent}
+\`\`\`
 
-        res.json({
-            success: true,
-            response: result.output,
-            sessionId
-        });
+相关项目上下文:
+{relevantContext}
+
+用户描述: {description}
+
+请仔细分析代码结构和用户需求，返回可能的修改位置。考虑以下因素：
+1. 代码的逻辑结构和依赖关系
+2. 函数/类的边界
+3. 变量作用域
+4. 最小侵入性原则
+
+{format_instructions}
+`);
+
+    try {
+      const chain = RunnableSequence.from([
+        analysisPrompt,
+        llm,
+        this.analysisParser
+      ]);
+
+      const result = await chain.invoke({
+        filePath,
+        fileContent: fileResult.content,
+        relevantContext,
+        description,
+        format_instructions: this.analysisParser.getFormatInstructions()
+      });
 
+      return { 
+        success: true, 
+        ...result,
+        fileMetadata: fileResult.metadata
+      };
     } catch (error) {
-        console.error('AI Agent错误:', error);
-        res.status(500).json({
-            success: false,
-            error: '处理请求时发生错误',
-            details: error.message
+      return { 
+        success: false, 
+        error: `分析失败: ${error.message}`,
+        fallbackLocations: this.fallbackLocationAnalysis(fileResult.lines, description)
+      };
+    }
+  }
+
+  /**
+   * 降级位置分析（当结构化分析失败时）
+   */
+  fallbackLocationAnalysis(lines, description) {
+    const keywords = description.toLowerCase().split(/\s+/);
+    const locations = [];
+    
+    lines.forEach((line, index) => {
+      const lineContent = line.toLowerCase();
+      const matchCount = keywords.filter(keyword => lineContent.includes(keyword)).length;
+      
+      if (matchCount > 0) {
+        locations.push({
+          startLine: index + 1,
+          endLine: index + 1,
+          reason: `包含关键词: ${keywords.filter(k => lineContent.includes(k)).join(', ')}`,
+          context: line.trim(),
+          confidence: matchCount / keywords.length
         });
+      }
+    });
+
+    return locations.sort((a, b) => b.confidence - a.confidence).slice(0, 3);
+  }
+
+  /**
+   * 生成结构化代码修改
+   */
+  async generateCodeModificationStructured(filePath, startLine, endLine, description, context = '') {
+    const fileResult = await this.readFileWithLangChain(filePath);
+    if (!fileResult.success) {
+      return { success: false, error: fileResult.error };
     }
-});
 
-// 获取文件列表
-router.get('/files', async (req, res) => {
+    const lines = fileResult.lines;
+    const beforeContext = lines.slice(Math.max(0, startLine - 6), startLine - 1).join('\n');
+    const targetCode = lines.slice(startLine - 1, endLine).join('\n');
+    const afterContext = lines.slice(endLine, Math.min(lines.length, endLine + 5)).join('\n');
+
+    // 获取项目上下文
+    const contextResult = await this.getRelevantContext(description, filePath);
+    const projectContext = contextResult.success ? 
+      contextResult.contexts.slice(0, 3).map(ctx => ctx.content).join('\n\n') : '';
+
+    const modificationPrompt = PromptTemplate.fromTemplate(`
+你是一个专业的代码修改专家。请根据用户的需求修改指定的代码片段。
+
+文件路径: {filePath}
+修改范围: 第{startLine}行 到 第{endLine}行
+
+项目上下文信息:
+{projectContext}
+
+附加上下文:
+{context}
+
+修改前的代码上下文:
+\`\`\`
+{beforeContext}
+--- 需要修改的代码开始 ---
+{targetCode}
+--- 需要修改的代码结束 ---
+{afterContext}
+\`\`\`
+
+用户需求: {description}
+
+请遵循以下原则：
+1. 保持原有的代码风格和缩进
+2. 确保修改后的代码语法正确
+3. 考虑代码的完整性和逻辑性
+4. 最小化对现有功能的影响
+5. 添加必要的注释说明
+
+{format_instructions}
+`);
+
+    try {
+      const chain = RunnableSequence.from([
+        modificationPrompt,
+        llm,
+        this.modificationParser
+      ]);
+
+      const result = await chain.invoke({
+        filePath,
+        startLine,
+        endLine,
+        beforeContext,
+        targetCode,
+        afterContext,
+        description,
+        context,
+        projectContext,
+        format_instructions: this.modificationParser.getFormatInstructions()
+      });
+
+      return { 
+        success: true, 
+        ...result,
+        originalCode: targetCode,
+        metadata: fileResult.metadata
+      };
+    } catch (error) {
+      return { 
+        success: false, 
+        error: `生成修改失败: ${error.message}`,
+        originalCode: targetCode
+      };
+    }
+  }
+
+  /**
+   * 应用代码修改（使用LangChain工具）
+   */
+  async applyModification(filePath, startLine, endLine, newCode) {
+    const fileResult = await this.readFileWithLangChain(filePath);
+    if (!fileResult.success) {
+      return { success: false, error: fileResult.error };
+    }
+
+    try {
+      const lines = fileResult.lines;
+      const newLines = [
+        ...lines.slice(0, startLine - 1),
+        ...newCode.split('\n'),
+        ...lines.slice(endLine)
+      ];
+
+      const newContent = newLines.join('\n');
+      const writeResult = await this.writeFileWithLangChain(filePath, newContent);
+      
+      if (writeResult.success) {
+        return { 
+          success: true, 
+          message: `成功修改文件 ${filePath}`,
+          changes: {
+            linesAdded: newCode.split('\n').length,
+            linesRemoved: endLine - startLine + 1,
+            originalRange: { startLine, endLine },
+            modifiedAt: writeResult.timestamp
+          }
+        };
+      } else {
+        return { success: false, error: writeResult.error };
+      }
+    } catch (error) {
+      return { 
+        success: false, 
+        error: `应用修改失败: ${error.message}` 
+      };
+    }
+  }
+
+  /**
+   * 智能代码修改 - 使用所有LangChain优化
+   */
+  async smartModifyWithEnhancements(filePath, description, autoApply = false) {
+    console.log(`开始智能分析文件: ${filePath}`);
+    
     try {
-        const { path: dirPath = '' } = req.query;
-        const fullPath = path.join(templateDebugPath, dirPath);
+      // 1. 使用结构化输出分析代码位置
+      const locationResult = await this.analyzeCodeLocationStructured(filePath, description);
+      if (!locationResult.success) {
+        return { success: false, error: locationResult.error };
+      }
+
+      console.log(`找到 ${locationResult.locations.length} 个可能的修改位置 (置信度: ${locationResult.confidence})`);
+      
+      const results = [];
+      
+      // 2. 对每个位置生成结构化修改
+      for (const location of locationResult.locations) {
+        console.log(`正在处理位置: 第${location.startLine}-${location.endLine}行`);
+        
+        const modificationResult = await this.generateCodeModificationStructured(
+          filePath,
+          location.startLine,
+          location.endLine,
+          description,
+          location.context
+        );
         
-        if (!fullPath.startsWith(templateDebugPath)) {
-            return res.status(400).json({ error: '无效的路径' });
+        if (modificationResult.success) {
+          const result = {
+            location,
+            modification: modificationResult,
+            applied: false,
+            riskAssessment: {
+              level: modificationResult.riskLevel,
+              considerations: this.assessModificationRisk(modificationResult)
+            }
+          };
+
+          // 如果启用自动应用且风险等级较低
+          if (autoApply && modificationResult.riskLevel === 'low') {
+            const applyResult = await this.applyModification(
+              filePath,
+              location.startLine,
+              location.endLine,
+              modificationResult.modifiedCode
+            );
+            result.applied = applyResult.success;
+            result.applyResult = applyResult;
+          }
+
+          results.push(result);
         }
+      }
+
+      return {
+        success: true,
+        analysis: locationResult.analysis,
+        confidence: locationResult.confidence,
+        modifications: results,
+        projectContextUsed: true
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `智能修改失败: ${error.message}`,
+        fallbackAvailable: true
+      };
+    }
+  }
+
+  /**
+   * 评估修改风险
+   */
+  assessModificationRisk(modificationResult) {
+    const considerations = [];
+    
+    // 检查修改复杂度
+    const changeCount = modificationResult.changes.length;
+    if (changeCount > 5) {
+      considerations.push("修改涉及多处变更，建议仔细审查");
+    }
+
+    // 检查是否涉及删除操作
+    const hasDeletes = modificationResult.changes.some(change => change.type === 'deleted');
+    if (hasDeletes) {
+      considerations.push("包含代码删除操作，请确认不会影响现有功能");
+    }
+
+    // 检查修改说明的完整性
+    if (!modificationResult.explanation || modificationResult.explanation.length < 20) {
+      considerations.push("修改说明较简单，建议获取更详细的解释");
+    }
+
+    return considerations;
+  }
+
+  /**
+   * 批量修改多个文件 - 增强版
+   */
+  async batchModifyEnhanced(modifications, options = {}) {
+    const { autoApply = false, maxConcurrency = 3 } = options;
+    const results = [];
+    
+    // 使用Promise控制并发数量
+    const semaphore = new Array(maxConcurrency).fill(null);
+    
+    const processModification = async (mod) => {
+      try {
+        let result;
         
-        if (!await fs.pathExists(fullPath)) {
-            return res.status(404).json({ error: '目录不存在' });
+        if (mod.startLine && mod.endLine) {
+          // 指定位置修改
+          const modResult = await this.generateCodeModificationStructured(
+            mod.filePath,
+            mod.startLine,
+            mod.endLine,
+            mod.description
+          );
+          
+          if (modResult.success && autoApply && modResult.riskLevel === 'low') {
+            const applyResult = await this.applyModification(
+              mod.filePath,
+              mod.startLine,
+              mod.endLine,
+              modResult.modifiedCode
+            );
+            result = { ...modResult, applied: applyResult.success, applyResult };
+          } else {
+            result = { ...modResult, applied: false };
+          }
+        } else {
+          // 智能修改
+          result = await this.smartModifyWithEnhancements(
+            mod.filePath,
+            mod.description,
+            autoApply
+          );
         }
         
-        const items = await fs.readdir(fullPath, { withFileTypes: true });
-        const files = items.map(item => ({
-            name: item.name,
-            type: item.isDirectory() ? 'directory' : 'file',
-            path: path.join(dirPath, item.name).replace(/\\/g, '/')
-        }));
+        return {
+          filePath: mod.filePath,
+          description: mod.description,
+          result,
+          processedAt: new Date().toISOString()
+        };
         
-        res.json({ success: true, files });
-    } catch (error) {
-        res.status(500).json({ error: '获取文件列表失败', details: error.message });
+      } catch (error) {
+        return {
+          filePath: mod.filePath,
+          description: mod.description,
+          result: { success: false, error: error.message },
+          processedAt: new Date().toISOString()
+        };
+      }
+    };
+
+    // 并发处理修改请求
+    const chunks = [];
+    for (let i = 0; i < modifications.length; i += maxConcurrency) {
+      chunks.push(modifications.slice(i, i + maxConcurrency));
     }
-});
 
-// 清除对话历史
-router.delete('/chat/:sessionId', (req, res) => {
-    const { sessionId } = req.params;
-    chatHistories.delete(sessionId);
-    res.json({ success: true, message: '对话历史已清除' });
-});
+    for (const chunk of chunks) {
+      const promises = chunk.map(processModification);
+      const chunkResults = await Promise.all(promises);
+      results.push(...chunkResults);
+    }
+    
+    return { 
+      success: true, 
+      results,
+      summary: {
+        total: results.length,
+        successful: results.filter(r => r.result.success).length,
+        applied: results.filter(r => r.result.applied).length,
+        failed: results.filter(r => !r.result.success).length
+      }
+    };
+  }
 
-// 健康检查
-router.get('/health', (req, res) => {
-    res.json({
-        success: true,
-        aiAvailable: !!agentExecutor,
-        hasOpenAIKey: hasOpenAIKey
-    });
-});
+  /**
+   * 清理资源
+   */
+  async cleanup() {
+    if (this.vectorStore) {
+      // 清理向量存储资源
+      this.vectorStore = null;
+    }
+    console.log('代码修改Agent资源已清理');
+  }
+}
+
+// 创建增强的代码修改 Agent 实例
+const enhancedCodeAgent = new EnhancedCodeModificationAgent();
+
+// 导出功能
+export { enhancedCodeAgent, EnhancedCodeModificationAgent };
 
-export default router;
+// 默认导出
+export default enhancedCodeAgent;