@gird/ccli 1.0.2 → 2.0.0

package/dist/agent/client-openai.js

@@ -1,166 +0,0 @@
-/**
- * OpenAI 兼容客户端 —— 对接 OpenAI Chat Completions 协议的后端,
- * 例如通义千问(DashScope compatible-mode)、DeepSeek、GLM 等。
- *
- * 它在边界处把代理循环内部使用的 Anthropic 消息格式(含 tool_use / tool_result 块)
- * 与 OpenAI 的 messages / tool_calls 格式互相转换,从而让上层循环逻辑保持不变。
- */
-import OpenAI from 'openai';
-export class OpenAICompatClient {
-    client;
-    model;
-    maxTokens;
-    temperature;
-    constructor(opts) {
-        this.client = new OpenAI({ apiKey: opts.apiKey, baseURL: opts.baseURL });
-        this.model = opts.model;
-        this.maxTokens = opts.maxTokens;
-        this.temperature = opts.temperature;
-    }
-    setModel(m) {
-        this.model = m;
-    }
-    getModel() {
-        return this.model;
-    }
-    async stream(system, messages, tools, callbacks, signal) {
-        const oaMessages = this.toOpenAIMessages(system, messages);
-        const oaTools = tools.map((t) => ({
-            type: 'function',
-            function: {
-                name: t.name,
-                description: t.description,
-                parameters: t.input_schema ?? { type: 'object', properties: {} },
-            },
-        }));
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            messages: oaMessages,
-            tools: oaTools.length ? oaTools : undefined,
-            tool_choice: oaTools.length ? 'auto' : undefined,
-            stream: true,
-            stream_options: { include_usage: true },
-        }, { signal });
-        let text = '';
-        let finishReason = null;
-        const usage = { input: 0, output: 0 };
-        // 按 index 累积 tool_calls
-        const toolAcc = new Map();
-        for await (const chunk of stream) {
-            const choice = chunk.choices?.[0];
-            if (choice) {
-                const delta = choice.delta;
-                if (delta?.content) {
-                    text += delta.content;
-                    callbacks.onText?.(delta.content);
-                }
-                if (delta?.tool_calls) {
-                    for (const tc of delta.tool_calls) {
-                        const idx = tc.index ?? 0;
-                        const cur = toolAcc.get(idx) ?? { id: '', name: '', args: '' };
-                        if (tc.id)
-                            cur.id = tc.id;
-                        if (tc.function?.name)
-                            cur.name = tc.function.name;
-                        if (tc.function?.arguments)
-                            cur.args += tc.function.arguments;
-                        toolAcc.set(idx, cur);
-                        if (tc.function?.name)
-                            callbacks.onToolUseStart?.(tc.function.name, cur.id);
-                    }
-                }
-                if (choice.finish_reason)
-                    finishReason = choice.finish_reason;
-            }
-            if (chunk.usage) {
-                usage.input = chunk.usage.prompt_tokens ?? 0;
-                usage.output = chunk.usage.completion_tokens ?? 0;
-            }
-        }
-        // 组装 Anthropic 内部格式的 content 块
-        const content = [];
-        if (text)
-            content.push({ type: 'text', text });
-        let genId = 0;
-        for (const [, tc] of [...toolAcc.entries()].sort((a, b) => a[0] - b[0])) {
-            let input = {};
-            try {
-                input = tc.args ? JSON.parse(tc.args) : {};
-            }
-            catch {
-                input = {};
-            }
-            content.push({
-                type: 'tool_use',
-                id: tc.id || `call_${Date.now()}_${genId++}`,
-                name: tc.name,
-                input,
-            });
-        }
-        const stopReason = finishReason === 'tool_calls'
-            ? 'tool_use'
-            : finishReason === 'length'
-                ? 'max_tokens'
-                : 'end_turn';
-        return { content, stopReason, usage };
-    }
-    /** Anthropic 内部消息 → OpenAI messages。 */
-    toOpenAIMessages(system, messages) {
-        const out = [
-            { role: 'system', content: system },
-        ];
-        for (const m of messages) {
-            if (typeof m.content === 'string') {
-                out.push({ role: m.role, content: m.content });
-                continue;
-            }
-            const blocks = m.content;
-            if (m.role === 'assistant') {
-                let textContent = '';
-                const toolCalls = [];
-                for (const b of blocks) {
-                    if (b.type === 'text')
-                        textContent += b.text;
-                    else if (b.type === 'tool_use') {
-                        toolCalls.push({
-                            id: b.id,
-                            type: 'function',
-                            function: {
-                                name: b.name,
-                                arguments: JSON.stringify(b.input ?? {}),
-                            },
-                        });
-                    }
-                }
-                const msg = { role: 'assistant' };
-                msg.content = textContent || null;
-                if (toolCalls.length)
-                    msg.tool_calls = toolCalls;
-                out.push(msg);
-                continue;
-            }
-            // user 消息:可能含 tool_result 与 text
-            const userTexts = [];
-            for (const b of blocks) {
-                if (b.type === 'tool_result') {
-                    out.push({
-                        role: 'tool',
-                        tool_call_id: b.tool_use_id,
-                        content: typeof b.content === 'string'
-                            ? b.content
-                            : JSON.stringify(b.content),
-                    });
-                }
-                else if (b.type === 'text') {
-                    userTexts.push(b.text);
-                }
-            }
-            if (userTexts.length) {
-                out.push({ role: 'user', content: userTexts.join('\n') });
-            }
-        }
-        return out;
-    }
-}

