evolclaw 2.8.3 → 3.1.0

package/dist/cli/init.js

@@ -0,0 +1,178 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { resolvePaths, ensureDataDirs } from '../paths.js';
+import { commandExists } from '../utils/cross-platform.js';
+import { scanInstances } from '../utils/instance-registry.js';
+// ==================== Helpers ====================
+function ask(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+const BASEAGENT_CANDIDATES = ['claude', 'codex', 'gemini'];
+const BASEAGENT_ENV_KEY = {
+    claude: 'ANTHROPIC_API_KEY',
+    codex: 'OPENAI_API_KEY',
+    gemini: 'GEMINI_API_KEY',
+};
+function detectAvailable() {
+    return BASEAGENT_CANDIDATES.filter(b => commandExists(b));
+}
+function pickDefault(available) {
+    return (available.includes('claude') ? 'claude' : available[0]);
+}
+function buildDefaults(chosen) {
+    const env = BASEAGENT_ENV_KEY[chosen];
+    return {
+        $schema_version: 1,
+        active_baseagent: chosen,
+        baseagents: { [chosen]: env ? { apiKey: `$ENV:${env}` } : {} },
+    };
+}
+function writeDefaults(defaultsPath, chosen) {
+    fs.mkdirSync(path.dirname(defaultsPath), { recursive: true });
+    fs.writeFileSync(defaultsPath, JSON.stringify(buildDefaults(chosen), null, 2) + '\n');
+}
+// ==================== Main ====================
+export async function cmdInit(options) {
+    const p = resolvePaths();
+    ensureDataDirs();
+    // ── 1. 单进程互斥 ──
+    const aliveMains = scanInstances().mains.filter(m => m.alive);
+    if (aliveMains.length > 0) {
+        const pids = aliveMains.map(m => m.record.pid).join(', ');
+        console.log(`❌ EvolClaw 正在运行 (PID: ${pids})，请先执行 evolclaw stop`);
+        return;
+    }
+    // ── 2. 探测 baseagent ──
+    const available = detectAvailable();
+    if (available.length === 0) {
+        console.log('❌ 未检测到任何 baseagent CLI，请先安装至少一款：');
+        for (const b of BASEAGENT_CANDIDATES)
+            console.log(`  - ${b}`);
+        console.log('\n安装后重新运行 evolclaw init');
+        return;
+    }
+    console.log('检测到可用的 baseagent:');
+    for (const b of available)
+        console.log(`  ● ${b}`);
+    console.log('');
+    const defaultsPath = p.defaultsConfig;
+    const exists = fs.existsSync(defaultsPath);
+    // ── 3. 非交互式分支 ──
+    if (options?.nonInteractive) {
+        if (exists && !options.force) {
+            console.log(`❌ 配置已存在: ${defaultsPath}（加 --force 可覆盖）`);
+            return;
+        }
+        let chosen;
+        if (options.baseagent) {
+            if (!BASEAGENT_CANDIDATES.includes(options.baseagent)) {
+                console.log(`❌ 无效 baseagent: ${options.baseagent}（可选: ${BASEAGENT_CANDIDATES.join('/')}）`);
+                return;
+            }
+            if (!available.includes(options.baseagent)) {
+                console.log(`❌ ${options.baseagent} 未在 PATH 中检测到（可用: ${available.join('/')}）`);
+                return;
+            }
+            chosen = options.baseagent;
+        }
+        else {
+            chosen = pickDefault(available);
+        }
+        writeDefaults(defaultsPath, chosen);
+        console.log(`✓ 已${exists ? '覆盖' : '创建'}: ${defaultsPath}`);
+        console.log(`  active_baseagent: ${chosen}`);
+        return;
+    }
+    // ── 4. 交互式分支 ──
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        if (exists) {
+            const ans = (await ask(rl, `配置文件已存在: ${defaultsPath}\n  是否覆盖？[y/N] `)).trim().toLowerCase();
+            if (ans !== 'y' && ans !== 'yes') {
+                console.log('  已取消');
+                return;
+            }
+        }
+        const defaultBa = pickDefault(available);
+        let chosen = null;
+        while (chosen === null) {
+            const input = (await ask(rl, `默认 baseagent (${available.join('/')}) [${defaultBa}]: `)).trim() || defaultBa;
+            if (!BASEAGENT_CANDIDATES.includes(input)) {
+                console.log(`  无效选择，可选: ${BASEAGENT_CANDIDATES.join('/')}`);
+                continue;
+            }
+            if (!available.includes(input)) {
+                console.log(`  ${input} 未在 PATH 中检测到（可用: ${available.join('/')}）`);
+                continue;
+            }
+            chosen = input;
+        }
+        writeDefaults(defaultsPath, chosen);
+        console.log(`\n✓ 已${exists ? '覆盖' : '创建'}: ${defaultsPath}`);
+        console.log(`  active_baseagent: ${chosen}\n`);
+        rl.close();
+        // ── 5. 嵌套 agent new ──
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('下一步：创建 agent\n');
+        const { agentCreateInteractive } = await import('./agent.js');
+        const result = await agentCreateInteractive();
+        if (!result.ok) {
+            console.error(`❌ ${result.error}`);
+        }
+    }
+    finally {
+        try {
+            rl.close();
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Present instance selection menu when existing instances are found.
+ * Returns the user's choice, or null if cancelled.
+ */
+export async function selectInstance(rl, channelType, instances) {
+    const typeLabel = channelType === 'feishu' ? '飞书' : channelType === 'wechat' ? '微信' : channelType === 'dingtalk' ? '钉钉' : channelType === 'qqbot' ? 'QQ机器人' : channelType === 'wecom' ? '企业微信' : channelType.toUpperCase();
+    console.log(`\n发现已有 ${typeLabel} 配置：`);
+    const letters = 'abcdefghijklmnopqrstuvwxyz';
+    for (let i = 0; i < instances.length; i++) {
+        const inst = instances[i];
+        const id = inst.aid || inst.appId || inst.botId || inst.clientId || inst.token?.slice(0, 16) || '';
+        const suffix = id ? ` (${id})` : '';
+        console.log(`  ${letters[i]}. ${inst.name}${suffix}`);
+    }
+    const addLetter = letters[instances.length];
+    console.log(`  ${addLetter}. 添加新配置`);
+    console.log('');
+    const validOptions = letters.slice(0, instances.length + 1).split('');
+    let choice = '';
+    while (!validOptions.includes(choice)) {
+        choice = (await new Promise(r => rl.question('请选择: ', r))).trim().toLowerCase();
+        if (!validOptions.includes(choice)) {
+            console.log(`无效选择，请输入 ${validOptions.join('/')}`);
+        }
+    }
+    const choiceIndex = letters.indexOf(choice);
+    if (choiceIndex === instances.length) {
+        let name = '';
+        while (!name) {
+            name = (await new Promise(r => rl.question('请输入新配置名称: ', r))).trim();
+            if (!name)
+                console.log('  名称不能为空');
+            if (instances.some(i => i.name === name)) {
+                console.log(`  名称 "${name}" 已存在，请换一个`);
+                name = '';
+            }
+        }
+        return { action: 'add', name };
+    }
+    const target = instances[choiceIndex];
+    console.log(`\n已选择：${target.name}`);
+    const confirm = (await new Promise(r => rl.question(`⚠️ 即将覆盖该配置，确认？(y/N) `, r))).trim().toLowerCase();
+    if (confirm !== 'y' && confirm !== 'yes') {
+        console.log('已取消');
+        return null;
+    }
+    return { action: 'overwrite', index: choiceIndex, name: target.name };
+}

package/dist/cli/link-rules.js

@@ -0,0 +1,245 @@
+import fs from 'fs';
+import path from 'path';
+import { kitsRulesDir, resolvePaths } from '../paths.js';
+import { atomicWriteJson, atomicReadJson } from '../utils/atomic-write.js';
+const isWindows = process.platform === 'win32';
+const KNOWN_BASEAGENTS = ['cc', 'codex', 'gemini'];
+function statePath() {
+    return path.join(resolvePaths().eckDir, 'link-state.json');
+}
+function loadState() {
+    return atomicReadJson(statePath()) ?? {};
+}
+function saveState(state) {
+    atomicWriteJson(statePath(), state);
+}
+function getEntry(state, ba) {
+    return state[ba] ?? { current: null, history: [] };
+}
+function pushHistory(entry, dir) {
+    entry.history = [dir, ...entry.history.filter(h => h !== dir)].slice(0, 5);
+}
+// ── symlink 目标路径（baseagent 决定放哪）──
+function resolveTarget(ba, dir) {
+    switch (ba) {
+        case 'cc':
+            return path.join(dir, '.claude', 'rules', 'eck');
+        case 'codex':
+            return path.join(dir, '.codex', 'rules', 'eck');
+        case 'gemini':
+            return path.join(dir, '.gemini', 'rules', 'eck');
+        default:
+            return path.join(dir, '.claude', 'rules', 'eck');
+    }
+}
+// ── 创建 symlink/junction ──
+function createLink(source, target) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    if (isWindows) {
+        fs.symlinkSync(source, target, 'junction');
+    }
+    else {
+        fs.symlinkSync(source, target, 'dir');
+    }
+}
+// ── 删除 symlink/junction + 逐级清理空目录 ──
+function removeLink(target) {
+    if (!fs.existsSync(target))
+        return false;
+    const stat = fs.lstatSync(target);
+    if (stat.isSymbolicLink()) {
+        fs.rmSync(target, { recursive: true });
+    }
+    else if (isWindows && stat.isDirectory()) {
+        const real = fs.realpathSync(target);
+        const resolved = path.resolve(target);
+        if (real.toLowerCase() === resolved.toLowerCase()) {
+            return false; // regular directory, not a junction
+        }
+        fs.rmSync(target, { recursive: true });
+    }
+    else {
+        return false;
+    }
+    cleanEmptyParents(path.dirname(target));
+    return true;
+}
+function cleanEmptyParents(dir) {
+    try {
+        const entries = fs.readdirSync(dir);
+        if (entries.length > 0)
+            return;
+        fs.rmdirSync(dir);
+        cleanEmptyParents(path.dirname(dir));
+    }
+    catch {
+        // stop on error (permission, root, etc.)
+    }
+}
+// ── 子命令 ──
+function showHelp() {
+    console.log(`Usage: evolclaw link-rules <subcommand> [baseagent] [--dir <path>]
+
+Subcommands:
+  connect       Connect ECK rules to a project directory (default: cwd)
+  disconnect    Remove ECK rules connection for a baseagent
+  status        Show connection state for all baseagents
+
+Arguments:
+  baseagent     Target base agent: ${KNOWN_BASEAGENTS.join(', ')} (default: cc)
+  --dir <path>  Target directory (default: current working directory)
+
+Supported baseagents:
+  cc            Claude Code (.claude/rules/eck/)
+  codex         Codex (.codex/rules/eck/)
+  gemini        Gemini CLI (.gemini/rules/eck/)
+
+Examples:
+  evolclaw link-rules connect              # connect cc in cwd
+  evolclaw link-rules connect codex        # connect codex in cwd
+  evolclaw link-rules connect cc --dir /x  # connect cc in specific dir
+  evolclaw link-rules disconnect cc        # disconnect cc
+  evolclaw link-rules status               # show all connections`);
+}
+function showStatus() {
+    const state = loadState();
+    const source = kitsRulesDir();
+    console.log(`ECK rules source: ${source}\n`);
+    for (const ba of KNOWN_BASEAGENTS) {
+        const entry = getEntry(state, ba);
+        const status = entry.current ? '● connected' : '○ disconnected';
+        console.log(`[${ba}] ${status}`);
+        if (entry.current) {
+            const target = resolveTarget(ba, entry.current);
+            console.log(`  path:  ${entry.current}`);
+            console.log(`  link:  ${target}`);
+            console.log(`  rules: ${source}`);
+        }
+        if (entry.history.length > 0) {
+            console.log(`  history:`);
+            for (const h of entry.history) {
+                console.log(`    - ${h}`);
+            }
+        }
+        console.log('');
+    }
+}
+function connect(ba, dir) {
+    const source = kitsRulesDir();
+    if (!fs.existsSync(source)) {
+        console.error(`❌ kits/rules/ not found at: ${source}`);
+        process.exit(1);
+    }
+    const absDir = path.resolve(dir);
+    if (!fs.existsSync(absDir)) {
+        console.error(`❌ Directory does not exist: ${absDir}`);
+        process.exit(1);
+    }
+    const state = loadState();
+    const entry = getEntry(state, ba);
+    // disconnect old link if exists (different dir)
+    if (entry.current && entry.current !== absDir) {
+        const oldTarget = resolveTarget(ba, entry.current);
+        removeLink(oldTarget);
+        console.log(`  disconnected old: ${entry.current}`);
+    }
+    // create new link
+    const target = resolveTarget(ba, absDir);
+    if (fs.existsSync(target)) {
+        // already linked here — check if it points to our source
+        try {
+            const real = fs.realpathSync(target);
+            const sourceReal = fs.realpathSync(source);
+            if (pathEquals(real, sourceReal)) {
+                console.log(`✓ Already connected: [${ba}] → ${absDir}`);
+                entry.current = absDir;
+                pushHistory(entry, absDir);
+                state[ba] = entry;
+                saveState(state);
+                return;
+            }
+        }
+        catch { /* fall through */ }
+        console.error(`❌ Target already exists and points elsewhere: ${target}`);
+        console.error(`   Run 'evolclaw link-rules disconnect ${ba}' first, or remove manually.`);
+        process.exit(1);
+    }
+    createLink(source, target);
+    entry.current = absDir;
+    pushHistory(entry, absDir);
+    state[ba] = entry;
+    saveState(state);
+    console.log(`✓ Connected: [${ba}] ${absDir}`);
+    console.log(`  ${target} → ${source}`);
+}
+function disconnect(ba) {
+    const state = loadState();
+    const entry = getEntry(state, ba);
+    if (!entry.current) {
+        console.log(`[${ba}] not connected.`);
+        return;
+    }
+    const target = resolveTarget(ba, entry.current);
+    const removed = removeLink(target);
+    if (removed) {
+        console.log(`✓ Disconnected: [${ba}] ${entry.current}`);
+    }
+    else if (!fs.existsSync(target)) {
+        console.log(`✓ Disconnected: [${ba}] (link was already gone)`);
+    }
+    else {
+        console.error(`❌ Could not remove: ${target} (not a symlink/junction)`);
+    }
+    entry.current = null;
+    state[ba] = entry;
+    saveState(state);
+}
+// ── 入口 ──
+export function cmdLinkRules(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        showHelp();
+        return;
+    }
+    const sub = args[0];
+    if (sub === 'status') {
+        showStatus();
+        return;
+    }
+    if (sub === 'disconnect') {
+        const ba = resolveBaseAgent(args[1]);
+        disconnect(ba);
+        return;
+    }
+    if (sub === 'connect') {
+        const ba = resolveBaseAgent(args[1] && !args[1].startsWith('-') ? args[1] : undefined);
+        const dir = getArgValue(args, '--dir') || process.cwd();
+        connect(ba, dir);
+        return;
+    }
+    // no subcommand or unknown → show help
+    showHelp();
+}
+function resolveBaseAgent(input) {
+    if (!input || input === 'claude-code')
+        return 'cc';
+    if (KNOWN_BASEAGENTS.includes(input))
+        return input;
+    // allow full names
+    if (input === 'claude' || input === 'claude-code')
+        return 'cc';
+    console.error(`❌ Unknown baseagent: ${input}`);
+    console.error(`   Supported: ${KNOWN_BASEAGENTS.join(', ')}`);
+    process.exit(1);
+}
+function getArgValue(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function pathEquals(a, b) {
+    if (isWindows) {
+        return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+    }
+    return path.resolve(a) === path.resolve(b);
+}