@gird/ccli 1.0.0

package/dist/index.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+/**
+ * CCLI 入口 —— 命令行参数解析与启动。
+ *
+ * 用法：
+ *   ccli                      进入交互式会话（REPL）
+ *   ccli -p "提示词"           一次性（非交互）模式，输出后退出
+ *   ccli --model <id>         指定模型
+ *   ccli config               配置 API Key
+ *   ccli --version / --help
+ */
+import * as readline from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { Config, DEFAULT_MODEL } from './config/config.js';
+import { Session } from './cli/session.js';
+import { c, brand } from './ui/theme.js';
+import { box } from './ui/markdown.js';
+import { runHeadless } from './cli/headless.js';
+import { SessionStore } from './session/store.js';
+import { loadDotenv } from './config/dotenv.js';
+const VERSION = '1.0.0';
+function parseArgs(argv) {
+    const args = { cwd: process.cwd() };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case '-p':
+            case '--print':
+                args.prompt = argv[++i];
+                break;
+            case '--model':
+            case '-m':
+                args.model = argv[++i];
+                break;
+            case '--cwd':
+                args.cwd = argv[++i];
+                break;
+            case '--dangerously-skip-permissions':
+            case '--yes':
+            case '-y':
+                args.autoApprove = true;
+                break;
+            case '--continue':
+            case '-c':
+                args.continueSession = true;
+                break;
+            case '--resume':
+            case '-r': {
+                args.resume = true;
+                const next = argv[i + 1];
+                if (next && !next.startsWith('-')) {
+                    args.resumeId = next;
+                    i++;
+                }
+                break;
+            }
+            case '--version':
+            case '-v':
+                args.command = 'version';
+                break;
+            case '--help':
+            case '-h':
+                args.command = 'help';
+                break;
+            case 'config':
+                args.command = 'config';
+                break;
+            default:
+                // 把裸参数当作 prompt
+                if (!a.startsWith('-') && !args.prompt) {
+                    args.prompt = argv.slice(i).join(' ');
+                    i = argv.length;
+                }
+        }
+    }
+    return args;
+}
+function printHelp() {
+    const lines = [
+        brand.primary(c.bold('CCLI')) + c.dim(`  v${VERSION} —— AI 软件工程师（Claude Code 复刻）`),
+        '',
+        c.bold('用法'),
+        `  ${brand.accent('ccli')}                      进入交互式会话`,
+        `  ${brand.accent('ccli "重构 utils 模块"')}    直接给出目标并进入会话`,
+        `  ${brand.accent('ccli -p "..."')}             一次性模式（输出后退出，适合脚本/管道）`,
+        `  ${brand.accent('ccli config')}               配置 API Key`,
+        '',
+        c.bold('选项'),
+        `  ${c.cyan('-p, --print <文本>')}        非交互模式`,
+        `  ${c.cyan('-m, --model <id>')}          指定模型（默认 claude-opus-4-8）`,
+        `  ${c.cyan('-y, --yes')}                 自动批准所有工具调用`,
+        `  ${c.cyan('-c, --continue')}            恢复本目录最近一次会话`,
+        `  ${c.cyan('-r, --resume [id]')}         列出/恢复历史会话`,
+        `  ${c.cyan('--cwd <目录>')}              指定工作目录`,
+        `  ${c.cyan('-v, --version')}             版本号`,
+        `  ${c.cyan('-h, --help')}                帮助`,
+        '',
+        c.bold('环境变量'),
+        `  ${c.cyan('ANTHROPIC_API_KEY')}        Anthropic API 密钥`,
+        `  ${c.cyan('ANTHROPIC_BASE_URL')}       自定义 API 端点（可选）`,
+    ];
+    stdout.write(box(lines) + '\n');
+}
+async function onboardApiKey(config) {
+    stdout.write(box([
+        brand.primary(c.bold('欢迎使用 CCLI')),
+        '',
+        '首次使用,先配置一个模型后端(将保存到 ~/.ccli/config.json)。',
+        '',
+        `  ${brand.accent('1')}  通义千问 Qwen ${c.dim('(OpenAI 兼容,推荐)')}`,
+        `  ${brand.accent('2')}  Anthropic Claude`,
+        `  ${brand.accent('3')}  其他 OpenAI 兼容后端 ${c.dim('(DeepSeek / GLM / 自建)')}`,
+    ], { color: brand.warn }) + '\n');
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+        const choice = (await rl.question(brand.primary('选择后端 [1] ❯ '))).trim() || '1';
+        if (choice === '2') {
+            config.data.provider = 'anthropic';
+            const key = (await rl.question(brand.primary('Anthropic API Key ❯ '))).trim();
+            if (!key)
+                return false;
+            config.data.apiKey = key;
+            config.data.baseURL = undefined;
+            config.data.model = DEFAULT_MODEL;
+        }
+        else if (choice === '3') {
+            config.data.provider = 'openai';
+            const base = (await rl.question(brand.primary('Base URL ❯ '))).trim();
+            const model = (await rl.question(brand.primary('模型 ID ❯ '))).trim();
+            const key = (await rl.question(brand.primary('API Key ❯ '))).trim();
+            if (!key || !base || !model)
+                return false;
+            config.data.apiKey = key;
+            config.data.baseURL = base;
+            config.data.model = model;
+        }
+        else {
+            // 默认:千问
+            config.data.provider = 'openai';
+            const key = (await rl.question(brand.primary('千问 API Key ') + c.dim('(sk-...) ❯ '))).trim();
+            if (!key)
+                return false;
+            config.data.apiKey = key;
+            config.data.baseURL =
+                'https://dashscope.aliyuncs.com/compatible-mode/v1';
+            const model = (await rl.question(brand.primary('模型 ') + c.dim('[qwen-plus] ❯ '))).trim();
+            config.data.model = model || 'qwen-plus';
+        }
+    }
+    finally {
+        rl.close();
+    }
+    config.saveGlobal();
+    stdout.write(brand.ok('✓ 已保存配置。') +
+        c.dim(` 后端 ${config.data.provider} · 模型 ${config.data.model}\n\n`));
+    return true;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    // 本地开发:自动加载 .env(不覆盖真实环境变量)
+    loadDotenv(args.cwd);
+    if (args.command === 'version') {
+        stdout.write(`ccli v${VERSION}\n`);
+        return;
+    }
+    if (args.command === 'help') {
+        printHelp();
+        return;
+    }
+    const config = new Config(args.cwd);
+    if (args.model) {
+        config.model = args.model;
+    }
+    if (args.autoApprove) {
+        config.data.autoApprove = true;
+    }
+    if (args.command === 'config') {
+        await onboardApiKey(config);
+        stdout.write([
+            `当前模型：${brand.accent(config.model)}`,
+            `配置文件：~/.ccli/config.json`,
+        ].join('\n') + '\n');
+        return;
+    }
+    // 检查 API Key
+    if (!config.apiKey) {
+        if (args.prompt) {
+            stdout.write(brand.err('错误：') +
+                '未设置 API Key。请先运行 ccli(无参数,引导配置),或 export ANTHROPIC_API_KEY / QWEN_API_KEY。\n');
+            process.exit(1);
+        }
+        const ok = await onboardApiKey(config);
+        if (!ok || !config.apiKey) {
+            stdout.write(c.dim('已退出。设置 API Key 后再运行 ccli。\n'));
+            process.exit(0);
+        }
+    }
+    // 一次性模式
+    if (args.prompt) {
+        await runHeadless(config, args.cwd, args.prompt);
+        return;
+    }
+    // 会话恢复
+    let resumeFrom;
+    if (args.resume && !args.resumeId) {
+        // 列出供选择
+        const all = SessionStore.list(args.cwd);
+        if (!all.length) {
+            stdout.write(c.dim('该目录暂无历史会话，将开启新会话。\n'));
+        }
+        else {
+            stdout.write(brand.primary('该目录的历史会话：\n'));
+            for (const s of all.slice(0, 10)) {
+                stdout.write(`  ${brand.accent(s.id)}  ${c.dim(s.updatedAt.replace('T', ' ').slice(0, 16))}  ${c.dim(`${s.messages.length} 条`)}\n`);
+            }
+            stdout.write(c.dim('用 ccli --resume <id> 恢复指定会话。本次将开启新会话。\n\n'));
+        }
+    }
+    else if ((args.continueSession || args.resumeId) && config.apiKey) {
+        const data = SessionStore.load(args.cwd, args.resumeId);
+        if (data) {
+            resumeFrom = data;
+            config.model = data.model;
+            stdout.write(c.dim(`已恢复会话 ${data.id}（${data.messages.length} 条历史）。\n\n`));
+        }
+        else {
+            stdout.write(c.dim('未找到可恢复的会话，将开启新会话。\n\n'));
+        }
+    }
+    // 交互式会话
+    const session = new Session(config, args.cwd, resumeFrom);
+    await session.start();
+}
+main().catch((e) => {
+    stdout.write(brand.err('\n致命错误：') + (e?.stack ?? e?.message ?? String(e)) + '\n');
+    process.exit(1);
+});