package/dist/agent/client.js

@@ -1,63 +0,0 @@
-/**
- * Anthropic Messages API 客户端封装 —— HTTP/2 + SSE 流式传输。
- */
-import Anthropic from '@anthropic-ai/sdk';
-export class AnthropicClient {
-    client;
-    model;
-    maxTokens;
-    temperature;
-    constructor(opts) {
-        this.client = new Anthropic({
-            apiKey: opts.apiKey,
-            baseURL: opts.baseURL,
-        });
-        this.model = opts.model;
-        this.maxTokens = opts.maxTokens;
-        this.temperature = opts.temperature;
-    }
-    setModel(m) {
-        this.model = m;
-    }
-    getModel() {
-        return this.model;
-    }
-    /**
-     * 发起一次带流式输出的对话请求。
-     * 返回完整的 assistant 回合（含文本与 tool_use 块）。
-     */
-    async stream(system, messages, tools, callbacks, signal) {
-        const stream = this.client.messages.stream({
-            model: this.model,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            system: [
-                {
-                    type: 'text',
-                    text: system,
-                    // 系统提示缓存（对应「分层上下文压缩」中的缓存策略）
-                    cache_control: { type: 'ephemeral' },
-                },
-            ],
-            messages,
-            tools: tools.length ? tools : undefined,
-        }, { signal });
-        stream.on('text', (delta) => callbacks.onText?.(delta));
-        stream.on('contentBlock', (block) => {
-            if (block.type === 'tool_use') {
-                callbacks.onToolUseStart?.(block.name, block.id);
-            }
-        });
-        // thinking（若启用扩展思考）
-        stream.on('thinking', (delta) => callbacks.onThinking?.(delta));
-        const final = await stream.finalMessage();
-        return {
-            content: final.content,
-            stopReason: final.stop_reason,
-            usage: {
-                input: final.usage.input_tokens,
-                output: final.usage.output_tokens,
-            },
-        };
-    }
-}

package/dist/agent/factory.js

