lcagent-cli 0.1.0

package/README.md

@@ -0,0 +1,166 @@
+# lcagent-cli
+
+一个从当前仓库架构中抽出来的最小独立 Agent CLI 项目。
+
+## 当前能力
+
+- `lcagent -p "..."`：单次非交互执行
+- `lcagent chat`：交互式聊天
+- `lcagent tools`：查看当前工具
+- `lcagent provider [name]`：查看或修改模型 provider
+- `lcagent model [name]`：查看或修改默认模型
+- `lcagent doctor`：检查当前模型配置和接口连通性
+- `lcagent config show`
+- `lcagent config set <key> <value>`
+
+## 已实现工具
+
+- `read_file`
+- `edit_file`
+- `grep`
+- `run_shell`
+
+## 安装
+
+```bash
+cd my-agent-cli
+npm install
+npm run build
+```
+
+## 发布到公网 npm
+
+先登录 npm 官方仓库：
+
+```bash
+npm login --registry https://registry.npmjs.org/
+```
+
+发布前先做一次本地打包验证：
+
+```bash
+npm run build
+npm pack
+```
+
+确认 `package.json` 中的包名还未被占用后，执行发布：
+
+```bash
+npm publish --registry https://registry.npmjs.org/
+```
+
+如果后续改成 scope 包（例如 `@your-scope/lcagent-cli`），首次发布时建议使用：
+
+```bash
+npm publish --access public --registry https://registry.npmjs.org/
+```
+
+## 从公网 npm 安装和执行
+
+全局安装：
+
+```bash
+npm install -g lcagent-cli --registry https://registry.npmjs.org/
+lcagent --help
+```
+
+不做全局安装时，也可以直接执行：
+
+```bash
+npx --registry https://registry.npmjs.org/ lcagent-cli --help
+npx --registry https://registry.npmjs.org/ lcagent-cli chat
+```
+
+## 配置
+
+方式一：Anthropic 环境变量
+
+```bash
+export ANTHROPIC_API_KEY="your-key"
+```
+
+方式二：写入本地配置
+
+```bash
+npm run start -- config set apiKey your-key
+npm run start -- model claude-3-7-sonnet-latest
+```
+
+## 使用本地 Qwen / OpenAI-compatible 服务
+
+如果你的本地服务提供 OpenAI-compatible 接口（例如 `http://127.0.0.1:8000/v1`），可以这样配置：
+
+```bash
+npm run start -- provider openai-compatible
+npm run start -- config set baseUrl http://127.0.0.1:8000/v1
+npm run start -- model Qwen3-Coder-30B-A3B-Instruct-FP8
+```
+
+或者直接一条命令初始化：
+
+```bash
+npm run start -- init-local --base-url http://127.0.0.1:8000/v1 --model Qwen3-Coder-30B-A3B-Instruct-FP8
+```
+
+如果你的本地服务需要 token：
+
+```bash
+npm run start -- init-local --base-url http://127.0.0.1:8000/v1 --model Qwen3-Coder-30B-A3B-Instruct-FP8 --api-key your-local-token
+```
+
+如果你的本地服务需要 Bearer Token：
+
+```bash
+export OPENAI_API_KEY="your-local-token"
+```
+
+如果本地服务不需要 token，可以不配置 `apiKey`。
+
+建议第一版优先用代码模型：
+
+```bash
+Qwen3-Coder-30B-A3B-Instruct-FP8
+```
+
+配置文件默认在：
+
+```bash
+~/.lcagent-cli/config.json
+```
+
+## 运行
+
+```bash
+npm run start -- -p "阅读 README 并总结项目结构"
+npm run start -- chat
+npm run start -- tools
+npm run start -- provider
+npm run start -- model
+npm run start -- doctor
+```
+
+## 设计目标
+
+- 保留 Claude Code 式的核心代理循环
+- 不依赖原仓库的内部 feature gate
+- 保持目录清晰，便于后续继续演进
+
+## 已知限制
+
+- 当前是最小版，没有流式输出
+- 工具权限策略还是简化版
+- `edit_file` 只做简单字符串替换
+- `grep` 是纯 Node 实现，不如 ripgrep 快
+- 当前按 Anthropic Messages API 直接调用，需要有效 API Key
+
+对于 OpenAI-compatible 本地模型：
+
+- 你的服务需要支持 `POST /chat/completions`
+- 最好支持 tool calling / function calling
+- 如果不支持 tool calling，Agent 的工具闭环能力会明显下降
+
+可以先用下面这条命令做自检：
+
+```bash
+npm run start -- doctor
+```

package/dist/app/bootstrap.d.ts

@@ -0,0 +1,8 @@
+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<{
+    config: Awaited<ReturnType<typeof loadConfig>>;
+    engine: AgentEngine;
+    tools: ReturnType<typeof getDefaultTools>;
+}>;

