@saber2pr/ai-agent 0.0.10 → 0.0.12

package/README.md

@@ -111,7 +111,7 @@ class MyPrivateLLM extends BaseChatModel {
 | ----------------- | ------------------------------------------------------------------------ |
 | `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_full_code`  | Reads file content with line numbers for precise auditing.               |
+| `read_text_file`  | Reads file content with line numbers for precise auditing.               |
 | `read_skeleton`   | Extracts class/function signatures without full logic (Token efficient). |
 
 ---

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

@@ -16,8 +16,7 @@ export default class McpChainAgent {
      * 工具处理器包装逻辑：增加日志打印和 Token 监控
      */
     private wrapHandler;
-    private registerBuiltinTools;
-    private injectCustomTools;
+    private initTools;
     private calculateTokens;
     private pruneMessages;
     init(): Promise<void>;

package/lib/core/agent-chain.js

@@ -43,12 +43,11 @@ 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 builtin_1 = require("../tools/builtin");
 const config_1 = require("../config/config");
 const jsonSchemaToZod_1 = require("../utils/jsonSchemaToZod");
+const builtin_1 = require("../tools/builtin");
 class McpChainAgent {
     constructor(options) {
-        var _a;
         this.allTools = [];
         this.messages = [];
         this.encoder = (0, js_tiktoken_1.getEncoding)("cl100k_base");
@@ -66,7 +65,7 @@ class McpChainAgent {
 1. **全局扫描（强制首选）**：在开始任何分析任务前，你【必须】首先调用 'get_repo_map'。这是理解项目结构、技术栈及模块关系的唯一来源。
 2. **循序渐进的分析路径**：
    - 优先使用 'read_skeleton' 提取接口和函数签名。
-   - 仅在需要分析具体逻辑或准备修复代码时，才使用 'read_full_code'。
+   - 仅在需要分析具体逻辑或准备修复代码时，才使用 'read_text_file'。
 3. **真实性原则**：所有的代码分析必须基于工具返回的真实内容，严禁虚假猜测。`;
         this.messages.push({
             role: "system",
@@ -74,20 +73,7 @@ class McpChainAgent {
                 ? `${baseSystemPrompt}\n\n[额外指令]:\n${JSON.stringify(options.extraSystemPrompt)}`
                 : baseSystemPrompt,
         });
-        if ((_a = options === null || options === void 0 ? void 0 : options.builtinTools) === null || _a === void 0 ? void 0 : _a.length) {
-            this.allTools.push(...options.builtinTools.map((t) => ({
-                type: t.type,
-                function: t.function,
-                _handler: this.wrapHandler(t.function.name, t._handler),
-            })));
-        }
-        else {
-            this.registerBuiltinTools({
-                ...options,
-                ...this,
-            });
-        }
-        this.injectCustomTools();
+        this.initTools(options);
     }
     /**
      * 工具处理器包装逻辑：增加日志打印和 Token 监控
@@ -108,24 +94,23 @@ class McpChainAgent {
             return content;
         };
     }
-    registerBuiltinTools(options) {
-        const defaults = (0, builtin_1.createDefaultBuiltinTools)({
-            options,
-            getCurrentTokens: () => this.calculateTokens(),
-        });
-        this.allTools.push(...defaults.map((t) => ({
-            type: t.type,
-            function: t.function,
-            _handler: this.wrapHandler(t.function.name, t._handler),
-        })));
-    }
-    injectCustomTools() {
-        for (const tool of this.extraTools) {
-            this.allTools.push({
-                type: "function",
-                function: { name: tool.name, description: tool.description, parameters: tool.parameters },
-                _handler: this.wrapHandler(tool.name, tool.handler),
-            });
+    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() {
@@ -174,6 +159,7 @@ class McpChainAgent {
                 },
             });
         });
+        // src/core/agent-chain.ts 中的 prompt 修改
         const prompt = prompts_1.PromptTemplate.fromTemplate(`
 {system_prompt}
 
@@ -187,7 +173,7 @@ class McpChainAgent {
 --------------------
 你必须严格遵守以下回复格式：
 
-Thought: [此处写下你的思考过程]
+Thought: 首先，我会[此处用中文简述你的分析思路和下一步目标]。
 \`\`\`json
 {{
   "action": "工具名称",
@@ -196,8 +182,8 @@ Thought: [此处写下你的思考过程]
 \`\`\`
 
 注意：
-- 每次调用工具前必须先写 Thought。
-- 最终结论请使用 "action": "Final Answer"。
+- 严禁直接输出 JSON，必须先写 Thought。
+- Thought 必须包含具体的分析意图，不少于 10 个字。
 
 Begin!
 Question: {input}
@@ -227,29 +213,34 @@ Thought: {agent_scratchpad}`);
                 // --- 新增：使用回调函数捕获 Thought ---
                 callbacks: [{
                         handleAgentAction: (action, runId) => {
-                            // action.log 包含了 LLM 输出的所有文本（包含 Thought 和 JSON）
                             if (action.log) {
                                 const log = action.log.trim();
-                                // 正则说明：匹配 Thought: 到 ```json 或 { 之间的内容
-                                const thoughtMatch = log.match(/Thought:\s*([\s\S]*?)(?=(?:```json|\{|$))/i);
+                                // 1. 提取 Thought 部分：取 Thought: 之后，直到遇到 ```json 或 { 之前的内容
+                                const thoughtMatch = log.match(/Thought:\s*([\s\S]*?)(?=(?:```json|\{|Action:|$))/i);
+                                let thought = "";
                                 if (thoughtMatch && thoughtMatch[1]) {
-                                    const thought = thoughtMatch[1].trim();
-                                    if (thought) {
-                                        console.log(`\n💭 [思考]: ${thought}`);
-                                    }
+                                    thought = thoughtMatch[1].trim();
+                                }
+                                else {
+                                    // 备选方案：如果没有 Thought 标签，直接截取 JSON 之前的文本
+                                    thought = log.split(/```json|\{/)[0].replace(/Thought:/i, "").trim();
                                 }
-                                else if (!log.startsWith('{') && !log.startsWith('```')) {
-                                    // 备选方案：如果没匹配到 Thought 标签，但有非 JSON 开头的文字，也打印出来
-                                    const rawThought = log.split(/```json|\{/)[0].trim();
-                                    if (rawThought) {
-                                        console.log(`\n💭 [思考]: ${rawThought}`);
+                                // 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}`);
                                     }
                                 }
                             }
                         }
                     }]
             });
-            let output = response.output;
+            // 修复点：确保 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;

package/lib/core/agent.d.ts

@@ -15,7 +15,7 @@ export default class McpAgent {
      * 兼容多模态内容 (Content Parts) 和 工具调用 (Tool Calls)
      */
     private calculateTokens;
-    private injectCustomTools;
+    private initTools;
     /**
      * 核心功能：内置代码分析工具（基于 engine/targetDir，可被外部通过 createDefaultBuiltinTools 替代）
      */

package/lib/core/agent.js

@@ -48,7 +48,6 @@ const builtin_1 = require("../tools/builtin");
 const config_1 = require("../config/config");
 class McpAgent {
     constructor(options) {
-        var _a;
         this.modelName = "";
         this.allTools = [];
         this.messages = [];
@@ -64,7 +63,7 @@ class McpAgent {
     1. **全局扫描（强制首选）**：在开始任何分析任务前，你【必须】首先调用 'get_repo_map'。这是你理解项目目录结构、技术栈及模块关系的唯一权威来源。
     2. **循序渐进的分析路径**：
        - 优先使用 'read_skeleton' 提取接口、类和函数签名，以最低的 Token 成本建立代码逻辑视图。
-       - 仅在需要深入分析具体业务逻辑、提取精准代码块或进行代码修改建议时，才使用 'read_full_code' 或 'get_method_body'。
+       - 仅在需要深入分析具体业务逻辑、提取精准代码块或进行代码修改建议时，才使用 'read_text_file' 或 'get_method_body'。
     3. **真实性原则**：
        - 所有的代码分析、行号定位和逻辑推断必须基于工具返回的真实内容，严禁基于文件名进行虚假猜测。
        - 如果工具返回结果为空或报错，应尝试调整路径或更换工具。
@@ -87,17 +86,7 @@ class McpAgent {
             role: "system",
             content: baseSystemPrompt,
         });
-        // 初始化内置工具：外部传入则使用，否则走默认 registerBuiltinTools
-        if ((_a = options === null || options === void 0 ? void 0 : options.builtinTools) === null || _a === void 0 ? void 0 : _a.length) {
-            this.allTools.push(...options.builtinTools);
-        }
-        else {
-            this.registerBuiltinTools({
-                ...options,
-                ...this,
-            });
-        }
-        this.injectCustomTools(); // 注入外部工具
+        this.initTools(options); // 注入外部工具
     }
     /**
      * 计算当前消息列表的总 Token 消耗
@@ -141,17 +130,19 @@ class McpAgent {
         }
         return total;
     }
-    injectCustomTools() {
-        for (const tool of this.extraTools) {
-            this.allTools.push({
-                type: "function",
-                function: {
-                    name: tool.name,
-                    description: tool.description,
-                    parameters: tool.parameters,
-                },
-                _handler: tool.handler,
-            });
+    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);
         }
     }
     /**
@@ -160,7 +151,6 @@ class McpAgent {
     registerBuiltinTools(options) {
         this.allTools.push(...(0, builtin_1.createDefaultBuiltinTools)({
             options,
-            getCurrentTokens: () => this.calculateTokens(),
         }));
     }
     // --- 初始化与环境准备 (API Config & MCP Servers) ---

package/lib/index.d.ts

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

package/lib/index.js

@@ -17,9 +17,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.McpChainAgent = void 0;
+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; } });
 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; } });

package/lib/tools/builtin.d.ts

@@ -1,7 +1,5 @@
 import { AgentOptions, ToolInfo } from '../types/type';
 export interface BuiltinToolsContext {
     options?: AgentOptions;
-    /** 可选：获取当前已用 token 数 */
-    getCurrentTokens?: () => number;
 }
 export declare function createDefaultBuiltinTools(context: BuiltinToolsContext): ToolInfo[];

package/lib/tools/builtin.js

@@ -1,98 +1,12 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultBuiltinTools = createDefaultBuiltinTools;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const ts_context_mcp_1 = require("@saber2pr/ts-context-mcp");
-const createTool_1 = require("../utils/createTool");
+const filesystem_1 = require("./filesystem");
+const ts_lsp_1 = require("./ts-lsp");
 function createDefaultBuiltinTools(context) {
-    const { options, getCurrentTokens } = context;
-    const engine = new ts_context_mcp_1.PromptEngine((options === null || options === void 0 ? void 0 : options.targetDir) || process.cwd());
-    const maxTokens = (options === null || options === void 0 ? void 0 : options.maxTokens) || 100000;
-    const rootDir = () => engine.getRootDir();
+    const { options } = context;
     return [
-        (0, createTool_1.createTool)({
-            maxTokens,
-            getCurrentTokens,
-            name: "get_repo_map",
-            description: "获取项目全局文件结构及导出清单，用于快速定位代码",
-            parameters: { type: "object", properties: {} },
-            handler: async () => {
-                engine.refresh();
-                return engine.getRepoMap();
-            },
-        }),
-        (0, createTool_1.createTool)({
-            maxTokens,
-            getCurrentTokens,
-            name: "analyze_deps",
-            description: "分析指定文件的依赖关系，支持 tsconfig 路径别名解析",
-            parameters: { type: "object", properties: { filePath: { type: "string", description: "文件相对路径", required: true } } },
-            validateParams: ["filePath"],
-            handler: async ({ filePath }) => engine.getDeps(filePath),
-        }),
-        (0, createTool_1.createTool)({
-            maxTokens,
-            getCurrentTokens,
-            name: "read_skeleton",
-            description: "提取文件的结构定义（接口、类、方法签名），忽略具体实现以节省 Token",
-            parameters: { type: "object", properties: { filePath: { type: "string", description: "文件相对路径" } } },
-            handler: async (args) => {
-                const pathArg = args === null || args === void 0 ? void 0 : args.filePath;
-                if (typeof pathArg !== "string" || pathArg.trim() === "") {
-                    return `Error: 参数 'filePath' 无效。收到的是: ${JSON.stringify(pathArg)}`;
-                }
-                try {
-                    engine.refresh();
-                    const result = engine.getSkeleton(pathArg);
-                    return result || `// Warning: 文件 ${pathArg} 存在但未找到任何可提取的结构。`;
-                }
-                catch (error) {
-                    return `Error: 解析文件 ${pathArg} 时发生内部错误: ${error.message}`;
-                }
-            },
-        }),
-        (0, createTool_1.createTool)({
-            maxTokens,
-            getCurrentTokens,
-            name: "get_method_body",
-            description: "获取指定文件内某个方法或函数的完整实现代码",
-            parameters: { type: "object", properties: { filePath: { type: "string", description: "文件相对路径" }, methodName: { type: "string", description: "方法名或函数名" } } },
-            handler: async ({ filePath, methodName }) => {
-                return engine.getMethodImplementation(filePath, methodName);
-            },
-        }),
-        (0, createTool_1.createTool)({
-            maxTokens,
-            getCurrentTokens,
-            name: "read_full_code",
-            description: "读取指定文件的完整源代码内容。当需要分析具体实现逻辑或查找硬编码字符串时使用。",
-            parameters: { type: "object", properties: { filePath: { type: "string", description: "文件相对路径" } } },
-            handler: async ({ filePath }) => {
-                try {
-                    if (typeof filePath !== "string" || !filePath) {
-                        return "Error: filePath 不能为空";
-                    }
-                    const fullPath = path_1.default.resolve(rootDir(), filePath);
-                    if (!fullPath.startsWith(rootDir())) {
-                        return "Error: 权限拒绝，禁止访问项目目录外的文件。";
-                    }
-                    if (!fs_1.default.existsSync(fullPath)) {
-                        return `Error: 文件不存在: ${filePath}`;
-                    }
-                    const content = fs_1.default.readFileSync(fullPath, "utf-8");
-                    return content
-                        .split("\n")
-                        .map((line, i) => `${i + 1} | ${line}`)
-                        .join("\n");
-                }
-                catch (err) {
-                    return `Error: 读取文件失败: ${err.message}`;
-                }
-            },
-        }),
+        ...(0, ts_lsp_1.getTsLspTools)((options === null || options === void 0 ? void 0 : options.targetDir) || process.cwd()),
+        ...(0, filesystem_1.getFilesystemTools)((options === null || options === void 0 ? void 0 : options.targetDir) || process.cwd()),
     ];
 }

package/lib/tools/filesystem/index.d.ts

@@ -0,0 +1 @@
+export declare const getFilesystemTools: (targetDir: string) => import("../../types/type").ToolInfo[];