@@ -1,39 +0,0 @@
-import { Agent } from './loop.js';
-import { buildSystemPrompt } from './prompt.js';
-import { createDefaultRegistry, createReadOnlyRegistry, } from '../tools/index.js';
-import { TodoStore } from '../tools/todo.js';
-import { createTaskTool, SUBAGENT_SYSTEM, } from '../tools/task.js';
-import { HookRunner } from '../hooks/hooks.js';
-import { gatherContext } from '../context/project.js';
-export function buildAgent(opts) {
-    const { client, cwd, permissions } = opts;
-    const todos = new TodoStore();
-    const hooks = new HookRunner(cwd);
-    const registry = createDefaultRegistry();
-    // 子代理运行器:用只读工具集跑一个独立 Agent,返回最终文本。
-    const runner = async (description, prompt, subCwd) => {
-        const subRegistry = createReadOnlyRegistry();
-        const subAgent = new Agent(client, subRegistry, permissions, SUBAGENT_SYSTEM, { cwd: subCwd }, hooks);
-        let text = '';
-        let isError = false;
-        try {
-            await subAgent.run(prompt, {
-                onAssistantText: (d) => {
-                    text += d;
-                },
-                onTurnStart: () => { },
-                onTurnEnd: () => { },
-            });
-        }
-        catch (e) {
-            isError = true;
-            text = `子代理出错:${e?.message ?? e}`;
-        }
-        return { text: text.trim(), isError };
-    };
-    registry.register(createTaskTool(runner));
-    const ctx = gatherContext(cwd);
-    const system = buildSystemPrompt(ctx);
-    const agent = new Agent(client, registry, permissions, system, { cwd, todos }, hooks);
-    return { agent, todos, hooks, client };
-}

package/dist/agent/loop.js

@@ -1,163 +0,0 @@
-import { toAnthropicTool } from '../tools/index.js';
-const MAX_ITERATIONS = 50;
-export class Agent {
-    client;
-    registry;
-    permissions;
-    system;
-    toolCtx;
-    hooks;
-    history = [];
-    totalUsage = { input: 0, output: 0 };
-    constructor(client, registry, permissions, system, toolCtx, hooks) {
-        this.client = client;
-        this.registry = registry;
-        this.permissions = permissions;
-        this.system = system;
-        this.toolCtx = toolCtx;
-        this.hooks = hooks;
-    }
-    setSystem(s) {
-        this.system = s;
-    }
-    /** 处理一条用户输入，驱动完整的代理循环直到回合结束。 */
-    async run(userInput, events, signal) {
-        this.history.push({ role: 'user', content: userInput });
-        await this.loop(events, signal);
-    }
-    /** 注入工具结果后继续循环（用于外部恢复，一般内部调用）。 */
-    async loop(events, signal) {
-        const tools = this.registry.list().map(toAnthropicTool);
-        for (let i = 0; i < MAX_ITERATIONS; i++) {
-            if (signal?.aborted)
-                return;
-            events.onTurnStart?.();
-            let turn;
-            try {
-                turn = await this.client.stream(this.system, this.history, tools, {
-                    onText: (d) => events.onAssistantText?.(d),
-                    onThinking: (d) => events.onThinking?.(d),
-                }, signal);
-            }
-            catch (e) {
-                events.onTurnEnd?.();
-                if (signal?.aborted)
-                    return;
-                throw e;
-            }
-            events.onTurnEnd?.();
-            this.totalUsage.input += turn.usage.input;
-            this.totalUsage.output += turn.usage.output;
-            events.onUsage?.(turn.usage);
-            // 记录 assistant 回合
-            this.history.push({ role: 'assistant', content: turn.content });
-            // 收集 tool_use 块
-            const toolUses = turn.content.filter((b) => b.type === 'tool_use');
-            if (toolUses.length === 0) {
-                // 没有工具调用 —— 回合结束
-                return;
-            }
-            // 依次执行工具，收集 tool_result
-            const toolResults = [];
-            for (const tu of toolUses) {
-                if (signal?.aborted) {
-                    toolResults.push({
-                        type: 'tool_result',
-                        tool_use_id: tu.id,
-                        content: '用户中断了操作。',
-                        is_error: true,
-                    });
-                    continue;
-                }
-                const result = await this.executeTool(tu, events);
-                toolResults.push(result);
-            }
-            // 把工具结果作为新的 user 消息回传
-            this.history.push({ role: 'user', content: toolResults });
-            // 继续循环
-        }
-        // 达到迭代上限
-        this.history.push({
-            role: 'user',
-            content: '已达到工具调用上限，请总结当前进展。',
-        });
-    }
-    async executeTool(tu, events) {
-        const tool = this.registry.get(tu.name);
-        if (!tool) {
-            return {
-                type: 'tool_result',
-                tool_use_id: tu.id,
-                content: `未知工具：${tu.name}`,
-                is_error: true,
-            };
-        }
-        const preview = tool.preview ? tool.preview(tu.input, this.toolCtx) : tu.name;
-        events.onToolStart?.(tu.name, tu.input, preview);
-        // 权限检查
-        if (tool.permission) {
-            const req = tool.permission(tu.input, this.toolCtx);
-            if (req) {
-                const decision = await this.permissions.check(req);
-                if (decision === 'deny') {
-                    events.onToolDenied?.(tu.name, '用户拒绝了该操作');
-                    return {
-                        type: 'tool_result',
-                        tool_use_id: tu.id,
-                        content: '用户拒绝执行此操作。请不要重试相同操作，可以询问用户希望如何继续。',
-                        is_error: true,
-                    };
-                }
-            }
-        }
-        // PreToolUse 钩子:可阻止工具
-        if (this.hooks) {
-            const pre = this.hooks.runPre(tu.name, tu.input);
-            if (pre.blocked) {
-                events.onToolDenied?.(tu.name, `钩子拦截：${pre.reason ?? ''}`);
-                return {
-                    type: 'tool_result',
-                    tool_use_id: tu.id,
-                    content: `操作被 PreToolUse 钩子阻止：${pre.reason ?? '(无理由)'}`,
-                    is_error: true,
-                };
-            }
-        }
-        // 执行
-        try {
-            const res = await tool.run(tu.input, this.toolCtx);
-            this.hooks?.runPost(tu.name, tu.input, res.content);
-            events.onToolResult?.(tu.name, res.display ?? res.content.slice(0, 200), res.isError ?? false);
-            return {
-                type: 'tool_result',
-                tool_use_id: tu.id,
-                content: res.content,
-                is_error: res.isError ?? false,
-            };
-        }
-        catch (e) {
-            events.onToolResult?.(tu.name, `执行异常：${e.message}`, true);
-            return {
-                type: 'tool_result',
-                tool_use_id: tu.id,
-                content: `工具执行异常：${e.message}`,
-                is_error: true,
-            };
-        }
-    }
-    /** 清空对话历史（/clear）。 */
-    clear() {
-        this.history = [];
-        this.totalUsage = { input: 0, output: 0 };
-    }
-    /** 压缩历史（/compact）—— 简化实现：保留最近若干轮 + 摘要占位。 */
-    compactSummary(summary) {
-        this.history = [
-            { role: 'user', content: `[此前对话的摘要]\n${summary}` },
-            {
-                role: 'assistant',
-                content: '好的，我已了解此前的上下文，请继续。',
-            },
-        ];
-    }
-}

