@saber2pr/ai-agent 0.0.14 → 0.0.16

package/README.md

@@ -80,39 +80,93 @@ await agent.chat("Scan for hardcoded colors and submit a review report.");
 
 ## 🔧 Extending with Private LLMs
 
-To use your own API protocol, extend the `BaseChatModel` from `@langchain/core`:
+### Using AgentChainModel (Recommended)
+
+For LangChain mode, extend `AgentChainModel` which provides a simplified interface for integrating custom LLMs:
 
 ```javascript
-const { BaseChatModel } = require("@langchain/core/language_models/chat_models");
+const { AgentChainModel } = require("@saber2pr/ai-agent");
+
+class MyPrivateLLM extends AgentChainModel {
+  constructor(fields) { 
+    super(fields || {}); 
+  }
 
-class MyPrivateLLM extends BaseChatModel {
-  async _generate(messages) {
+  async generateAgentChainResponse(messages) {
     const lastMessage = messages[messages.length - 1];
-    const response = await fetch("https://your-api.com/v1/chat", {
+    const queryText = lastMessage.content;
+    
+    const response = await fetch("https://your-api-gateway.com/api/completions", {
       method: 'POST',
-      body: JSON.stringify({ query: lastMessage.content }),
-      headers: { 'Authorization': `Bearer ${token}` }
+      body: JSON.stringify({ query: queryText, stream: false }),
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer YOUR_API_KEY`,
+      }
     });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`HTTP Error: ${response.status}, ${errorText}`);
+    }
+
     const data = await response.json();
-    return {
-      generations: [{ text: data.text, message: { content: data.text, role: "assistant" } }]
-    };
+    let text = data.text || "";
+    
+    // Handle special response formats if needed
+    if (text.includes("Action:") && text.includes("Final Answer:")) {
+      text = text.split("Final Answer:")[0].trim();
+    }
+    
+    return text;
   }
-  _llmType() { return "private_llm"; }
 }
