lcagent-cli 0.1.6 → 0.1.7

package/README.md

@@ -10,6 +10,8 @@
 - `lcagent provider [name]`：查看或修改模型 provider
 - `lcagent model [name]`：查看或修改默认模型
 - `lcagent doctor`：检查当前模型配置和接口连通性
+- `lcagent config set approvalMode auto|manual`：切换工具权限模式
+- `lcagent config set autoContinueOnMaxTurns true|false`：切换超限自动续跑
 - `lcagent config show`
 - `lcagent config set <key> <value>`
 
@@ -20,6 +22,26 @@
 - `grep`
 - `run_shell`
 
+其中 `edit_file` 现已支持：
+
+- 单文件 `unified diff / patch` 应用
+- 精确文本替换
+- 直引号 / 弯引号不一致时的归一化匹配
+- 命中弯引号内容时自动保留原文件引号风格
+- 多处命中时提示使用 `occurrence` 或 `replaceAll`
+- 替换失败时返回更具体的上下文诊断
+
+`edit_file` 现在有两种模式：
+
+- 文本替换模式：传 `path + oldText + newText`
+- Patch 模式：传 `patch`，也可以额外传 `path`
+
+Patch 模式当前限制：
+
+- 只支持单文件 unified diff
+- patch 需要能对当前文件内容干净应用
+- 如果 `path` 与 patch 头里的目标文件不一致，会直接报错
+
 ## 安装
 
 ```bash
@@ -28,6 +50,21 @@ npm install
 npm run build
 ```
 
+如果你想先确认本地最小闭环是否正常，可以直接运行：
+
+```bash
+npm run smoke
+```
+
+这条命令不会访问模型服务，只会验证：
+
+- `lcagent tools`
+- `lcagent config show`
+- `read_file`
+- `grep`
+- `edit_file`
+- `run_shell`
+
 ## 发布到公网 npm
 
 先登录 npm 官方仓库：
@@ -137,16 +174,111 @@ npm run start -- tools
 npm run start -- provider
 npm run start -- model
 npm run start -- doctor