package/dist/agent/pricing.js

@@ -1,28 +0,0 @@
-const PRICES = [
-    { match: /opus/i, price: { input: 15, output: 75 } },
-    { match: /sonnet/i, price: { input: 3, output: 15 } },
-    { match: /haiku/i, price: { input: 0.8, output: 4 } },
-    // OpenAI 兼容后端(近似值,仅供参考)
-    { match: /qwen-max/i, price: { input: 1.6, output: 6.4 } },
-    { match: /qwen-plus/i, price: { input: 0.4, output: 1.2 } },
-    { match: /qwen-turbo|qwen-flash/i, price: { input: 0.05, output: 0.2 } },
-    { match: /qwen/i, price: { input: 0.4, output: 1.2 } },
-    { match: /deepseek/i, price: { input: 0.27, output: 1.1 } },
-    { match: /glm/i, price: { input: 0.5, output: 1.5 } },
-];
-const FALLBACK = { input: 3, output: 15 };
-export function priceFor(model) {
-    return PRICES.find((p) => p.match.test(model))?.price ?? FALLBACK;
-}
-/** 计算给定用量的美元成本。 */
-export function estimateCost(model, usage) {
-    const p = priceFor(model);
-    const input = (usage.input / 1_000_000) * p.input;
-    const output = (usage.output / 1_000_000) * p.output;
-    return { input, output, total: input + output };
-}
-export function formatUsd(n) {
-    if (n < 0.01)
-        return `$${n.toFixed(4)}`;
-    return `$${n.toFixed(4)}`;
-}