package/dist/permissions/permissions.js

@@ -0,0 +1,87 @@
+// 只读工具：默认无需确认
+const SAFE_TOOLS = new Set(['read_file', 'list_dir', 'grep', 'glob']);
+// 危险命令模式
+const DANGEROUS_PATTERNS = [
+    /\brm\s+-rf?\b/,
+    /\bgit\s+push\b/,
+    /\bgit\s+reset\s+--hard\b/,
+    /\bsudo\b/,
+    /\bchmod\s+-R\b/,
+    /\b(mkfs|dd)\b/,
+    /\b:\(\)\s*\{.*\};\s*:/, // fork bomb
+    /\bcurl\b.*\|\s*(sh|bash)\b/,
+    /\bnpm\s+publish\b/,
+    /\bgit\s+push\s+.*--force\b/,
+    />\s*\/dev\/sd/,
+];
+export function isDangerousCommand(cmd) {
+    return DANGEROUS_PATTERNS.some((re) => re.test(cmd));
+}
+/** 提取 bash 命令的「命令前缀」用于白名单匹配，如 'npm test'。 */
+export function commandPrefix(cmd) {
+    const trimmed = cmd.trim();
+    // 取第一个管道/分号前的片段
+    const first = trimmed.split(/[|;&]/)[0].trim();
+    const parts = first.split(/\s+/);
+    // 保留命令 + 第一个子命令（如 git status / npm test）
+    if (parts.length >= 2 && /^(git|npm|yarn|pnpm|cargo|go|docker|make)$/.test(parts[0])) {
+        return `${parts[0]} ${parts[1]}`;
+    }
+    return parts[0] || trimmed;
+}
+export class PermissionManager {
+    config;
+    asker;
+    constructor(config, asker) {
+        this.config = config;
+        this.asker = asker;
+    }
+    /** 判断某次工具调用是否被允许，必要时询问用户。 */
+    async check(req) {
+        // 自动批准模式
+        if (this.config.data.autoApprove)
+            return 'allow';
+        // 只读工具放行
+        if (SAFE_TOOLS.has(req.tool))
+            return 'allow';
+        // 拒绝白名单优先
+        if (this.matchRule(this.config.data.deniedTools, req))
+            return 'deny';
+        // 批准白名单
+        if (this.matchRule(this.config.data.allowedTools, req))
+            return 'allow';
+        // 询问用户
+        const answer = await this.asker.ask(req);
+        if (answer === 'deny')
+            return 'deny';
+        if (answer === 'always') {
+            this.config.addAllowed(req.rule);
+            // 同时把工具级别也加入（如 'Edit'），便于后续同类放行
+            this.config.addAllowed(toolLevelRule(req.tool));
+            return 'allow';
+        }
+        return 'allow';
+    }
+    matchRule(rules, req) {
+        for (const r of rules) {
+            if (r === req.rule)
+                return true;
+            // 工具级通配，如 'Edit' 匹配所有 edit_file
+            if (r === toolLevelRule(req.tool))
+                return true;
+            // 前缀匹配，如 'Bash(npm)' 匹配 'Bash(npm test)'
+            if (req.rule.startsWith(r.replace(/\)$/, '')))
+                return true;
+        }
+        return false;
+    }
+}
+export function toolLevelRule(tool) {
+    const map = {
+        bash: 'Bash',
+        edit_file: 'Edit',
+        write_file: 'Write',
+        read_file: 'Read',
+    };
+    return map[tool] ?? tool;
+}

