@saber2pr/ai-agent 0.0.14 → 0.0.15

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,12 @@ export default class McpChainAgent {
     private apiConfig;
     private maxIterations;
     private apiModel?;
-    private targetDir;
-    private verbose;
+    private memory?;
+    private systemPrompt;
     private runningTokenCounter;
     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,149 +39,106 @@ 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 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 memory_1 = require("langchain/memory");
+const readline = __importStar(require("readline"));
 const config_1 = require("../config/config");
 const jsonSchemaToZod_1 = require("../utils/jsonSchemaToZod");
 const builtin_1 = require("../tools/builtin");
 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 输出的字段
         });
-        // 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),
+        }));
+        // 2. 构造支持 Memory 的 Prompt
+        const prompt = prompts_1.PromptTemplate.fromTemplate(`{system_prompt}
+
+### 历史记录摘要及近期对话：
+{chat_history}
 
-### 🛠 可用工具列表 (TOOLS)
---------------------
+### 可用工具：
 {tools}
 
 工具名称列表: [{tool_names}]
 
-### 📝 交互协议格式 (PROTOCOL)
---------------------
-你必须严格遵守以下回复格式：
-
-Thought: 首先，我会[此处用中文简述你的分析思路和下一步目标]。
+### 交互协议：
+Thought: [你的中文分析思路]
 \`\`\`json
 {{
   "action": "工具名称",
@@ -189,10 +146,6 @@ Thought: 首先，我会[此处用中文简述你的分析思路和下一步目
 }}
 \`\`\`
 
-注意：
-- 严禁直接输出 JSON，必须先写 Thought。
-- Thought 必须包含具体的分析意图，不少于 10 个字。
-
 Begin!
 Question: {input}
 Thought: {agent_scratchpad}`);
@@ -200,61 +153,35 @@ Thought: {agent_scratchpad}`);
         this.executor = new agents_1.AgentExecutor({
             agent,
             tools: langchainTools,
-            verbose: this.verbose, // 我们已经有了 wrapHandler 日志，关闭原生 verbose 以保持整洁
+            memory: this.memory, // 挂载内存模块
+            verbose: false,
             handleParsingErrors: true,
             maxIterations: this.maxIterations
         });
     }
     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 thought = action.log.split(/```json|\{/)[0].replace(/Thought:/i, "").trim();
+                            if (thought && !thought.startsWith('{')) {
+                                console.log(`\n💭 [思考]: ${thought.split('\n')[0]}`);
                             }
                         }
                     }]
             });
-            // 修复点：确保 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 +194,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 +207,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 +221,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber2pr/ai-agent",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "AI Assistant CLI.",
   "author": "saber2pr",
   "license": "ISC",
@@ -25,13 +25,13 @@
     "@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",
+    "langchain": "~0.3",
+    "minimatch": "^10.0.1",
+    "openai": "^6.16.0"
   },
   "devDependencies": {
     "@types/node": "^16.3.3",