+npm run start -- config set approvalMode manual
 ```
 
+注意：`chat` 和 `-p` 都依赖一个可用的模型配置。
+
+- 如果你走 `anthropic`，需要先配置 `ANTHROPIC_API_KEY` 或 `lcagent config set apiKey ...`
+- 如果你走本地模型，建议先执行 `init-local`，再执行 `doctor`，最后再进入 `chat`
+
+## 最小闭环验收顺序
+
+推荐按下面顺序验证当前版本：
+
+1. 本地静态能力：
+
+```bash
+npm run check
+npm run build
+npm run smoke
+```
+
+2. 本地模型接入（OpenAI-compatible）：
+
+```bash
+npm run start -- init-local --base-url http://127.0.0.1:8000/v1 --model your-model-name
+npm run start -- doctor
+```
+
+如果你使用 Anthropic 官方接口，则把上面两条替换成：
+
+```bash
+export ANTHROPIC_API_KEY="your-key"
+npm run start -- doctor
+```
+
+3. 交互式 chat：
+
+```bash
+npm run start -- chat
+```
+
+进到 chat 后，建议先做一个最小读文件任务，例如：
+
+- `读取 README.md 的前 40 行并总结项目结构`
+- `搜索项目里有哪些 edit_file 相关实现`
+
+如果 `doctor` 可通过、`chat` 能读文件、`npm run smoke` 通过，就说明当前最小闭环已经稳定可用。
+
+如果 `doctor` 能跑但 `chat` 提示缺少 API key，通常不是程序损坏，而是当前配置仍停留在默认的 `anthropic` 且没有完成认证。先执行 `config show` 检查当前 provider，再按上面的配置步骤修正即可。
+
+## 权限模式
+
+`lcagent` 当前支持两种最小权限模式：
+
+- `auto`：工具直接执行
+- `manual`：`read_file` / `grep` 直接放行，`edit_file` / `run_shell` 在执行前询问确认
+
+其中 `manual` 模式已经裁剪复用了 Claude Code 权限层里的两类思路：
+
+- 权限模式分层思路
+- 危险文件 / 危险目录名单（如 `.git`、`.vscode`、`.claude`、shell 配置文件）
+
+如果 `edit_file` 命中的目标位于这些高风险路径下，确认提示会给出更高风险说明。
+
+如果当前不是交互式终端，`manual` 模式下的写入/执行工具会被拒绝，并返回明确原因。
+
 当模型触发工具时，CLI 会打印：
 
 - `[tool-call] 工具名`：后面跟模型传入的原始 JSON 参数
 - `[tool-result] 工具名`：显示工具执行结果
 - `[tool-result] 工具名 (error)`：显示工具失败原因
+- 同时附带 `cwd`、执行耗时、审批状态、失败阶段等元数据，便于排查是校验失败、审批拒绝还是工具执行异常
 
 这样可以直接看出是模型参数字段名不对、路径不对，还是工具执行本身报错。
 
+## 超限续跑
+
+当前默认配置下，`lcagent` 在单段运行达到 `maxTurns` 后，不会立刻报错退出，而是会自动续跑下一段：
+
+- `maxTurns`：每一段最多运行多少轮，默认 `8`
+- `autoContinueOnMaxTurns`：达到上限后是否自动续跑，默认 `true`
+- `maxContinuations`：最多自动续跑多少段，默认 `3`
+
+也就是说，默认情况下最多会跑 `1 + 3 = 4` 段。
+
+如果自动续跑次数也耗尽了，CLI 不会只打印一条生硬错误，而是会额外输出：
+
+- 最近的 assistant 文本进展
+- 最近几次工具调用
+- 最近几次工具结果
+- 一个建议的“继续”提示词
+
+常用配置示例：
+
+```bash
+npm run start -- config set maxTurns 12
+npm run start -- config set autoContinueOnMaxTurns true
+npm run start -- config set maxContinuations 4
+```
+
+如果你想恢复原来那种“达到上限就停止”的行为：
+
+```bash
+npm run start -- config set autoContinueOnMaxTurns false
+```
+
 ## 设计目标
 
 - 保留 Claude Code 式的核心代理循环
@@ -157,7 +289,6 @@ npm run start -- doctor
 
 - 当前是最小版，没有流式输出
 - 工具权限策略还是简化版
-- `edit_file` 只做简单字符串替换
 - `grep` 是纯 Node 实现，不如 ripgrep 快
 - 当前按 Anthropic Messages API 直接调用，需要有效 API Key
 

package/dist/app/bootstrap.d.ts

@@ -1,7 +1,10 @@
 import { loadConfig } from '../config/store.js';
 import { AgentEngine } from '../core/engine.js';
 import { getDefaultTools } from '../tools/registry.js';
-export declare function createApp(cwd: string): Promise<{
+import type { ToolContext } from '../tools/types.js';
+export declare function createApp(cwd: string, options?: {
+    requestApproval?: ToolContext['requestApproval'];
+}): Promise<{
     config: Awaited<ReturnType<typeof loadConfig>>;
     engine: AgentEngine;
     tools: ReturnType<typeof getDefaultTools>;

package/dist/app/bootstrap.js

@@ -4,7 +4,7 @@ import { buildSystemPrompt } from '../core/systemPrompt.js';
 import { ModelClient } from '../core/model.js';
 import { AgentEngine } from '../core/engine.js';
 import { getDefaultTools } from '../tools/registry.js';
-export async function createApp(cwd) {
+export async function createApp(cwd, options) {
     const config = await loadConfig();
     const apiKey = config.apiKey ??
         process.env.MODEL_API_KEY ??
@@ -21,7 +21,7 @@ export async function createApp(cwd) {
         baseUrl: config.baseUrl,
         model: config.model,
         maxTokens: config.maxTokens,
-    }), tools, buildSystemPrompt(cwd), cwd);
+    }), tools, buildSystemPrompt(cwd), cwd, options?.requestApproval);
     return {
         config,
         engine,

package/dist/bin/cli.js

@@ -54,6 +54,33 @@ function formatToolInput(input) {
         return String(input);
     }
 }
+function formatToolResultMeta(meta) {
+    if (!meta) {
+        return null;
+    }
+    const parts = [`cwd=${meta.cwd}`, `duration=${meta.durationMs}ms`];
+    if (meta.approval.required) {
+        const approvalState = meta.approval.approved === false
+            ? 'denied'
+            : meta.approval.approved === true
+                ? 'approved'
+                : 'pending';
+        parts.push(`approval=${approvalState}`);
+        if (meta.approval.risk) {
+            parts.push(`risk=${meta.approval.risk}`);
+        }
+        if (meta.approval.targets && meta.approval.targets.length > 0) {
+            parts.push(`targets=${meta.approval.targets.join(',')}`);
+        }
+    }
+    else {
+        parts.push(`approval=${meta.approval.mode === 'manual' ? 'not-required' : 'auto'}`);
+    }
+    if (meta.failureStage) {
+        parts.push(`stage=${meta.failureStage}`);
+    }
+    return parts.join(' | ');
+}
 function printEvent(event) {
     switch (event.type) {
         case 'status':
@@ -64,14 +91,54 @@ function printEvent(event) {
             break;
         case 'tool_call':
             console.log(`\n[tool-call] ${event.toolName}`);
+            console.log(`cwd=${event.cwd} | approvalMode=${event.approvalMode}`);
             console.log(formatToolInput(event.input));
             break;
         case 'tool_result':
             console.log(`\n[tool-result] ${event.toolName}${event.isError ? ' (error)' : ''}`);
+            const metaLine = formatToolResultMeta(event.meta);
+            if (metaLine) {
+                console.log(metaLine);
+            }
             console.log(event.result);
             break;
     }
 }
+async function promptForToolApproval(request, rl) {
+    if (!input.isTTY || !output.isTTY) {
+        return {
+            approved: false,
+            reason: `Denied ${request.toolName}: manual approval requires an interactive terminal.`,
+        };
+    }
+    const lines = [
+        '',
+        `[approval] ${request.toolName}`,
+        `- risk: ${request.risk}`,
+        `- summary: ${request.summary}`,
+        `- reason: ${request.reason}`,
+    ];
+    if (request.targets.length > 0) {
+        lines.push(`- targets: ${request.targets.join(', ')}`);
+    }
+    console.log(lines.join('\n'));
+    const temporaryRl = rl ?? createInterface({ input, output });
+    try {
+        const answer = (await questionAsync(temporaryRl, 'Allow this tool call? [y/N] ')).trim().toLowerCase();
+        if (answer === 'y' || answer === 'yes') {
+            return { approved: true };
+        }
+        return {
+            approved: false,
+            reason: `User denied ${request.toolName}.`,
+        };
+    }
+    finally {
+        if (!rl) {
+            temporaryRl.close();
+        }
+    }
+}
 async function probeUrl(url) {
     try {
         const response = await fetchWithTimeout(url, {
@@ -229,17 +296,21 @@ async function runDoctor() {
     });
 }
 async function printAgentRun(prompt) {
-    const { engine } = await createApp(process.cwd());
+    const { engine } = await createApp(process.cwd(), {
+        requestApproval: request => promptForToolApproval(request),
+    });
     for await (const event of engine.submit(prompt)) {
         printEvent(event);
     }
 }
 async function runChat() {
-    const { engine, config } = await createApp(process.cwd());
-    console.log(`lcagent chat started with provider: ${config.provider}, model: ${config.model}`);
-    console.log('Type `exit` or `quit` to leave.');
     const rl = createInterface({ input, output });
     try {
+        const { engine, config } = await createApp(process.cwd(), {
+            requestApproval: request => promptForToolApproval(request, rl),
+        });
+        console.log(`lcagent chat started with provider: ${config.provider}, model: ${config.model}, approvalMode: ${config.approvalMode}`);
+        console.log('Type `exit` or `quit` to leave.');
         while (true) {
             const line = (await questionAsync(rl, '> ')).trim();
             if (!line) {
@@ -358,11 +429,13 @@ configCommand
     .argument('<value>', 'Config value')
     .action(async (key, value) => {
     const current = await loadConfig();
-    const nextValue = key === 'maxTurns' || key === 'maxTokens'
+    const nextValue = key === 'maxTurns' || key === 'maxTokens' || key === 'maxContinuations'
         ? Number(value)
-        : key === 'approvalMode' || key === 'provider'
-            ? value
-            : value;
+        : key === 'autoContinueOnMaxTurns'
+            ? value === 'true'
+            : key === 'approvalMode' || key === 'provider'
+                ? value
+                : value;
     const next = agentConfigSchema.parse({
         ...current,
         [key]: nextValue,

package/dist/config/schema.d.ts

@@ -8,6 +8,8 @@ export declare const agentConfigSchema: z.ZodObject<{
     baseUrl: z.ZodDefault<z.ZodString>;
     model: z.ZodDefault<z.ZodString>;
     maxTurns: z.ZodDefault<z.ZodNumber>;
+    autoContinueOnMaxTurns: z.ZodDefault<z.ZodBoolean>;
+    maxContinuations: z.ZodDefault<z.ZodNumber>;
     maxTokens: z.ZodDefault<z.ZodNumber>;
     approvalMode: z.ZodDefault<z.ZodEnum<{
         auto: "auto";

package/dist/config/schema.js

@@ -5,6 +5,8 @@ export const agentConfigSchema = z.object({
     baseUrl: z.string().url().default('https://api.anthropic.com'),
     model: z.string().trim().min(1).default('claude-3-7-sonnet-latest'),
     maxTurns: z.number().int().positive().default(8),
+    autoContinueOnMaxTurns: z.boolean().default(true),
+    maxContinuations: z.number().int().min(0).default(3),
     maxTokens: z.number().int().positive().default(2048),
     approvalMode: z.enum(['auto', 'manual']).default('auto'),
 });

package/dist/core/engine.d.ts

@@ -1,8 +1,8 @@
+import type { ToolContext, ToolDefinition } from '../tools/types.js';
 import type { AgentConfig } from '../config/schema.js';
 import type { AgentSession } from '../app/session.js';
 import { type AgentEvent } from './message.js';
 import type { ModelClient } from './model.js';
-import type { ToolDefinition } from '../tools/types.js';
 export declare class AgentEngine {
     private readonly session;
     private readonly config;
@@ -10,6 +10,7 @@ export declare class AgentEngine {
     private readonly tools;
     private readonly systemPrompt;
     private readonly cwd;
-    constructor(session: AgentSession, config: AgentConfig, modelClient: ModelClient, tools: ToolDefinition[], systemPrompt: string, cwd: string);
+    private readonly requestApproval?;
+    constructor(session: AgentSession, config: AgentConfig, modelClient: ModelClient, tools: ToolDefinition[], systemPrompt: string, cwd: string, requestApproval?: ToolContext['requestApproval']);
     submit(prompt: string): AsyncGenerator<AgentEvent, void>;
 }

package/dist/core/engine.js

@@ -1,5 +1,63 @@
-import { createUserTextMessage } from './message.js';
+import { createAutoContinuationMessage, createUserTextMessage } from './message.js';
 import { runAgentLoop } from './loop.js';
+function truncate(value, maxLength = 140) {
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    if (normalized.length <= maxLength) {
+        return normalized;
+    }
+    return `${normalized.slice(0, maxLength - 1)}…`;
+}
+function buildRecentProgressSummary(messages) {
+    const recentToolNames = [];
+    const recentToolResults = [];
+    let latestAssistantText = null;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (!latestAssistantText && message.role === 'assistant') {
+            const textBlock = message.content.find(block => block.type === 'text' && block.text.trim().length > 0);
+            if (textBlock && textBlock.type === 'text') {
+                latestAssistantText = truncate(textBlock.text);
+            }
+        }
+        if (message.role === 'assistant') {
+            const toolUses = message.content.filter(block => block.type === 'tool_use');
+            for (let toolIndex = toolUses.length - 1; toolIndex >= 0; toolIndex -= 1) {
+                const toolUse = toolUses[toolIndex];
+                recentToolNames.push(toolUse.name);
+                if (recentToolNames.length >= 3) {
+                    break;
+                }
+            }
+        }
+        if (message.role === 'user') {
+            const toolResults = message.content.filter(block => block.type === 'tool_result');
+            for (let resultIndex = toolResults.length - 1; resultIndex >= 0; resultIndex -= 1) {
+                const toolResult = toolResults[resultIndex];
+                recentToolResults.push(truncate(toolResult.content));
+                if (recentToolResults.length >= 3) {
+                    break;
+                }
+            }
+        }
+        if (latestAssistantText &&
+            recentToolNames.length >= 3 &&
+            recentToolResults.length >= 3) {
+            break;
+        }
+    }
+    const lines = ['Recent progress summary:'];
+    if (latestAssistantText) {
+        lines.push(`- Last assistant note: ${latestAssistantText}`);
+    }
+    if (recentToolNames.length > 0) {
+        lines.push(`- Recent tools: ${recentToolNames.reverse().join(' -> ')}`);
+    }
+    if (recentToolResults.length > 0) {
+        lines.push(`- Recent tool results: ${recentToolResults.reverse().join(' | ')}`);
+    }
+    lines.push('- Suggested next prompt: 继续，基于当前上下文完成剩余任务，并优先处理尚未完成的步骤。');
+    return lines.join('\n');
+}
 export class AgentEngine {
     session;
     config;
@@ -7,23 +65,55 @@ export class AgentEngine {
     tools;
     systemPrompt;
     cwd;
-    constructor(session, config, modelClient, tools, systemPrompt, cwd) {
+    requestApproval;
+    constructor(session, config, modelClient, tools, systemPrompt, cwd, requestApproval) {
         this.session = session;
         this.config = config;
         this.modelClient = modelClient;
         this.tools = tools;
         this.systemPrompt = systemPrompt;
         this.cwd = cwd;
+        this.requestApproval = requestApproval;
     }
     async *submit(prompt) {
         this.session.messages.push(createUserTextMessage(prompt));
-        yield* runAgentLoop({
-            config: this.config,
-            modelClient: this.modelClient,
-            messages: this.session.messages,
-            tools: this.tools,
-            systemPrompt: this.systemPrompt,
-            cwd: this.cwd,
-        });
+        let continuationCount = 0;
+        while (true) {
+            const result = yield* runAgentLoop({
+                config: this.config,
+                modelClient: this.modelClient,
+                messages: this.session.messages,
+                tools: this.tools,
+                systemPrompt: this.systemPrompt,
+                cwd: this.cwd,
+                requestApproval: this.requestApproval,
+            });
+            if (result.reason !== 'max_turns') {
+                return;
+            }
+            if (!this.config.autoContinueOnMaxTurns ||
+                continuationCount >= this.config.maxContinuations) {
+                yield {
+                    type: 'status',
+                    message: `Reached maxTurns=${this.config.maxTurns} and stopped after ${continuationCount} auto-continuation(s). ` +
+                        'Increase maxTurns or maxContinuations if you want longer autonomous runs.',
+                };
+                yield {
+                    type: 'status',
+                    message: buildRecentProgressSummary(this.session.messages),
+                };
+                return;
+            }
+            continuationCount += 1;
+            yield {
+                type: 'status',
+                message: `Reached maxTurns=${this.config.maxTurns}; auto-continuing segment ${continuationCount}/${this.config.maxContinuations}...`,
+            };
+            this.session.messages.push(createAutoContinuationMessage({
+                maxTurns: this.config.maxTurns,
+                segment: continuationCount,
+                maxContinuations: this.config.maxContinuations,
+            }));
+        }
     }
 }

package/dist/core/loop.d.ts

@@ -1,7 +1,11 @@
 import type { AgentConfig } from '../config/schema.js';
 import type { AgentEvent, AgentMessage } from './message.js';
-import type { ToolDefinition } from '../tools/types.js';
+import type { ToolContext, ToolDefinition } from '../tools/types.js';
 import type { ModelClient } from './model.js';
+export type AgentLoopResult = {
+    reason: 'completed' | 'max_turns';
+    turnCount: number;
+};
 export declare function runAgentLoop(params: {
     config: AgentConfig;
     modelClient: ModelClient;
@@ -9,4 +13,5 @@ export declare function runAgentLoop(params: {
     tools: ToolDefinition[];
     systemPrompt: string;
     cwd: string;
-}): AsyncGenerator<AgentEvent, void>;
+    requestApproval?: ToolContext['requestApproval'];
+}): AsyncGenerator<AgentEvent, AgentLoopResult>;

package/dist/core/loop.js

@@ -3,6 +3,7 @@ export async function* runAgentLoop(params) {
     const toolContext = {
         cwd: params.cwd,
         approvalMode: params.config.approvalMode,
+        requestApproval: params.requestApproval,
     };
     for (let turn = 0; turn < params.config.maxTurns; turn += 1) {
         yield { type: 'status', message: `Thinking (turn ${turn + 1}/${params.config.maxTurns})...` };
@@ -23,13 +24,15 @@ export async function* runAgentLoop(params) {
             }
         }
         if (toolUses.length === 0) {
-            return;
+            return { reason: 'completed', turnCount: turn + 1 };
         }
         for (const toolUse of toolUses) {
             yield {
                 type: 'tool_call',
                 toolName: toolUse.name,
                 input: toolUse.input,
+                cwd: params.cwd,
+                approvalMode: params.config.approvalMode,
             };
             const result = await executeToolCall(toolUse, params.tools, toolContext);
             yield {
@@ -37,6 +40,7 @@ export async function* runAgentLoop(params) {
                 toolName: toolUse.name,
                 result: result.content,
                 isError: result.isError,
+                meta: result.meta,
             };
             const toolResultBlock = {
                 type: 'tool_result',
@@ -50,5 +54,8 @@ export async function* runAgentLoop(params) {
             });
         }
     }
-    throw new Error(`Agent stopped after reaching maxTurns=${params.config.maxTurns}`);
+    return {
+        reason: 'max_turns',
+        turnCount: params.config.maxTurns,
+    };
 }

package/dist/core/message.d.ts

@@ -1,3 +1,4 @@
+import type { ToolExecutionMeta } from '../tools/types.js';
 export type TextBlock = {
     type: 'text';
     text: string;
@@ -29,10 +30,18 @@ export type AgentEvent = {
     type: 'tool_call';
     toolName: string;
     input: unknown;
+    cwd: string;
+    approvalMode: 'auto' | 'manual';
 } | {
     type: 'tool_result';
     toolName: string;
     result: string;
     isError?: boolean;
+    meta?: ToolExecutionMeta;
 };
 export declare function createUserTextMessage(text: string): AgentMessage;
+export declare function createAutoContinuationMessage(params: {
+    maxTurns: number;
+    segment: number;
+    maxContinuations: number;
+}): AgentMessage;

package/dist/core/message.js

@@ -4,3 +4,12 @@ export function createUserTextMessage(text) {
         content: [{ type: 'text', text }],
     };
 }
+export function createAutoContinuationMessage(params) {
+    const text = [
+        `Automatic continuation ${params.segment}/${params.maxContinuations} after reaching maxTurns=${params.maxTurns}.`,
+        'Continue from the current state without repeating completed work.',
+        'Prioritize the remaining unfinished steps and finish the task if possible.',
+        'If the task is already complete, answer directly without additional tool calls.',
+    ].join(' ');
+    return createUserTextMessage(text);
+}

package/dist/tools/editFile.d.ts

@@ -4,10 +4,18 @@ declare const inputSchema: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
     filePath: z.ZodOptional<z.ZodString>;
     file_path: z.ZodOptional<z.ZodString>;
+    patch: z.ZodOptional<z.ZodString>;
+    diff: z.ZodOptional<z.ZodString>;
+    unifiedDiff: z.ZodOptional<z.ZodString>;
+    unified_diff: 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>;
+    replaceAll: z.ZodOptional<z.ZodBoolean>;
+    replace_all: z.ZodOptional<z.ZodBoolean>;
+    occurrence: z.ZodOptional<z.ZodNumber>;
+    occurrence_index: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export declare const editFileTool: ToolDefinition<z.infer<typeof inputSchema>>;
 export {};