package/dist/app/bootstrap.js

@@ -0,0 +1,30 @@
+import { createSession } from './session.js';
+import { loadConfig } from '../config/store.js';
+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) {
+    const config = await loadConfig();
+    const apiKey = config.apiKey ??
+        process.env.MODEL_API_KEY ??
+        (config.provider === 'anthropic'
+            ? process.env.ANTHROPIC_API_KEY
+            : process.env.OPENAI_API_KEY);
+    if (config.provider === 'anthropic' && !apiKey) {
+        throw new Error('Missing API key for provider=anthropic. Run `lcagent config set apiKey <key>` or set ANTHROPIC_API_KEY.');
+    }
+    const tools = getDefaultTools();
+    const engine = new AgentEngine(createSession(), config, new ModelClient({
+        provider: config.provider,
+        apiKey,
+        baseUrl: config.baseUrl,
+        model: config.model,
+        maxTokens: config.maxTokens,
+    }), tools, buildSystemPrompt(cwd), cwd);
+    return {
+        config,
+        engine,
+        tools,
+    };
+}

package/dist/app/session.d.ts

@@ -0,0 +1,5 @@
+import type { AgentMessage } from '../core/message.js';
+export type AgentSession = {
+    messages: AgentMessage[];
+};
+export declare function createSession(): AgentSession;

package/dist/app/session.js

