@saber2pr/ai-agent 0.0.65 → 0.0.67

package/lib/core/agent-graph.js

@@ -185,7 +185,10 @@ class McpGraphAgent {
         if (this.options.filterTools) {
             allToolInfos = allToolInfos.filter(this.options.filterTools);
         }
-        this.langchainTools = allToolInfos.map((t) => (0, convertToLangChainTool_1.convertToLangChainTool)(t, { allTools: allToolInfos }));
+        this.langchainTools = allToolInfos.map((t) => (0, convertToLangChainTool_1.convertToLangChainTool)(t, {
+            allTools: allToolInfos,
+            agentOptions: this.options,
+        }));
         this.toolNode = new prebuilt_1.ToolNode(this.langchainTools);
         return {
             builtinToolInfos,

package/lib/tools/builtin.d.ts

@@ -1,4 +1,4 @@
-import { AgentOptions, ToolInfo } from '../types/type';
+import { AgentOptions, ToolInfo } from "../types/type";
 export interface BuiltinToolsContext {
     options?: AgentOptions;
 }

package/lib/tools/builtin.js

@@ -2,13 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultBuiltinTools = createDefaultBuiltinTools;
 const filesystem_1 = require("./filesystem");
-const get_all_tools_schema_1 = require("./loader/get_all_tools_schema");
 const ts_lsp_1 = require("./ts-lsp");
+const get_all_tools_schema_1 = require("./loader/get_all_tools_schema");
+const batch_run_tools_1 = require("./loader/batch_run_tools");
 function createDefaultBuiltinTools(context) {
     const { options } = context;
     return [
         ...(0, ts_lsp_1.getTsLspTools)(options?.targetDir || process.cwd()),
         ...(0, filesystem_1.getFilesystemTools)(options?.targetDir || process.cwd()),
         get_all_tools_schema_1.getAllToolsSchema,
+        batch_run_tools_1.batchRunTools,
     ];
 }

package/lib/tools/loader/batch_run_tools.d.ts

@@ -0,0 +1,2 @@
+import { ToolInfo } from '../../types/type';
+export declare const batchRunTools: ToolInfo;

package/lib/tools/loader/batch_run_tools.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchRunTools = void 0;
+const zod_1 = require("zod");
+const createTool_1 = require("../../utils/createTool");
+const kit_1 = require("../../utils/kit");
+exports.batchRunTools = (0, createTool_1.createTool)({
+    name: 'batch_run_tools',
+    // 使用更具指令性的英文描述
+    description: `Execute multiple tools in parallel. Use this for independent tasks such as reading multiple files, applying unrelated edits to different files, or fetching diagnostics simultaneously. CRITICAL: DO NOT apply multiple edits to the same file within a single batch to avoid write conflicts.`,
+    parameters: zod_1.z.object({
+        actions: zod_1.z.array(zod_1.z.object({
+            // 字段名和描述对齐 AI 习惯
+            tool_name: zod_1.z.string().describe('The name of the tool to execute.'),
+            args: zod_1.z.any().describe('The JSON object containing arguments for the specific tool.')
+        })).describe('A list of tool-calling actions to be executed concurrently.')
+    }),
+    handler: async ({ actions }, context) => {
+        // 1. 获取所有可用工具的映射
+        const toolMap = (0, kit_1.getArray)(context?.allTools).reduce((acc, tool) => ({ ...acc, [tool.function.name]: tool }), {});
+        if (Object.keys(toolMap).length === 0) {
+            return 'Error: Failed to retrieve tool execution context.';
+        }
+        // 2. 并行执行所有 Action
+        const results = await Promise.all(actions.map(async (action) => {
+            const { tool_name, args } = action;
+            const tool = toolMap[tool_name];
+            if (!tool) {
+                return {
+                    tool_name,
+                    status: 'error',
+                    output: `Tool not found: ${tool_name}`
+                };
+            }
+            try {
+                // 特别注意：这里调用的是 _handler，请确保参数 args 的结构与子工具 Zod 定义一致
+                const output = await tool._handler(args, context);
+                return {
+                    tool_name,
+                    status: 'success',
+                    output
+                };
+            }
+            catch (error) {
+                return {
+                    tool_name,
+                    status: 'error',
+                    output: error?.message || String(error)
+                };
+            }
+        }));
+        // 3. 格式化输出结果
+        // 虽然参数改成了英文，但返回给 AI 的结果标题可以保留清晰的结构
+        return results.map(res => `### Tool: ${res.tool_name} (${res.status})\n${res.output}\n---`).join('\n');
+    }
+});

package/lib/tools/loader/get_all_tools_schema.js

@@ -9,25 +9,36 @@ const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const createTool_1 = require("../../utils/createTool");
 const generateToolMarkdown_1 = require("../../utils/generateToolMarkdown");
 const kit_1 = require("../../utils/kit");
+const getSystemPromptTemplate_1 = require("../../utils/getSystemPromptTemplate");
 exports.getAllToolsSchema = (0, createTool_1.createTool)({
-    name: 'get_all_tools_schema',
+    name: "get_all_tools_schema",
     description: 'Use this tool when you encounter a "tool not found" error or are unsure about the parameter schema. It retrieves the full definitions and JSON schemas for all available tools in the current environment.',
     parameters: zod_1.z.object({
-        toolName: zod_1.z.string().optional().describe('Optional: Specify a tool name to get its detailed schema. If omitted, returns all available tools.')
+        toolName: zod_1.z
+            .string()
+            .optional()
+            .describe("Optional: Specify a tool name to get its detailed schema. If omitted, returns all available tools."),
     }),
     // 增加第二个参数 context
     handler: async ({ toolName }, context) => {
         // 这里的 context.allTools 是在运行时从 Agent 实例传入的
         const availableTools = (0, kit_1.getArray)(context?.allTools);
         const targetTools = toolName
-            ? availableTools.filter(t => t.function.name === toolName)
+            ? availableTools.filter((t) => t.function.name === toolName)
             : availableTools;
-        return (0, generateToolMarkdown_1.generateToolMarkdown)(targetTools.map(item => ({
+        let remainPrompt = "";
+        if (context?.agentOptions) {
+            // 如果AI忘记了工具用法，说明出现了记忆模糊，这里把系统提示词再补充上，加强记忆
+            const systemPrompt = (0, getSystemPromptTemplate_1.getSystemPromptTemplate)(context.agentOptions.targetDir);
+            remainPrompt = `${systemPrompt || ""}\n${context?.agentOptions?.extraSystemPrompt || ""}`;
+        }
+        const toolsMarkdown = (0, generateToolMarkdown_1.generateToolMarkdown)(targetTools.map((item) => ({
             ...item,
             function: {
                 ...item.function,
-                parameters: (0, zod_to_json_schema_1.default)(item.function.parameters)
-            }
+                parameters: (0, zod_to_json_schema_1.default)(item.function.parameters),
+            },
         })));
-    }
+        return `${remainPrompt}\n${toolsMarkdown}`;
+    },
 });

package/lib/types/type.d.ts

@@ -15,6 +15,7 @@ export interface ToolInfo {
     };
     _handler?: (args: any, context: {
         allTools: ToolInfo[];
+        agentOptions?: GraphAgentOptions;
     }) => Promise<any>;
     _client?: Client;
     _originalName?: string;

package/lib/utils/convertToLangChainTool.d.ts

@@ -1,7 +1,8 @@
 import { DynamicStructuredTool } from '@langchain/core/tools';
-import { ToolInfo } from '../types/type';
+import { GraphAgentOptions, ToolInfo } from '../types/type';
 export declare function convertToLangChainTool(info: ToolInfo, context: {
     allTools: ToolInfo[];
+    agentOptions: GraphAgentOptions;
 }): DynamicStructuredTool<import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
     [x: string]: any;
 }, {

package/lib/utils/createTool.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { ToolInfo } from '../types/type';
+import { z } from "zod";
+import { GraphAgentOptions, ToolInfo } from "../types/type";
 export interface CreateToolOptions {
     name: string;
     description: string;
@@ -9,6 +9,7 @@ export interface CreateToolOptions {
     parameters: z.ZodObject<any>;
     handler: (args: any, context: {
         allTools: ToolInfo[];
+        agentOptions?: GraphAgentOptions;
     }) => Promise<string>;
 }
 export declare function createTool(options: CreateToolOptions): ToolInfo;

package/lib/utils/createTool.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTool = createTool;
 function createTool(options) {
     return {
-        type: 'function',
+        type: "function",
         function: {
             name: options.name,
             description: options.description,
@@ -12,7 +12,7 @@ function createTool(options) {
         _handler: async (input, context) => {
             // 兼容处理：如果 input 是字符串，尝试解析为 JSON 对象
             let args = input;
-            if (typeof input === 'string') {
+            if (typeof input === "string") {
                 try {
                     args = JSON.parse(input);
                 }

package/lib/utils/formatSchema.js

@@ -6,18 +6,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSchema = formatSchema;
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 function formatSchema(schema) {
-    const res = (0, zod_to_json_schema_1.default)(schema);
-    if (typeof res.properties === 'object') {
-        const requiredKeys = res.required || [];
+    const jsonSchema = (0, zod_to_json_schema_1.default)(schema);
+    // 递归处理函数
+    const processProperties = (properties, required = [], level = 0) => {
+        if (!properties || typeof properties !== 'object')
+            return '';
+        const indent = '  '.repeat(level);
         const lines = [];
-        for (const key in res.properties) {
-            lines.push(`     - ${key}: ${res.properties[key].type}${requiredKeys.includes(key) ? ' (required)' : ''}`);
+        for (const key in properties) {
+            const prop = properties[key];
+            const isRequired = required.includes(key);
+            // 1. 基础描述
+            let line = `${indent}- ${key}: ${prop.type || 'any'}${isRequired ? ' (required)' : ''}`;
+            if (prop.description)
+                line += ` - ${prop.description}`;
+            lines.push(line);
+            // 2. 递归处理数组 (Items)
+            if (prop.type === 'array' && prop.items) {
+                lines.push(`${indent}  Items:`);
+                if (prop.items.type === 'object' && prop.items.properties) {
+                    lines.push(processProperties(prop.items.properties, prop.items.required, level + 2));
+                }
+                else {
+                    lines.push(`${indent}    - Type: ${prop.items.type || 'any'}`);
+                }
+            }
+            // 3. 递归处理嵌套对象 (Object)
+            if (prop.type === 'object' && prop.properties) {
+                lines.push(processProperties(prop.properties, prop.required, level + 1));
+            }
         }
-        if (lines.length > 0) {
-            return lines.join('\n');
-        }
-        return 'No parameters';
+        return lines.join('\n');
+    };
+    if (jsonSchema.properties) {
+        const result = processProperties(jsonSchema.properties, jsonSchema.required, 2); // 保持你原来的缩进感
+        return result || 'No parameters';
     }
     const keys = Object.keys(schema.shape);
-    return keys.join(', ');
+    return keys.length > 0 ? keys.join(', ') : 'No parameters';
 }

package/lib/utils/generateToolMarkdown.d.ts

@@ -1,5 +1 @@
-/**
- * 将工具定义从 Zod Schema 转换为极简 Markdown 格式
- * 目的：显著节省 System Prompt 的 Token，同时保持 LLM 理解力
- */
 export declare function generateToolMarkdown(tools: any[]): string;

package/lib/utils/generateToolMarkdown.js

@@ -7,20 +7,41 @@ const kit_1 = require("./kit");
  * 将工具定义从 Zod Schema 转换为极简 Markdown 格式
  * 目的：显著节省 System Prompt 的 Token，同时保持 LLM 理解力
  */
+/**
+ * 递归解析 JSON Schema 并生成简化的 Markdown
+ */
+function parseSchemaRecursive(schema, indent = '') {
+    if (!schema)
+        return '';
+    let res = '';
+    // 1. 处理对象类型 (Object)
+    if (schema.type === 'object' && schema.properties) {
+        Object.entries(schema.properties).forEach(([key, val]) => {
+            const isReq = schema.required?.includes(key);
+            const type = val.type || (val.anyOf ? 'any' : 'unknown');
+            const desc = val.description ? `: ${val.description}` : '';
+            res += `${indent}- \`${key}\` (${type}${isReq ? ', required' : ''})${desc}\n`;
+            // 递归处理嵌套对象或数组
+            res += parseSchemaRecursive(val, indent + '  ');
+        });
+    }
+    // 2. 处理数组类型 (Array)
+    else if (schema.type === 'array' && schema.items) {
+        // 标注数组项的结构
+        res += `${indent}  *Items:* \n${parseSchemaRecursive(schema.items, indent + '    ')}`;
+    }
+    return res;
+}
 function generateToolMarkdown(tools) {
     let markdown = "## Tool Definitions\n\n";
     (0, kit_1.getArray)(tools).forEach((tool) => {
+        // 假设 cleanToolDefinition 返回的是符合 JSON Schema 规范的对象
         const { name, description, parameters } = (0, cleanToolDefinition_1.cleanToolDefinition)(tool);
         markdown += `- **${name}**: ${description}\n`;
-        // 提取 Zod 参数
-        const shape = parameters.properties || {};
-        const requiredFields = parameters.required || [];
-        Object.entries(shape).forEach(([paramName, schema]) => {
-            const isRequired = requiredFields.includes(paramName);
-            const type = schema.type.replace('Zod', '').toLowerCase();
-            const desc = schema.description || schema.title || '';
-            markdown += `  - \`${paramName}\` (${type}${isRequired ? ', required' : ''})${desc ? `: ${desc}` : ''}\n`;
-        });
+        // 从根部开始递归解析参数
+        if (parameters && parameters.type === 'object') {
+            markdown += parseSchemaRecursive(parameters, '  ');
+        }
         markdown += "\n";
     });
     return markdown;

package/lib/utils/getSystemPromptTemplate.js

@@ -4,15 +4,24 @@ exports.getSystemPromptTemplate = void 0;
 const getSystemPromptTemplate = (targetDir) => {
     return `You are an expert software engineer. Working directory: ${targetDir}.
 
-# 🧠 Mandatory Thinking Process
+# Mandatory Thinking Process
 Before providing any output or calling a tool, you **MUST** conduct a deep logical analysis. Wrap your thought process within <think> tags.
 
-# 🛠️ Tool Call Specifications
+# Tool Call Specifications
 1. **Pure JSON Arguments**: Arguments must be a valid JSON object. NEVER wrap the entire JSON object in a string or quotes.
 2. **No Double Escaping**: Do not double-escape characters within the JSON.
 3. **No Idle Operations**: If the task is complete or no tool is needed, DO NOT output any "Action" structure. Never use "None", "null", or empty strings as a tool name.
+4. **Important Note**: For optimal efficiency, when performing multiple operations, use batch_run_tools to invoke all relevant tools in parallel, rather than sequentially. Prioritize parallel tool invocation whenever possible. For example, when reading three files, run three tool invocations in parallel to read all three files into the context simultaneously. When running multiple read-only commands (such as read_file_range, grep_search, or read_text_file), always run all commands in parallel. Use parallel tool invocations whenever possible, rather than running too many tools sequentially.
 
-# 🎯 Core Instructions
+# Researching Unfamiliar Symbols (Must Follow)
+1. **No Guesswork**: When encountering any API, function, class, variable, constant, or type that is not defined within the current context, you are strictly prohibited from writing code based on intuition or assumptions.
+2. **Proactive Traceability**: You must initiate the "Search-Read-Understand" cycle immediately:
+  2.1 **Search**: Use grep_search to locate relevant definitions and find the Top 3 typical usage examples within the project.
+  2.2 **Read**: Use batch_run_tools to concurrently read both the definition files and the identified usage examples.
+  2.3 **Analyze**: Conduct a deep analysis of the parameter structures, implementation logic, invocation patterns, and error-handling strategies.
+3. **Code Consistency**: When implementing code, you must strictly replicate the established best practices and patterns found within the project.
+
+# Core Instructions
 1. **Termination Criterion**: Once you have read the requested files, answered the questions, or completed the code implementation, you must provide the final response immediately.
 2. **Response Format**: Upon task completion, start your summary with "Final Answer:". No further tool calls should be made after this point.
 `.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saber2pr/ai-agent",
-  "version": "0.0.65",
+  "version": "0.0.67",
   "description": "AI Assistant CLI.",
   "author": "saber2pr",
   "license": "ISC",