package/dist/session/store.js

@@ -0,0 +1,81 @@
+/**
+ * 会话持久化 —— 把对话历史落盘,支持 --continue / --resume。
+ * 存储路径:~/.ccli/sessions/<cwd 哈希>/<sessionId>.json
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { createHash, randomUUID } from 'node:crypto';
+function sessionsRoot() {
+    return join(homedir(), '.ccli', 'sessions');
+}
+function cwdDir(cwd) {
+    const hash = createHash('sha1').update(cwd).digest('hex').slice(0, 12);
+    return join(sessionsRoot(), hash);
+}
+export class SessionStore {
+    id;
+    cwd;
+    dir;
+    createdAt;
+    constructor(cwd, id) {
+        this.cwd = cwd;
+        this.id = id ?? randomUUID().slice(0, 8);
+        this.dir = cwdDir(cwd);
+        this.createdAt = new Date().toISOString();
+    }
+    path() {
+        return join(this.dir, `${this.id}.json`);
+    }
+    save(model, messages) {
+        try {
+            if (!existsSync(this.dir))
+                mkdirSync(this.dir, { recursive: true });
+            const data = {
+                id: this.id,
+                cwd: this.cwd,
+                model,
+                createdAt: this.createdAt,
+                updatedAt: new Date().toISOString(),
+                messages,
+            };
+            writeFileSync(this.path(), JSON.stringify(data), 'utf8');
+        }
+        catch {
+            /* 落盘失败不影响主流程 */
+        }
+    }
+    /** 列出该 cwd 下的会话,按更新时间倒序。 */
+    static list(cwd) {
+        const dir = cwdDir(cwd);
+        if (!existsSync(dir))
+            return [];
+        const out = [];
+        for (const f of readdirSync(dir)) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                out.push(JSON.parse(readFileSync(join(dir, f), 'utf8')));
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    /** 加载指定会话(id 可省略 → 最新一条)。 */
+    static load(cwd, id) {
+        const all = SessionStore.list(cwd);
+        if (!all.length)
+            return null;
+        if (!id)
+            return all[0];
+        return all.find((s) => s.id === id) ?? null;
+    }
+    /** 用已有 SessionData 构造一个续写的 store(保留原 id 与创建时间)。 */
+    static resume(data) {
+        const s = new SessionStore(data.cwd, data.id);
+        s.createdAt = data.createdAt;
+        return s;
+    }
+}