-
 ```
 
+**Key Points:**
+- `AgentChainModel` abstracts away LangChain's internal message handling
+- You only need to implement `generateAgentChainResponse(messages)` which receives an array of messages
+- The method should return a plain string response
+- The base class handles conversion to LangChain's expected format
+
 ---
 
 ## 📦 Built-in Toolset
 
-| Tool              | Description                                                              |
-| ----------------- | ------------------------------------------------------------------------ |
-| `generate_review` | Finalizes the process by submitting a structured violation report.       |
-| `get_repo_map`    | Generates a high-level map of the project files and exports.             |
-| `read_text_file`  | Reads file content with line numbers for precise auditing.               |
-| `read_skeleton`   | Extracts class/function signatures without full logic (Token efficient). |
+The toolkit provides a comprehensive set of built-in tools organized into two categories: **Filesystem Tools** and **Code Analysis Tools**. All tools operate within the `targetDir` scope for security.
+
+### Filesystem Tools
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `read_text_file` | Read complete file contents as text. Supports `head` and `tail` parameters for partial reading. Handles various text encodings. | `path` (required), `head?`, `tail?` |
+| `read_multiple_files` | Read multiple files simultaneously for efficient batch analysis. Individual failures won't stop the operation. | `paths` (array, required) |
+| `write_file` | Create a new file or completely overwrite an existing file. Use with caution as it overwrites without warning. | `path` (required), `content` (required) |
+| `edit_file` | Make line-based edits to a text file. Replaces exact line sequences with new content. Returns git-style diff. Supports `dryRun` mode for preview. | `path` (required), `edits` (array, required), `dryRun?` |
+| `get_directory_tree` | Get a recursive tree view of files and directories as JSON. Supports `excludePatterns` for filtering (minimatch patterns). Essential for understanding project structure. | `path` (required), `excludePatterns?` (array) |
+| `list_directory` | List all files and directories in a specified path. Results distinguish files and directories with `[FILE]` and `[DIR]` prefixes. | `path` (required) |
+| `list_directory_with_sizes` | List directory contents with file sizes. Supports sorting by name or size. Includes summary statistics. | `path` (required), `sortBy?` ("name" \| "size") |
+| `search_files` | Search for files matching a glob pattern. Supports exclude patterns for filtering. | `path` (required), `pattern` (required), `excludePatterns?` (array) |
+| `move_file` | Move or rename files and directories. Can move between directories and rename in a single operation. | `source` (required), `destination` (required) |
+| `create_directory` | Create a new directory or ensure it exists. Can create multiple nested directories recursively. | `path` (required) |
+| `get_file_info` | Get detailed metadata about a file: size, last modified time, type, etc. | `path` (required) |
+
+### Code Analysis Tools
+
+| Tool | Description | Parameters |
+|------|-------------|------------|
+| `get_repo_map` | Generate a high-level map of project files and exports. Extracts export definitions to understand module relationships. Use this first to understand project structure. | None |
+| `read_skeleton` | Extract structural definitions (interfaces, classes, method signatures) without implementation details. Token-efficient for code analysis. | `filePath` (required) |
+| `analyze_deps` | Analyze dependency relationships for a specific file. Supports TypeScript path alias resolution via tsconfig. | `filePath` (required) |
+| `get_method_body` | Get the complete implementation code for a specific method or function within a file. | `filePath` (required), `methodName` (required) |
+
+### Tool Usage Tips
+
+1. **Start with `get_directory_tree`**: Always begin by understanding the project structure before reading files.
+2. **Use `read_skeleton` before `read_text_file`**: Extract signatures first to save tokens, then read full content only when needed.
+3. **Leverage `excludePatterns`**: Use minimatch patterns to exclude `node_modules`, `.git`, build artifacts, etc.
+4. **Batch operations**: Use `read_multiple_files` when analyzing multiple files to improve efficiency.
+5. **Preview changes**: Use `edit_file` with `dryRun: true` to preview changes before applying them.
 
 ---
 

package/lib/core/agent-chain.d.ts

@@ -1,7 +1,6 @@
 import { AgentOptions } from '../types/type';
 export default class McpChainAgent {
     private allTools;
-    private messages;
     private encoder;
     private extraTools;
     private maxTokens;
@@ -9,17 +8,13 @@ export default class McpChainAgent {
     private apiConfig;
     private maxIterations;
     private apiModel?;
-    private targetDir;
-    private verbose;
+    private memory?;
+    private systemPrompt;
     private runningTokenCounter;
+    private verbose;
     constructor(options?: AgentOptions);
-    /**
-     * 工具处理器包装逻辑：增加日志打印和 Token 监控
-     */
-    private wrapHandler;
     private initTools;
-    private calculateTokens;
-    private pruneMessages;
+    private wrapHandler;
     init(): Promise<void>;
     chat(input: string): Promise<string>;
     private showLoading;

package/lib/core/agent-chain.js

@@ -39,222 +39,162 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const js_tiktoken_1 = require("js-tiktoken");
 const agents_1 = require("langchain/agents");
+const memory_1 = require("langchain/memory");
 const readline = __importStar(require("readline"));
 const prompts_1 = require("@langchain/core/prompts");
 const tools_1 = require("@langchain/core/tools");
 const openai_1 = require("@langchain/openai");
 const config_1 = require("../config/config");
-const jsonSchemaToZod_1 = require("../utils/jsonSchemaToZod");
 const builtin_1 = require("../tools/builtin");
+const jsonSchemaToZod_1 = require("../utils/jsonSchemaToZod");
 class McpChainAgent {
     constructor(options) {
         this.allTools = [];
-        this.messages = [];
         this.encoder = (0, js_tiktoken_1.getEncoding)("cl100k_base");
         this.extraTools = [];
-        this.runningTokenCounter = 0; // 新增：用于追踪当前 Task 的动态消耗
+        this.runningTokenCounter = 0;
         this.extraTools = (options === null || options === void 0 ? void 0 : options.tools) || [];
         this.maxTokens = (options === null || options === void 0 ? void 0 : options.maxTokens) || 100000;
         this.apiConfig = options === null || options === void 0 ? void 0 : options.apiConfig;
         this.maxIterations = (options === null || options === void 0 ? void 0 : options.maxIterations) || 20;
         this.apiModel = options === null || options === void 0 ? void 0 : options.apiModel;
-        this.targetDir = (options === null || options === void 0 ? void 0 : options.targetDir) || process.cwd();
         this.verbose = (options === null || options === void 0 ? void 0 : options.verbose) || false;
-        const baseSystemPrompt = `你是一个专业的 AI 代码架构师，具备深度的源码分析与工程化处理能力。
-    
-### 核心操作规范：
-1. **全局扫描（强制首选）**：在开始任何分析任务前，你【必须】首先调用 'get_repo_map'。这是理解项目结构、技术栈及模块关系的唯一来源。
-2. **循序渐进的分析路径**：
-   - 优先使用 'read_skeleton' 提取接口和函数签名。
-   - 仅在需要分析具体逻辑或准备修复代码时，才使用 'read_text_file'。
-3. **真实性原则**：所有的代码分析必须基于工具返回的真实内容，严禁虚假猜测。`;
-        this.messages.push({
-            role: "system",
-            content: (options === null || options === void 0 ? void 0 : options.extraSystemPrompt)
-                ? `${baseSystemPrompt}\n\n[额外指令]:\n${JSON.stringify(options.extraSystemPrompt)}`
-                : baseSystemPrompt,
-        });
+        const baseSystemPrompt = `你是一个专业的代码架构师。
+你的目标是理解并分析用户项目，请务必遵循以下工作流：
+
+### 第一阶段：全景感知 (The "Where" Phase)
+1. **必须首先调用 'get_directory_tree'**：获取项目完整文件列表，包括样式文件 (.less, .css) 和资源文件。
+2. 结合目录结构，观察项目架构（如 Monorepo 结构或 src 布局）。
+
+### 第二阶段：逻辑映射 (The "What" Phase)
+1. **调用 'get_repo_map'**：针对代码文件提取导出定义，理解模块间的调用关系。
+2. 如果需要查看具体的样式定义，直接使用 'read_text_file' 读取 .less 或 .css 文件。
+
+### 核心原则：
+- 不要猜测文件是否存在，先看目录树。
+- 优先查看 Skeleton（骨架），只有需要修复逻辑时才读取完整 Text（全文）。
+- 始终以中文回答思考过程。`;
+        this.systemPrompt = (options === null || options === void 0 ? void 0 : options.extraSystemPrompt)
+            ? `${baseSystemPrompt}\n\n[额外指令]:\n${JSON.stringify(options.extraSystemPrompt)}`
+            : baseSystemPrompt;
         this.initTools(options);
     }
-    /**
-     * 工具处理器包装逻辑：增加日志打印和 Token 监控
-     */
+    initTools(options) {
+        const allTools = [...(0, builtin_1.createDefaultBuiltinTools)({ options: { ...options, ...this } }), ...this.extraTools];
+        this.allTools = allTools.map((t) => ({
+            ...t,
+            _handler: this.wrapHandler(t.function.name, t._handler),
+        }));
+    }
     wrapHandler(name, handler) {
         return async (args) => {
-            // 1. 打印工具执行日志
             console.log(`\n   [工具调用]: ${name}`);
-            if (args === null || args === void 0 ? void 0 : args.filePath) {
-                console.log(`   [目标文件]: ${args.filePath}`);
-            }
-            // 2. 执行逻辑
             const result = await handler(args);
             const content = typeof result === "string" ? result : JSON.stringify(result);
-            // 3. 统计 Token 消耗
-            const outputTokens = this.encoder.encode(content).length;
-            console.log(`   [输出长度]: ${outputTokens} tokens`);
-            // 2. 更新动态计数器：
-            // 这里的逻辑是：当前基础 Context + 本次工具调用的输出
-            // 随着迭代增加，这个值会一直累加，直到任务结束存入 messages
-            const baseTokens = this.calculateTokens();
-            this.runningTokenCounter = baseTokens + outputTokens;
-            // 3. 打印正确且递增的状态
-            console.log(`   📊 状态: Context ${this.runningTokenCounter} / Limit ${this.maxTokens} tokens`);
+            this.runningTokenCounter += this.encoder.encode(content).length;
             return content;
         };
     }
-    initTools(options) {
-        const allTools = [
-            // 注册内置工具
-            ...(0, builtin_1.createDefaultBuiltinTools)({
-                options: {
-                    ...options,
-                    ...this
-                }
-            }),
-            ...this.extraTools
-        ];
-        if (allTools === null || allTools === void 0 ? void 0 : allTools.length) {
-            this.allTools.push(...allTools.map((t) => ({
-                type: t.type,
-                function: t.function,
-                _handler: this.wrapHandler(t.function.name, t._handler),
-            })));
-        }
-    }
-    calculateTokens() {
-        return this.messages.reduce((acc, msg) => acc + this.encoder.encode(String(msg.content || "")).length, 0);
-    }
-    pruneMessages() {
-        const current = this.calculateTokens();
-        if (current > this.maxTokens) {
-            console.log(`\n⚠️ 上下文达到限制 (${current} tokens)，正在裁剪旧消息...`);
-            // 保留 system prompt (index 0)，移除后续消息
-            while (this.calculateTokens() > this.maxTokens * 0.8 && this.messages.length > 2) {
-                this.messages.splice(1, 1);
-            }
-            console.log(`✅ 裁剪完成，当前: ${this.calculateTokens()} tokens`);
-        }
-    }
     async init() {
         if (this.executor)
             return;
         let model;
         if (this.apiModel) {
-            console.log("ℹ️ 使用自定义 API Model 实例");
             model = this.apiModel;
         }
         else {
-            // 降级方案：使用配置创建默认的 ChatOpenAI
             const apiConfig = await this.ensureApiConfig();
-            console.log(`ℹ️ 使用默认 ChatOpenAI (${apiConfig.model})`);
             model = new openai_1.ChatOpenAI({
                 configuration: { baseURL: apiConfig.baseURL, apiKey: apiConfig.apiKey },
                 modelName: apiConfig.model,
                 temperature: 0,
-                streaming: false
             });
         }
-        const langchainTools = this.allTools.map(t => {
-            return new tools_1.DynamicStructuredTool({
-                name: t.function.name,
-                description: t.function.description || "",
-                // 定义 schema 告诉 LangChain 这是一个对象输入
-                // passthrough() 允许接收未在 schema 中显式定义的其他字段
-                schema: (0, jsonSchemaToZod_1.jsonSchemaToZod)(t.function.parameters),
-                func: async (args) => {
-                    // 这里的 args 已经被 LangChain 自动解析为对象
-                    return await t._handler(args);
-                },
-            });
+        // 1. 初始化 SummaryBufferMemory
+        // maxTokenLimit 决定了当对话历史超过多少 Token 时触发“自动总结”
+        this.memory = new memory_1.ConversationSummaryBufferMemory({
+            llm: model,
+            maxTokenLimit: 2000,
+            memoryKey: "chat_history",
+            returnMessages: true,
+            // 必须添加下面这两行显式声明：
+            inputKey: "input", // 对应 invoke 里的 input 字段
+            outputKey: "output", // 对应 Agent 输出的字段
+            chatHistory: new memory_1.ChatMessageHistory(), // 👈 显式指定 history 实例
         });
-        // src/core/agent-chain.ts 中的 prompt 修改
-        const prompt = prompts_1.PromptTemplate.fromTemplate(`
-{system_prompt}
+        const langchainTools = this.allTools.map(t => new tools_1.DynamicStructuredTool({
+            name: t.function.name,
+            description: t.function.description || "",
+            schema: (0, jsonSchemaToZod_1.jsonSchemaToZod)(t.function.parameters),
+            func: async (args) => await t._handler(args),
+        }));
+        const prompt = prompts_1.PromptTemplate.fromTemplate(`{system_prompt}
 
-### 🛠 可用工具列表 (TOOLS)
---------------------
+### 🛠 可用工具：
 {tools}
 
-工具名称列表: [{tool_names}]
+### 🛠 工具名称：
+[{tool_names}]
+
+### 📝 历史记录：
+{chat_history}
 
-### 📝 交互协议格式 (PROTOCOL)
---------------------
-你必须严格遵守以下回复格式：
+### ⚠️ 回复规范（严格遵守）：
+1. 首先输出 **Thought:**，用中文详细说明你的分析思路。
+2. 接着输出一个 **JSON Action 代码块**。
 
-Thought: 首先，我会[此处用中文简述你的分析思路和下一步目标]。
+示例格式：
+Thought: 正在查看目录。
 \`\`\`json
 {{
-  "action": "工具名称",
-  "action_input": {{ "参数名": "参数值" }}
+  "action": "directory_tree",
+  "action_input": {{}}
 }}
 \`\`\`
 
-注意：
-- 严禁直接输出 JSON，必须先写 Thought。
-- Thought 必须包含具体的分析意图，不少于 10 个字。
-
 Begin!
 Question: {input}
-Thought: {agent_scratchpad}`);
+{agent_scratchpad}`); // 👈 强制以 Thought: 开头，解决断更问题
         const agent = await (0, agents_1.createStructuredChatAgent)({ llm: model, tools: langchainTools, prompt });
         this.executor = new agents_1.AgentExecutor({
             agent,
             tools: langchainTools,
-            verbose: this.verbose, // 我们已经有了 wrapHandler 日志，关闭原生 verbose 以保持整洁
-            handleParsingErrors: true,
-            maxIterations: this.maxIterations
+            memory: this.memory, // 挂载内存模块
+            verbose: this.verbose,
+            maxIterations: this.maxIterations,
+            handleParsingErrors: (e) => {
+                // 简化报错，不要再给 AI 错误的 JSON 示例
+                return `格式不正确。请确保你输出了一个正确的 Markdown JSON 代码块，例如：\n\`\`\`json\n{ "action": "...", "action_input": { ... } }\n\`\`\``;
+            },
         });
     }
     async chat(input) {
-        var _a;
         if (!this.executor)
             await this.init();
-        this.messages.push({ role: "user", content: input });
-        this.pruneMessages();
-        console.log(`\n📊 状态: Context ${this.calculateTokens()} / Limit ${this.maxTokens} tokens`);
-        const stopLoading = this.showLoading("🤖 Agent 正在思考并执行工具...");
+        this.runningTokenCounter = this.encoder.encode(input).length;
+        const stopLoading = this.showLoading("🤖 Agent 正在思考并管理上下文...");
         try {
+            // 执行请求，AgentExecutor 会自动：
+            // 1. 从 memory 加载历史 (chat_history)
+            // 2. 将这次对话的结果 saveContext 到 memory
             const response = await this.executor.invoke({
                 input: input,
-                system_prompt: this.messages[0].content,
+                system_prompt: this.systemPrompt,
             }, {
-                // --- 新增：使用回调函数捕获 Thought ---
                 callbacks: [{
-                        handleAgentAction: (action, runId) => {
-                            if (action.log) {
-                                const log = action.log.trim();
-                                // 1. 提取 Thought 部分：取 Thought: 之后，直到遇到 ```json 或 { 之前的内容
-                                const thoughtMatch = log.match(/Thought:\s*([\s\S]*?)(?=(?:```json|\{|Action:|$))/i);
-                                let thought = "";
-                                if (thoughtMatch && thoughtMatch[1]) {
-                                    thought = thoughtMatch[1].trim();
-                                }
-                                else {
-                                    // 备选方案：如果没有 Thought 标签，直接截取 JSON 之前的文本
-                                    thought = log.split(/```json|\{/)[0].replace(/Thought:/i, "").trim();
-                                }
-                                // 2. 只有当 thought 真的有文字内容（且不是 JSON）时才打印
-                                if (thought && thought.length > 0 && !thought.startsWith('{')) {
-                                    // 进一步清洗：如果 thought 包含多行，只取非空的第一行，避免打印太长
-                                    const displayThought = thought.split('\n').find(line => line.trim().length > 0);
-                                    if (displayThought) {
-                                        console.log(`\n💭 [思考]: ${displayThought}`);
-                                    }
-                                }
+                        handleAgentAction: (action) => {
+                            const rawLog = action.log || "";
+                            // 兼容 Thought: Thought: [内容]
+                            let thought = rawLog.split(/```json|\{/)[0]
+                                .replace(/Thought:/gi, "") // 全局替换掉所有 Thought: 标签
+                                .trim();
+                            if (thought) {
+                                console.log(`\n💭 [思考]: ${thought}`);
                             }
                         }
                     }]
             });
-            // 修复点：确保 output 是字符串
-            let output = typeof response.output === 'string'
-                ? response.output
-                : JSON.stringify(response.output);
-            // 清洗 ReAct 冗余标签
-            if (output.includes("Final Answer:")) {
-                output = ((_a = output.split("Final Answer:").pop()) === null || _a === void 0 ? void 0 : _a.trim()) || output;
-            }
-            this.messages.push({ role: "assistant", content: output });
-            return output;
+            return typeof response.output === 'string' ? response.output : JSON.stringify(response.output);
         }
         finally {
             stopLoading();
@@ -267,16 +207,12 @@ Thought: {agent_scratchpad}`);
             process.stdout.write(`\r${chars[i]} ${text}`);
             i = (i + 1) % chars.length;
         }, 80);
-        return () => {
-            clearInterval(timer);
-            process.stdout.write('\r\x1b[K');
-        };
+        return () => { clearInterval(timer); process.stdout.write('\r\x1b[K'); };
     }
     async start() {
         await this.init();
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        console.log(`\n🚀 AI 助手启动 (LangChain 核心)`);
-        console.log(`📂 目标目录: ${this.targetDir}`);
+        console.log(`\n🚀 AI 助手 (Summary+Window 模式) 已启动`);
         const chatLoop = () => {
             rl.question("\n👤 你: ", async (input) => {
                 if (!input.trim())
@@ -284,8 +220,8 @@ Thought: {agent_scratchpad}`);
                 if (input.toLowerCase() === "exit")
                     process.exit(0);
                 try {
-                    const result = await this.chat(input);
-                    console.log(`\n🤖 Agent: ${result}`);
+                    const res = await this.chat(input);
+                    console.log(`\n🤖 Agent: ${res}`);
                 }
                 catch (err) {
                     console.error("\n❌ 系统错误:", err.message);
@@ -298,20 +234,11 @@ Thought: {agent_scratchpad}`);
     async ensureApiConfig() {
         if (this.apiConfig)
             return this.apiConfig;
-        if (fs_1.default.existsSync(config_1.CONFIG_FILE)) {
+        if (fs_1.default.existsSync(config_1.CONFIG_FILE))
             return JSON.parse(fs_1.default.readFileSync(config_1.CONFIG_FILE, "utf-8"));
-        }
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         const question = (q) => new Promise((res) => rl.question(q, res));
-        console.log("\n🔑 配置 API 凭据:");
-        const config = {
-            baseURL: await question("? API Base URL (如 https://api.openai.com/v1): "),
-            apiKey: await question("? API Key: "),
-            model: await question("? Model Name (如 gpt-4o): "),
-        };
+        const config = { baseURL: await question("? API Base URL: "), apiKey: await question("? API Key: "), model: await question("? Model Name: ") };
         fs_1.default.writeFileSync(config_1.CONFIG_FILE, JSON.stringify(config, null, 2));
         rl.close();
         return config;

package/lib/core/agent.js

@@ -57,24 +57,21 @@ class McpAgent {
         this.extraTools = (options === null || options === void 0 ? void 0 : options.tools) || []; // 接收外部传入的工具
         this.maxTokens = (options === null || options === void 0 ? void 0 : options.maxTokens) || 100000; // 默认 100k
         this.apiConfig = options === null || options === void 0 ? void 0 : options.apiConfig;
-        let baseSystemPrompt = `你是一个专业的 AI 代码架构师，具备深度的源码分析与工程化处理能力。
+        let baseSystemPrompt = `你是一个专业的代码架构师。
+你的目标是理解并分析用户项目，请务必遵循以下工作流：
 
-    ### 核心操作规范：
-    1. **全局扫描（强制首选）**：在开始任何分析任务前，你【必须】首先调用 'get_repo_map'。这是你理解项目目录结构、技术栈及模块关系的唯一权威来源。
-    2. **循序渐进的分析路径**：
-       - 优先使用 'read_skeleton' 提取接口、类和函数签名，以最低的 Token 成本建立代码逻辑视图。
-       - 仅在需要深入分析具体业务逻辑、提取精准代码块或进行代码修改建议时，才使用 'read_text_file' 或 'get_method_body'。
-    3. **真实性原则**：
-       - 所有的代码分析、行号定位和逻辑推断必须基于工具返回的真实内容，严禁基于文件名进行虚假猜测。
-       - 如果工具返回结果为空或报错，应尝试调整路径或更换工具。
-    
-    ### 技术能力：
-    - 精通 TypeScript/JavaScript 及其 AST 结构，能准确识别各种复杂的声明与调用关系。
-    - 能够理解代码间的依赖链路，并结合项目上下文给出合理的架构建议。
-    
-    ### 执行准则：
-    - **任务导向**：直接通过工具链解决问题，减少不必要的中间对话。
-    - **自主决策**：根据任务需求自主选择最合适的工具组合，无需每一步都向用户请示。`;
+### 第一阶段：全景感知 (The "Where" Phase)
+1. **必须首先调用 'get_directory_tree'**：获取项目完整文件列表，包括样式文件 (.less, .css) 和资源文件。
+2. 结合目录结构，观察项目架构（如 Monorepo 结构或 src 布局）。
+
+### 第二阶段：逻辑映射 (The "What" Phase)
+1. **调用 'get_repo_map'**：针对代码文件提取导出定义，理解模块间的调用关系。
+2. 如果需要查看具体的样式定义，直接使用 'read_text_file' 读取 .less 或 .css 文件。
+
+### 核心原则：
+- 不要猜测文件是否存在，先看目录树。
+- 优先查看 Skeleton（骨架），只有需要修复逻辑时才读取完整 Text（全文）。
+- 始终以中文回答思考过程。`;
         // 2. 拼接额外指令
         if (options === null || options === void 0 ? void 0 : options.extraSystemPrompt) {
             const extra = typeof options.extraSystemPrompt === 'string'

package/lib/index.d.ts

@@ -2,3 +2,4 @@ export * from './core/agent';
 export { default as McpChainAgent } from './core/agent-chain';
 export { default } from './core/agent';
 export { createTool } from './utils/createTool';
+export { AgentChainModel } from './model/AgentChainModel';

package/lib/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTool = exports.default = exports.McpChainAgent = void 0;
+exports.AgentChainModel = exports.createTool = exports.default = exports.McpChainAgent = void 0;
 __exportStar(require("./core/agent"), exports);
 var agent_chain_1 = require("./core/agent-chain");
 Object.defineProperty(exports, "McpChainAgent", { enumerable: true, get: function () { return __importDefault(agent_chain_1).default; } });
@@ -25,3 +25,5 @@ var agent_1 = require("./core/agent");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(agent_1).default; } });
 var createTool_1 = require("./utils/createTool");
 Object.defineProperty(exports, "createTool", { enumerable: true, get: function () { return createTool_1.createTool; } });
+var AgentChainModel_1 = require("./model/AgentChainModel");
+Object.defineProperty(exports, "AgentChainModel", { enumerable: true, get: function () { return AgentChainModel_1.AgentChainModel; } });

package/lib/model/AgentChainModel.d.ts

@@ -0,0 +1,18 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { AIMessage, MessageFieldWithRole } from "@langchain/core/messages";
+interface AgentChainModelImpl {
+    generateAgentChainResponse: (messages: MessageFieldWithRole[]) => Promise<string>;
+}
+export declare abstract class AgentChainModel extends BaseChatModel implements AgentChainModelImpl {
+    bind(args: any): any;
+    constructor(fields?: any);
+    generateAgentChainResponse(messages: MessageFieldWithRole[]): Promise<string>;
+    _generate(messages: any): Promise<{
+        generations: {
+            text: string;
+            message: AIMessage;
+        }[];
+    }>;
+    _llmType(): string;
+}
+export {};

package/lib/model/AgentChainModel.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentChainModel = void 0;
+const chat_models_1 = require("@langchain/core/language_models/chat_models");
+const messages_1 = require("@langchain/core/messages");
+class AgentChainModel extends chat_models_1.BaseChatModel {
+    bind(args) {
+        // 逻辑上调用基类（即使基类在类型上说没有，运行时通常是有的）
+        // 如果运行时也没有，这里就返回 this 本身
+        // @ts-ignore
+        return (super.bind ? super.bind(args) : this);
+    }
+    constructor(fields) { super(fields || {}); }
+    async generateAgentChainResponse(messages) {
+        return '';
+    }
+    async _generate(messages) {
+        let text = await this.generateAgentChainResponse(messages);
+        return { generations: [{ text, message: new messages_1.AIMessage(text) }] };
+    }
+    _llmType() { return "my_private_llm"; }
+}
+exports.AgentChainModel = AgentChainModel;

package/lib/tools/filesystem/index.js

@@ -7,6 +7,7 @@ exports.getFilesystemTools = void 0;
 const zod_1 = require("zod");
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const createTool_1 = require("../../utils/createTool");
 const minimatch_1 = require("minimatch");
 const lib_1 = require("./lib");
@@ -89,7 +90,7 @@ const getFilesystemTools = (targetDir) => {
             "the contents of a single file. Use the 'head' parameter to read only " +
             "the first N lines of a file, or the 'tail' parameter to read only " +
             "the last N lines of a file. Operates on the file as text regardless of extension.",
-        parameters: ReadTextFileArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(ReadTextFileArgsSchema, 'ReadTextFileArgsSchema'),
         validateParams: ["path"],
         handler: readTextFileHandler
     });
@@ -100,7 +101,7 @@ const getFilesystemTools = (targetDir) => {
             "or compare multiple files. Each file's content is returned with its " +
             "path as a reference. Failed reads for individual files won't stop " +
             "the entire operation. Only works within allowed directories.",
-        parameters: ReadMultipleFilesArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(ReadMultipleFilesArgsSchema, 'ReadMultipleFilesArgsSchema'),
         validateParams: ["paths"],
         handler: async (args) => {
             const results = await Promise.all(args.paths.map(async (filePath) => {
@@ -123,7 +124,7 @@ const getFilesystemTools = (targetDir) => {
         description: "Create a new file or completely overwrite an existing file with new content. " +
             "Use with caution as it will overwrite existing files without warning. " +
             "Handles text content with proper encoding. Only works within allowed directories.",
-        parameters: WriteFileArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(WriteFileArgsSchema, 'WriteFileArgsSchema'),
         validateParams: ["path", "content"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -137,7 +138,7 @@ const getFilesystemTools = (targetDir) => {
         description: "Make line-based edits to a text file. Each edit replaces exact line sequences " +
             "with new content. Returns a git-style diff showing the changes made. " +
             "Only works within allowed directories.",
-        parameters: EditFileArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(EditFileArgsSchema, 'EditFileArgsSchema'),
         validateParams: ["path", "edits"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -151,7 +152,7 @@ const getFilesystemTools = (targetDir) => {
             "nested directories in one operation. If the directory already exists, " +
             "this operation will succeed silently. Perfect for setting up directory " +
             "structures for projects or ensuring required paths exist. Only works within allowed directories.",
-        parameters: CreateDirectoryArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(CreateDirectoryArgsSchema, 'CreateDirectoryArgsSchema'),
         validateParams: ["path"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -166,7 +167,7 @@ const getFilesystemTools = (targetDir) => {
             "Results clearly distinguish between files and directories with [FILE] and [DIR] " +
             "prefixes. This tool is essential for understanding directory structure and " +
             "finding specific files within a directory. Only works within allowed directories.",
-        parameters: ListDirectoryArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(ListDirectoryArgsSchema, 'ListDirectoryArgsSchema'),
         validateParams: ["path"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -183,7 +184,7 @@ const getFilesystemTools = (targetDir) => {
             "Results clearly distinguish between files and directories with [FILE] and [DIR] " +
             "prefixes. This tool is useful for understanding directory structure and " +
             "finding specific files within a directory. Only works within allowed directories.",
-        parameters: ListDirectoryWithSizesArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(ListDirectoryWithSizesArgsSchema, 'ListDirectoryWithSizesArgsSchema'),
         validateParams: ["path"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -238,7 +239,7 @@ const getFilesystemTools = (targetDir) => {
             "Each entry includes 'name', 'type' (file/directory), and 'children' for directories. " +
             "Files have no children array, while directories always have a children array (which may be empty). " +
             "The output is formatted with 2-space indentation for readability. Only works within allowed directories.",
-        parameters: DirectoryTreeArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(DirectoryTreeArgsSchema, 'DirectoryTreeArgsSchema'),
         validateParams: ["path"],
         handler: async (args) => {
             const rootPath = args.path;
@@ -283,7 +284,7 @@ const getFilesystemTools = (targetDir) => {
             "and rename them in a single operation. If the destination exists, the " +
             "operation will fail. Works across different directories and can be used " +
             "for simple renaming within the same directory. Both source and destination must be within allowed directories.",
-        parameters: MoveFileArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(MoveFileArgsSchema, 'MoveFileArgsSchema'),
         validateParams: ["source", "destination"],
         handler: async (args) => {
             const validSourcePath = await (0, lib_1.validatePath)(targetDir, args.source);
@@ -297,7 +298,7 @@ const getFilesystemTools = (targetDir) => {
         name: "search_files",
         description: "Search for files matching a specific pattern in a specified path. " +
             "Returns a list of files that match the pattern. Only works within allowed directories.",
-        parameters: SearchFilesArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(SearchFilesArgsSchema, 'SearchFilesArgsSchema'),
         validateParams: ["path", "pattern"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);
@@ -310,7 +311,7 @@ const getFilesystemTools = (targetDir) => {
         name: "get_file_info",
         description: "Get detailed information about a file, including its size, last modified time, and type. " +
             "Only works within allowed directories.",
-        parameters: GetFileInfoArgsSchema.toJSONSchema(),
+        parameters: (0, zod_to_json_schema_1.zodToJsonSchema)(GetFileInfoArgsSchema, 'GetFileInfoArgsSchema'),
         validateParams: ["path"],
         handler: async (args) => {
             const validPath = await (0, lib_1.validatePath)(targetDir, args.path);

package/lib/types/type.d.ts

@@ -1,4 +1,3 @@
-import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { Client } from "@modelcontextprotocol/sdk/client/index";
 export interface ApiConfig {
     baseURL: string;
@@ -27,12 +26,24 @@ export interface McpConfig {
 }
 export interface AgentOptions {
     targetDir?: string;
-    /** 外部传入的内置工具列表，不传则使用默认的 registerBuiltinTools */
     tools?: ToolInfo[];
     extraSystemPrompt?: any;
     maxTokens?: number;
+    /**
+     * only for chain agent
+     */
     apiConfig?: ApiConfig;
-    apiModel?: BaseChatModel;
+    /**
+     * only for chain agent
+     * extends BaseChatModel
+     */
+    apiModel?: any;
+    /**
+     * only for chain agent
+     */
     maxIterations?: number;
+    /**
+     * only for chain agent
+     */
     verbose?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber2pr/ai-agent",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "AI Assistant CLI.",
   "author": "saber2pr",
   "license": "ISC",
@@ -22,16 +22,21 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@langchain/core": "^1.1.18",
-    "@langchain/openai": "^1.2.4",
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "@saber2pr/ts-context-mcp": "^0.0.6",
-    "js-tiktoken": "^1.0.21",
-    "langchain": "~0.3",
-    "openai": "^6.16.0",
+    "@saber2pr/ts-context-mcp": "^0.0.8",
     "diff": "^8.0.3",
     "glob": "^10.5.0",
-    "minimatch": "^10.0.1"
+    "js-tiktoken": "^1.0.21",
+    "minimatch": "^10.0.1",
+    "openai": "^6.16.0",
+    "zod-to-json-schema": "3.23.2",
+    "langchain": "0.3.15",
+    "@langchain/core": "0.3.39",
+    "@langchain/openai": "0.4.0",
+    "zod": "3.23.8"
+  },
+  "resolutions": {
+    "@langchain/core": "0.3.39"
   },
   "devDependencies": {
     "@types/node": "^16.3.3",