lcagent-cli 0.1.5 → 0.1.6

package/README.md

@@ -139,6 +139,14 @@ npm run start -- model
 npm run start -- doctor
 ```
 
+当模型触发工具时，CLI 会打印：
+
+- `[tool-call] 工具名`：后面跟模型传入的原始 JSON 参数
+- `[tool-result] 工具名`：显示工具执行结果
+- `[tool-result] 工具名 (error)`：显示工具失败原因
+
+这样可以直接看出是模型参数字段名不对、路径不对，还是工具执行本身报错。
+
 ## 设计目标
 
 - 保留 Claude Code 式的核心代理循环

package/dist/bin/cli.js

@@ -46,6 +46,32 @@ function questionAsync(rl, prompt) {
         });
     });
 }
+function formatToolInput(input) {
+    try {
+        return JSON.stringify(input, null, 2);
+    }
+    catch {
+        return String(input);
+    }
+}
+function printEvent(event) {
+    switch (event.type) {
+        case 'status':
+            console.log(`\n[status] ${event.message}`);
+            break;
+        case 'assistant_text':
+            console.log(`\n${event.text}`);
+            break;
+        case 'tool_call':
+            console.log(`\n[tool-call] ${event.toolName}`);
+            console.log(formatToolInput(event.input));
+            break;
+        case 'tool_result':
+            console.log(`\n[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
+            console.log(event.result);
+            break;
+    }
+}
 async function probeUrl(url) {
     try {
         const response = await fetchWithTimeout(url, {
@@ -205,21 +231,7 @@ async function runDoctor() {
 async function printAgentRun(prompt) {
     const { engine } = await createApp(process.cwd());
     for await (const event of engine.submit(prompt)) {
-        switch (event.type) {
-            case 'status':
-                console.log(`\n[status] ${event.message}`);
-                break;
-            case 'assistant_text':
-                console.log(`\n${event.text}`);
-                break;
-            case 'tool_call':
-                console.log(`\n[tool] ${event.toolName} ${JSON.stringify(event.input)}`);
-                break;
-            case 'tool_result':
-                console.log(`\n[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
-                console.log(event.result);
-                break;
-        }
+        printEvent(event);
     }
 }
 async function runChat() {
@@ -237,21 +249,7 @@ async function runChat() {
                 break;
             }
             for await (const event of engine.submit(line)) {
-                switch (event.type) {
-                    case 'status':
-                        console.log(`[status] ${event.message}`);
-                        break;
-                    case 'assistant_text':
-                        console.log(event.text);
-                        break;
-                    case 'tool_call':
-                        console.log(`[tool] ${event.toolName} ${JSON.stringify(event.input)}`);
-                        break;
-                    case 'tool_result':
-                        console.log(`[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
-                        console.log(event.result);
-                        break;
-                }
+                printEvent(event);
             }
         }
     }

package/dist/tools/editFile.d.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
-    oldText: z.ZodString;
-    newText: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodString>;
+    oldText: z.ZodOptional<z.ZodString>;
+    old_text: z.ZodOptional<z.ZodString>;
+    newText: z.ZodOptional<z.ZodString>;
+    new_text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const editFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/editFile.js

@@ -2,9 +2,13 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    path: z.string().min(1),
-    oldText: z.string(),
-    newText: z.string(),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
+    oldText: z.string().optional(),
+    old_text: z.string().optional(),
+    newText: z.string().optional(),
+    new_text: z.string().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
@@ -31,18 +35,27 @@ export const editFileTool = {
                 content: 'edit_file is blocked in manual approval mode. Switch config approvalMode to auto to enable file edits.',
             };
         }
-        const absolutePath = resolvePath(context.cwd, input.path);
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        const oldText = input.oldText ?? input.old_text;
+        const newText = input.newText ?? input.new_text;
+        if (!normalizedPath || oldText === undefined || newText === undefined) {
+            return {
+                isError: true,
+                content: 'Missing required fields: path, oldText, or newText',
+            };
+        }
+        const absolutePath = resolvePath(context.cwd, normalizedPath);
         const current = await readFile(absolutePath, 'utf8');
-        if (!current.includes(input.oldText)) {
+        if (!current.includes(oldText)) {
             return {
                 isError: true,
                 content: 'oldText was not found in the target file.',
             };
         }
-        const next = current.replace(input.oldText, input.newText);
+        const next = current.replace(oldText, newText);
         await writeFile(absolutePath, next, 'utf8');
         return {
-            content: `Updated ${input.path}`,
+            content: `Updated ${normalizedPath}`,
         };
     },
 };

package/dist/tools/execute.js

@@ -13,5 +13,13 @@ export async function executeToolCall(toolUse, tools, context) {
             content: parsed.error.message,
         };
     }
-    return tool.execute(parsed.data, context);
+    try {
+        return await tool.execute(parsed.data, context);
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: error instanceof Error ? error.message : String(error),
+        };
+    }
 }

package/dist/tools/grep.d.ts

@@ -1,10 +1,14 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    pattern: z.ZodString;
+    pattern: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
+    directory: z.ZodOptional<z.ZodString>;
     maxResults: z.ZodOptional<z.ZodNumber>;
+    max_results: z.ZodOptional<z.ZodNumber>;
     isRegex: z.ZodOptional<z.ZodBoolean>;
+    is_regex: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const grepTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/grep.js

@@ -2,10 +2,14 @@ import { readdir, readFile } from 'node:fs/promises';
 import { extname, isAbsolute, join, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    pattern: z.string().min(1),
+    pattern: z.string().min(1).optional(),
+    query: z.string().min(1).optional(),
     path: z.string().optional(),
+    directory: z.string().optional(),
     maxResults: z.number().int().positive().max(200).optional(),
+    max_results: z.number().int().positive().max(200).optional(),
     isRegex: z.boolean().optional(),
+    is_regex: z.boolean().optional(),
 });
 const textExtensions = new Set([
     '.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.txt', '.yml', '.yaml', '.css', '.html', '.mjs', '.cjs', '.sh', '.py', '.java', '.go', '.rs'
@@ -44,17 +48,26 @@ export const grepTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const root = input.path
-            ? isAbsolute(input.path)
-                ? input.path
-                : resolve(context.cwd, input.path)
+        const pattern = input.pattern ?? input.query;
+        if (!pattern) {
+            return {
+                isError: true,
+                content: 'Missing required field: pattern',
+            };
+        }
+        const searchPath = input.path ?? input.directory;
+        const root = searchPath
+            ? isAbsolute(searchPath)
+                ? searchPath
+                : resolve(context.cwd, searchPath)
             : context.cwd;
-        const matcher = input.isRegex
-            ? new RegExp(input.pattern, 'i')
+        const isRegex = input.isRegex ?? input.is_regex;
+        const matcher = isRegex
+            ? new RegExp(pattern, 'i')
             : null;
         const files = await walk(root);
         const results = [];
-        const maxResults = input.maxResults ?? 50;
+        const maxResults = input.maxResults ?? input.max_results ?? 50;
         for (const filePath of files) {
             if (!textExtensions.has(extname(filePath))) {
                 continue;
@@ -68,7 +81,7 @@ export const grepTool = {
                 const line = lines[index] ?? '';
                 const matched = matcher
                     ? matcher.test(line)
-                    : line.toLowerCase().includes(input.pattern.toLowerCase());
+                    : line.toLowerCase().includes(pattern.toLowerCase());
                 if (!matched) {
                     continue;
                 }

package/dist/tools/readFile.d.ts

@@ -1,9 +1,13 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    path: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodOptional<z.ZodString>;
     startLine: z.ZodOptional<z.ZodNumber>;
+    start_line: z.ZodOptional<z.ZodNumber>;
     endLine: z.ZodOptional<z.ZodNumber>;
+    end_line: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const readFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/readFile.js

@@ -2,9 +2,13 @@ import { readFile } from 'node:fs/promises';
 import { isAbsolute, resolve } from 'node:path';
 import { z } from 'zod';
 const inputSchema = z.object({
-    path: z.string().min(1),
+    path: z.string().min(1).optional(),
+    filePath: z.string().min(1).optional(),
+    file_path: z.string().min(1).optional(),
     startLine: z.number().int().positive().optional(),
+    start_line: z.number().int().positive().optional(),
     endLine: z.number().int().positive().optional(),
+    end_line: z.number().int().positive().optional(),
 });
 function resolvePath(cwd, filePath) {
     return isAbsolute(filePath) ? filePath : resolve(cwd, filePath);
@@ -25,11 +29,20 @@ export const readFileTool = {
     },
     isReadOnly: true,
     async execute(input, context) {
-        const absolutePath = resolvePath(context.cwd, input.path);
+        const normalizedPath = input.path ?? input.filePath ?? input.file_path;
+        if (!normalizedPath) {
+            return {
+                isError: true,
+                content: 'Missing required field: path',
+            };
+        }
+        const startLine = input.startLine ?? input.start_line;
+        const endLine = input.endLine ?? input.end_line;
+        const absolutePath = resolvePath(context.cwd, normalizedPath);
         const contents = await readFile(absolutePath, 'utf8');
         const lines = contents.split(/\r?\n/);
-        const start = Math.max((input.startLine ?? 1) - 1, 0);
-        const end = Math.min(input.endLine ?? lines.length, lines.length);
+        const start = Math.max((startLine ?? 1) - 1, 0);
+        const end = Math.min(endLine ?? lines.length, lines.length);
         const slice = lines.slice(start, end);
         const numbered = slice
             .map((line, index) => `${start + index + 1}: ${line}`)

package/dist/tools/runShell.d.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import type { ToolDefinition } from './types.js';
 declare const inputSchema: z.ZodObject<{
-    command: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    cmd: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const runShellTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};

package/dist/tools/runShell.js

@@ -3,7 +3,8 @@ import { promisify } from 'node:util';
 import { z } from 'zod';
 const execAsync = promisify(exec);
 const inputSchema = z.object({
-    command: z.string().min(1),
+    command: z.string().min(1).optional(),
+    cmd: z.string().min(1).optional(),
 });
 export const runShellTool = {
     name: 'run_shell',
@@ -29,9 +30,16 @@ export const runShellTool = {
             };
         }
         try {
-            const { stdout, stderr } = await execAsync(input.command, {
+            const command = input.command ?? input.cmd;
+            if (!command) {
+                return {
+                    isError: true,
+                    content: 'Missing required field: command',
+                };
+            }
+            const { stdout, stderr } = await execAsync(command, {
                 cwd: context.cwd,
-                shell: '/bin/sh',
+                shell: process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : '/bin/sh',
                 maxBuffer: 1024 * 1024,
             });
             const output = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lcagent-cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A minimal coding agent CLI for terminal-based coding workflows.",
   "type": "module",
   "publishConfig": {