package/dist/tools/bash.js

@@ -0,0 +1,97 @@
+/**
+ * bash 工具 —— 通过 child_process 执行 shell 命令。
+ * 用于运行测试、构建、git 等命令。受权限机制约束，高危命令需二次确认。
+ */
+import { spawn } from 'node:child_process';
+import { c, brand } from '../ui/theme.js';
+import { commandPrefix, isDangerousCommand, } from '../permissions/permissions.js';
+const DEFAULT_TIMEOUT = 120_000;
+const MAX_OUTPUT = 30_000;
+export const bashTool = {
+    name: 'bash',
+    description: '在持久化的工作目录中执行 shell 命令（zsh/bash）。用于运行测试、构建、git、安装依赖等。不要用它来读写文件——请用 read_file/write_file/edit_file。避免交互式命令。',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: '要执行的 shell 命令' },
+            timeout: {
+                type: 'number',
+                description: '超时毫秒数（默认 120000，最大 600000）',
+            },
+            description: {
+                type: 'string',
+                description: '对该命令用途的一句话说明（5-10 字）',
+            },
+        },
+        required: ['command'],
+    },
+    permission(input) {
+        const cmd = String(input.command || '');
+        const prefix = commandPrefix(cmd);
+        const dangerous = isDangerousCommand(cmd);
+        return {
+            tool: 'bash',
+            rule: `Bash(${prefix})`,
+            description: input.description
+                ? `${input.description}：${cmd}`
+                : `执行：${cmd}`,
+            dangerous,
+        };
+    },
+    preview(input) {
+        return `${brand.accent('$')} ${input.command}`;
+    },
+    async run(input, ctx) {
+        const cmd = String(input.command || '');
+        const timeout = Math.min(input.timeout ?? DEFAULT_TIMEOUT, 600_000);
+        return new Promise((resolveP) => {
+            const shell = process.env.SHELL || '/bin/bash';
+            const child = spawn(shell, ['-c', cmd], {
+                cwd: ctx.cwd,
+                env: process.env,
+            });
+            let stdout = '';
+            let stderr = '';
+            let killed = false;
+            const timer = setTimeout(() => {
+                killed = true;
+                child.kill('SIGKILL');
+            }, timeout);
+            child.stdout.on('data', (d) => {
+                stdout += d.toString();
+                if (stdout.length > MAX_OUTPUT)
+                    stdout = stdout.slice(0, MAX_OUTPUT);
+            });
+            child.stderr.on('data', (d) => {
+                stderr += d.toString();
+                if (stderr.length > MAX_OUTPUT)
+                    stderr = stderr.slice(0, MAX_OUTPUT);
+            });
+            child.on('error', (e) => {
+                clearTimeout(timer);
+                resolveP({ content: `命令启动失败：${e.message}`, isError: true });
+            });
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                const combined = [stdout, stderr].filter(Boolean).join('\n').trim();
+                if (killed) {
+                    resolveP({
+                        content: `命令超时（${timeout}ms）被终止。\n部分输出：\n${combined.slice(0, 4000)}`,
+                        isError: true,
+                    });
+                    return;
+                }
+                const exitNote = code === 0 ? '' : `\n[退出码 ${code}]`;
+                const body = combined || '（无输出）';
+                const truncated = body.length >= MAX_OUTPUT ? '\n…（输出已截断）' : '';
+                resolveP({
+                    content: `${body}${truncated}${exitNote}`,
+                    isError: code !== 0,
+                    display: code === 0
+                        ? `${brand.ok('✓')} ${c.dim(cmd)}`
+                        : `${brand.err('✗')} ${c.dim(cmd)} ${c.dim(`(退出码 ${code})`)}`,
+                });
+            });
+        });
+    },
+};