@@ -0,0 +1,5 @@
+export function createSession() {
+    return {
+        messages: [],
+    };
+}

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { stdin as input, stdout as output } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { createApp } from '../app/bootstrap.js';
+import { agentConfigSchema } from '../config/schema.js';
+import { getConfigPath, loadConfig, updateConfig } from '../config/store.js';
+import { getDefaultTools } from '../tools/registry.js';
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, '');
+}
+async function probeUrl(url) {
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: { accept: 'application/json,text/plain,*/*' },
+        });
+        return {
+            ok: response.ok,
+            status: response.status,
+            detail: `GET ${url} -> HTTP ${response.status}`,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function runDoctor() {
+    const config = await loadConfig();
+    const apiKey = config.apiKey ??
+        process.env.MODEL_API_KEY ??
+        (config.provider === 'anthropic'
+            ? process.env.ANTHROPIC_API_KEY
+            : process.env.OPENAI_API_KEY);
+    console.log('lcagent doctor');
+    console.log(`- config: ${getConfigPath()}`);
+    console.log(`- provider: ${config.provider}`);
+    console.log(`- baseUrl: ${config.baseUrl}`);
+    console.log(`- model: ${config.model}`);
+    console.log(`- apiKey: ${apiKey ? 'configured' : 'not configured'}`);
+    const rootProbe = await probeUrl(trimTrailingSlash(config.baseUrl));
+    console.log(`- baseUrl probe: ${rootProbe.detail}`);
+    if (config.provider === 'openai-compatible') {
+        const endpoint = `${trimTrailingSlash(config.baseUrl)}/chat/completions`;
+        console.log(`- endpoint: ${endpoint}`);
+        try {
+            const response = await fetch(endpoint, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                },
+                body: JSON.stringify({
+                    model: config.model,
+                    messages: [{ role: 'user', content: 'Reply with the single word pong.' }],
+                    max_tokens: 8,
+                }),
+            });
+            const text = await response.text();
+            console.log(`- chat/completions probe: HTTP ${response.status}`);
+            console.log(`- response preview: ${text.slice(0, 200) || '(empty body)'}`);
+        }
+        catch (error) {
+            console.log(`- chat/completions probe failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+    }
+    const endpoint = `${trimTrailingSlash(config.baseUrl)}/v1/messages`;
+    console.log(`- endpoint: ${endpoint}`);
+    try {
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(apiKey ? { 'x-api-key': apiKey } : {}),
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: config.model,
+                max_tokens: 8,
+                messages: [{ role: 'user', content: 'Reply with the single word pong.' }],
+            }),
+        });
+        const text = await response.text();
+        console.log(`- v1/messages probe: HTTP ${response.status}`);
+        console.log(`- response preview: ${text.slice(0, 200) || '(empty body)'}`);
+    }
+    catch (error) {
+        console.log(`- v1/messages probe failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+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;
+        }
+    }
+}
+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 {
+        while (true) {
+            const line = (await rl.question('> ')).trim();
+            if (!line) {
+                continue;
+            }
+            if (line === 'exit' || line === 'quit') {
+                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;
+                }
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+const program = new Command();
+program
+    .name('lcagent')
+    .description('A minimal coding agent CLI inspired by Claude Code architecture.')
+    .version('0.1.0')
+    .option('-p, --prompt <text>', 'Run a single non-interactive prompt')
+    .action(async (options) => {
+    if (!options.prompt) {
+        program.outputHelp();
+        return;
+    }
+    await printAgentRun(options.prompt);
+});
+program
+    .command('chat')
+    .description('Start interactive chat mode')
+    .action(async () => {
+    await runChat();
+});
+program
+    .command('doctor')
+    .description('Check provider config and probe the configured model endpoint')
+    .action(async () => {
+    await runDoctor();
+});
+program
+    .command('tools')
+    .description('List enabled tools')
+    .action(async () => {
+    const tools = getDefaultTools();
+    for (const tool of tools) {
+        console.log(`- ${tool.name}: ${tool.description}`);
+    }
+});
+program
+    .command('provider')
+    .description('Show or update the current model provider')
+    .argument('[name]', 'Provider name: anthropic | openai-compatible')
+    .action(async (name) => {
+    if (!name) {
+        const config = await loadConfig();
+        console.log(config.provider);
+        return;
+    }
+    const next = await updateConfig({ provider: name });
+    console.log(`Provider updated to ${next.provider}`);
+});
+program
+    .command('init-local')
+    .description('Initialize local OpenAI-compatible model settings in one command')
+    .requiredOption('--base-url <url>', 'Local model base URL, e.g. http://127.0.0.1:8000/v1')
+    .requiredOption('--model <name>', 'Local model name')
+    .option('--api-key <key>', 'Optional local API key / bearer token')
+    .action(async (options) => {
+    const current = await loadConfig();
+    const next = agentConfigSchema.parse({
+        ...current,
+        provider: 'openai-compatible',
+        baseUrl: options.baseUrl,
+        model: options.model,
+        ...(options.apiKey ? { apiKey: options.apiKey } : {}),
+    });
+    await updateConfig(next);
+    console.log('Local model config initialized:');
+    console.log(`- provider: ${next.provider}`);
+    console.log(`- baseUrl: ${next.baseUrl}`);
+    console.log(`- model: ${next.model}`);
+    console.log(`- config: ${getConfigPath()}`);
+    if (!options.apiKey) {
+        console.log('- apiKey: unchanged (not provided)');
+    }
+});
+program
+    .command('model')
+    .description('Show or update the default model')
+    .argument('[name]', 'Optional model name to store in config')
+    .action(async (name) => {
+    if (!name) {
+        const config = await loadConfig();
+        console.log(`${config.provider}: ${config.model}`);
+        return;
+    }
+    const next = await updateConfig({ model: name });
+    console.log(`Default model updated to ${next.model}`);
+});
+const configCommand = program.command('config').description('Manage local config');
+configCommand
+    .command('show')
+    .description('Print current config')
+    .action(async () => {
+    const config = await loadConfig();
+    console.log(JSON.stringify(config, null, 2));
+    console.log(`Config path: ${getConfigPath()}`);
+});
+configCommand
+    .command('set')
+    .description('Set a config key')
+    .argument('<key>', 'Config key')
+    .argument('<value>', 'Config value')
+    .action(async (key, value) => {
+    const current = await loadConfig();
+    const nextValue = key === 'maxTurns' || key === 'maxTokens'
+        ? Number(value)
+        : key === 'approvalMode' || key === 'provider'
+            ? value
+            : value;
+    const next = agentConfigSchema.parse({
+        ...current,
+        [key]: nextValue,
+    });
+    await updateConfig(next);
+    console.log(`Updated ${key}`);
+});
+program.parseAsync(process.argv).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/config/schema.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const agentConfigSchema: z.ZodObject<{
+    provider: z.ZodDefault<z.ZodEnum<{
+        anthropic: "anthropic";
+        "openai-compatible": "openai-compatible";
+    }>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodDefault<z.ZodString>;
+    model: z.ZodDefault<z.ZodString>;
+    maxTurns: z.ZodDefault<z.ZodNumber>;
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    approvalMode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        manual: "manual";
+    }>>;
+}, z.core.$strip>;
+export type AgentConfig = z.infer<typeof agentConfigSchema>;
+export declare const defaultAgentConfig: AgentConfig;

package/dist/config/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export const agentConfigSchema = z.object({
+    provider: z.enum(['anthropic', 'openai-compatible']).default('anthropic'),
+    apiKey: z.string().trim().min(1).optional(),
+    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),
+    maxTokens: z.number().int().positive().default(2048),
+    approvalMode: z.enum(['auto', 'manual']).default('auto'),
+});
+export const defaultAgentConfig = agentConfigSchema.parse({});

package/dist/config/store.d.ts

@@ -0,0 +1,5 @@
+import { type AgentConfig } from './schema.js';
+export declare function loadConfig(): Promise<AgentConfig>;
+export declare function saveConfig(config: AgentConfig): Promise<void>;
+export declare function updateConfig(partial: Partial<AgentConfig>): Promise<AgentConfig>;
+export declare function getConfigPath(): string;