package/dist/agent/prompt.js

@@ -1,43 +0,0 @@
-/**
- * 系统提示词 —— 定义 Agent 的人格、工作流与约束。
- * 复刻 Claude Code 「AI 软件工程师」的代理型行为。
- */
-import { renderEnvironment } from '../context/project.js';
-const BASE_PROMPT = `你是 CCLI，一个运行在用户终端中的 AI 软件工程师，是 Claude Code 的开源复刻。
-你不仅能编写代码，更能理解整个代码库的架构与逻辑，并自主完成多步骤的开发任务。
-
-# 工作方式（代理循环 Agentic Loop）
-你的每一次响应都遵循「感知 → 推理 → 行动 → 验证」的循环：
-1. 感知：通过工具读取文件、运行命令、检索代码来收集事实，而不是猜测。
-2. 推理：基于事实规划要做的步骤。
-3. 行动：调用工具执行——读写文件、运行命令、修改代码。
-4. 验证：运行测试 / 类型检查 / 构建命令来确认改动正确，必要时修复。
-循环持续进行，直到用户的目标真正完成。
-
-# 行为准则
-- 务实、直接、简洁。这是 CLI 终端环境，避免冗长的寒暄和不必要的总结。
-- 默认用中文与用户交流（除非用户使用其他语言）。
-- 动手之前先用工具了解现状：阅读相关文件、搜索相关代码，理解现有约定（命名、风格、依赖）后再修改。
-- 修改代码时严格匹配周边代码的风格与缩进。不要主动添加未被要求的注释。
-- 不要假设某个库存在或可用——先检查（package.json、import 语句、已有用法）。
-- 一次只做用户要求的事，不擅自扩大范围。完成后简要说明做了什么。
-- 编辑文件后，主动运行可用的验证手段（测试、lint、typecheck、build），并修复发现的问题。
-- 涉及破坏性操作（删除文件、git push、覆盖重要文件）时保持谨慎，遵循权限机制。
-
-# 工具使用
-- 优先使用专用工具（read_file / edit_file / write_file / grep / glob / list_dir）而非 shell 等价命令。
-- 需要并行且互相独立的工具调用时，可在一次响应中同时发起。
-- bash 工具用于运行测试、构建、git 等命令；不要用它来读写文件（用专用工具更安全）。
-- 不要在没有读取文件内容的情况下编辑它。edit_file 要求 old_text 精确匹配（含缩进）。
-
-# 输出格式
-- 输出会以 GitHub 风格 Markdown 在终端渲染。可使用代码块、列表、粗体。
-- 引用代码位置时使用 \`文件路径:行号\` 格式，便于用户跳转。
-- 不要用表情包堆砌，保持专业。
-
-# 安全
-- 协助授权范围内的安全测试、防御性安全与教学场景。
-- 拒绝明显恶意的破坏性请求。`;
-export function buildSystemPrompt(ctx) {
-    return `${BASE_PROMPT}\n\n# 当前环境\n${renderEnvironment(ctx)}`;
-}

package/dist/agent/provider.js