package/dist/config/store.js

@@ -0,0 +1,37 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { agentConfigSchema, defaultAgentConfig } from './schema.js';
+const CONFIG_PATH = join(homedir(), '.lcagent-cli', 'config.json');
+async function ensureConfigDir() {
+    await mkdir(dirname(CONFIG_PATH), { recursive: true });
+}
+export async function loadConfig() {
+    try {
+        const raw = await readFile(CONFIG_PATH, 'utf8');
+        return agentConfigSchema.parse({
+            ...defaultAgentConfig,
+            ...JSON.parse(raw),
+        });
+    }
+    catch {
+        return { ...defaultAgentConfig };
+    }
+}
+export async function saveConfig(config) {
+    await ensureConfigDir();
+    const normalized = agentConfigSchema.parse(config);
+    await writeFile(CONFIG_PATH, JSON.stringify(normalized, null, 2) + '\n', 'utf8');
+}
+export async function updateConfig(partial) {
+    const current = await loadConfig();
+    const next = agentConfigSchema.parse({
+        ...current,
+        ...partial,
+    });
+    await saveConfig(next);
+    return next;
+}
+export function getConfigPath() {
+    return CONFIG_PATH;
+}

package/dist/core/engine.d.ts

@@ -0,0 +1,15 @@
+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;
+    private readonly modelClient;
+    private readonly tools;
+    private readonly systemPrompt;
+    private readonly cwd;
+    constructor(session: AgentSession, config: AgentConfig, modelClient: ModelClient, tools: ToolDefinition[], systemPrompt: string, cwd: string);
+    submit(prompt: string): AsyncGenerator<AgentEvent, void>;
+}

package/dist/core/engine.js

@@ -0,0 +1,29 @@
+import { createUserTextMessage } from './message.js';
+import { runAgentLoop } from './loop.js';
+export class AgentEngine {
+    session;
+    config;
+    modelClient;
+    tools;
+    systemPrompt;
+    cwd;
+    constructor(session, config, modelClient, tools, systemPrompt, cwd) {
+        this.session = session;
+        this.config = config;
+        this.modelClient = modelClient;
+        this.tools = tools;
+        this.systemPrompt = systemPrompt;
+        this.cwd = cwd;
+    }
+    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,
+        });
+    }
+}

package/dist/core/loop.d.ts

@@ -0,0 +1,12 @@
+import type { AgentConfig } from '../config/schema.js';
+import type { AgentEvent, AgentMessage } from './message.js';
+import type { ToolDefinition } from '../tools/types.js';
+import type { ModelClient } from './model.js';
+export declare function runAgentLoop(params: {
+    config: AgentConfig;
+    modelClient: ModelClient;
+    messages: AgentMessage[];
+    tools: ToolDefinition[];
+    systemPrompt: string;
+    cwd: string;
+}): AsyncGenerator<AgentEvent, void>;

package/dist/core/loop.js

@@ -0,0 +1,54 @@
+import { executeToolCall } from '../tools/execute.js';
+export async function* runAgentLoop(params) {
+    const toolContext = {
+        cwd: params.cwd,
+        approvalMode: params.config.approvalMode,
+    };
+    for (let turn = 0; turn < params.config.maxTurns; turn += 1) {
+        yield { type: 'status', message: `Thinking (turn ${turn + 1}/${params.config.maxTurns})...` };
+        const response = await params.modelClient.createMessage({
+            systemPrompt: params.systemPrompt,
+            messages: params.messages,
+            tools: params.tools,
+        });
+        const assistantMessage = {
+            role: 'assistant',
+            content: response.content,
+        };
+        params.messages.push(assistantMessage);
+        const toolUses = response.content.filter((block) => block.type === 'tool_use');
+        for (const block of response.content) {
+            if (block.type === 'text' && block.text.trim()) {
+                yield { type: 'assistant_text', text: block.text };
+            }
+        }
+        if (toolUses.length === 0) {
+            return;
+        }
+        for (const toolUse of toolUses) {
+            yield {
+                type: 'tool_call',
+                toolName: toolUse.name,
+                input: toolUse.input,
+            };
+            const result = await executeToolCall(toolUse, params.tools, toolContext);
+            yield {
+                type: 'tool_result',
+                toolName: toolUse.name,
+                result: result.content,
+                isError: result.isError,
+            };
+            const toolResultBlock = {
+                type: 'tool_result',
+                tool_use_id: toolUse.id,
+                content: result.content,
+                is_error: result.isError,
+            };
+            params.messages.push({
+                role: 'user',
+                content: [toolResultBlock],
+            });
+        }
+    }
+    throw new Error(`Agent stopped after reaching maxTurns=${params.config.maxTurns}`);
+}