@@ -1,18 +0,0 @@
-import { AnthropicClient } from './client.js';
-import { OpenAICompatClient } from './client-openai.js';
-export function createClient(config) {
-    const common = {
-        apiKey: config.apiKey,
-        model: config.model,
-        maxTokens: config.data.maxTokens,
-        temperature: config.data.temperature,
-    };
-    if (config.provider === 'openai') {
-        return new OpenAICompatClient({
-            ...common,
-            baseURL: config.data.baseURL ||
-                'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        });
-    }
-    return new AnthropicClient({ ...common, baseURL: config.data.baseURL });
-}

package/dist/cli/headless.js

@@ -1,50 +0,0 @@
-/**
- * 一次性（非交互）模式 —— 对应 `ccli -p "..."`。
- * 适合脚本与管道：自动批准只读工具，写操作默认按配置（可 -y 全自动）。
- */
-import { stdout } from 'node:process';
-import { createClient } from '../agent/provider.js';
-import { buildAgent } from '../agent/factory.js';
-import { PermissionManager, } from '../permissions/permissions.js';
-import { c, brand } from '../ui/theme.js';
-import { renderTodos } from '../tools/todo.js';
-import { expandMentions } from './mentions.js';
-export async function runHeadless(config, cwd, prompt) {
-    const client = createClient(config);
-    // 非交互：无法询问用户。未开启 autoApprove 时，对写操作拒绝并提示。
-    const asker = {
-        async ask(req) {
-            if (config.data.autoApprove)
-                return 'allow';
-            stdout.write(c.dim(`  [跳过未授权操作：${req.description}（非交互模式，加 -y 可自动批准）]\n`));
-            return 'deny';
-        },
-    };
-    const permissions = new PermissionManager(config, asker);
-    const { agent, todos } = buildAgent({ client, cwd, permissions });
-    const isTTY = stdout.isTTY ?? false;
-    if (isTTY) {
-        todos.onChange((items) => stdout.write('\n' + renderTodos(items) + '\n'));
-    }
-    const events = {
-        onTurnStart: () => { },
-        onTurnEnd: () => { },
-        onAssistantText: (d) => stdout.write(d),
-        onToolStart: (_t, _i, preview) => {
-            if (isTTY)
-                stdout.write('\n' + brand.accent('⚒ ') + preview + '\n');
-        },
-        onToolResult: (_t, display, isError) => {
-            if (isTTY)
-                stdout.write('  ' + display + '\n');
-        },
-    };
-    try {
-        await agent.run(expandMentions(prompt, cwd), events);
-        stdout.write('\n');
-    }
-    catch (e) {
-        stdout.write(brand.err('错误：') + (e?.message ?? String(e)) + '\n');
-        process.exit(1);
-    }
-}

package/dist/cli/mentions.js

@@ -1,60 +0,0 @@
-/**
- * @文件引用展开 —— 把用户输入中的 @path 自动并入文件内容。
- */
-import { existsSync, readFileSync, statSync, readdirSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-const MAX_PER_FILE = 4000;
-/**
- * 扫描输入中的 @path,对存在的文件/目录追加内容块。
- * 返回展开后的消息文本(原文 + 附加块)。
- */
-export function expandMentions(input, cwd) {
-    const re = /@([\w./_-]+)/g;
-    const seen = new Set();
-    const blocks = [];
-    let match;
-    while ((match = re.exec(input))) {
-        const p = match[1];
-        if (seen.has(p))
-            continue;
-        seen.add(p);
-        const full = isAbsolute(p) ? p : resolve(cwd, p);
-        if (!existsSync(full))
-            continue; // 不存在则当普通文字
-        try {
-            const st = statSync(full);
-            if (st.isDirectory()) {
-                const list = readdirSync(full)
-                    .filter((e) => e !== 'node_modules' && e !== '.git')
-                    .slice(0, 100)
-                    .join('\n');
-                blocks.push(`<directory path="${p}">\n${list}\n</directory>`);
-            }
-            else {
-                let text = readFileSync(full, 'utf8');
-                if (text.length > MAX_PER_FILE) {
-                    text = text.slice(0, MAX_PER_FILE) + '\n…（已截断）';
-                }
-                blocks.push(`<file path="${p}">\n${text}\n</file>`);
-            }
-        }
-        catch {
-            /* 读失败则忽略 */
-        }
-    }
-    if (!blocks.length)
-        return input;
-    return `${input}\n\n${blocks.join('\n\n')}`;
-}
-/** 返回输入中实际命中的引用路径(用于 UI 提示)。 */
-export function foundMentions(input, cwd) {
-    const re = /@([\w./_-]+)/g;
-    const out = [];
-    let m;
-    while ((m = re.exec(input))) {
-        const full = isAbsolute(m[1]) ? m[1] : resolve(cwd, m[1]);
-        if (existsSync(full))
-            out.push(m[1]);
-    }
-    return out;
-}