@winspan/claude-forge 0.1.9 → 0.2.0

package/dist/cli/commands/init.js

@@ -1,811 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import readline from 'readline';
-import { spawn } from 'child_process';
-import { success, info, warning, heading, error } from '../utils/output.js';
-import { ConfigManager } from '../../config/index.js';
-import { detectBestModel } from '../../utils/claude-api.js';
-import { isRunning } from '../../daemon/lifecycle.js';
-const FORGE_HOME = path.join(os.homedir(), '.claude-forge');
-const CLAUDE_HOME = path.join(os.homedir(), '.claude');
-const SETTINGS_PATH = path.join(CLAUDE_HOME, 'settings.json');
-const HOOKS_DIR = path.join(FORGE_HOME, 'hooks');
-const HOOK_SCRIPT_NAMES = [
-    'pre-tool-use.sh',
-    'post-tool-use.sh',
-    'check-context-limit.sh',
-    'user-prompt-submit.sh',
-    'notification.sh',
-    'stop.sh',
-];
-function isForgeCommand(cmd) {
-    return cmd.includes('claude-forge') || cmd.includes('.claude-forge');
-}
-/** 顶层或嵌套 hooks 内是否指向 claude-forge 脚本 */
-function entryRefersToForge(entry) {
-    const top = entry.command;
-    if (typeof top === 'string' && isForgeCommand(top)) {
-        return true;
-    }
-    if (Array.isArray(entry.hooks)) {
-        return entry.hooks.some((sub) => {
-            if (typeof sub !== 'object' || sub === null)
-                return false;
-            const c = sub.command;
-            return typeof c === 'string' && isForgeCommand(c);
-        });
-    }
-    return false;
-}
-/** 将旧版扁平 { type, command } forge 项转为 matcher + hooks（Claude Code 当前要求） */
-function normalizeLegacyForgeEntry(entry) {
-    if (Array.isArray(entry.hooks)) {
-        return entry;
-    }
-    const cmd = entry.command;
-    const type = typeof entry.type === 'string' ? entry.type : 'command';
-    if (typeof cmd === 'string' && isForgeCommand(cmd)) {
-        return {
-            matcher: typeof entry.matcher === 'string' ? entry.matcher : '',
-            hooks: [{ type, command: cmd }],
-        };
-    }
-    return entry;
-}
-function parseHookEntry(raw) {
-    if (typeof raw === 'object' && raw !== null) {
-        return raw;
-    }
-    return {};
-}
-function getForgeHookEntries() {
-    return {
-        PreToolUse: {
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'pre-tool-use.sh')}`,
-                },
-            ],
-        },
-        PostToolUse: {
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'post-tool-use.sh')}`,
-                },
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'check-context-limit.sh')}`,
-                },
-            ],
-        },
-        UserPromptSubmit: {
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'user-prompt-submit.sh')}`,
-                },
-            ],
-        },
-        Notification: {
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'notification.sh')}`,
-                },
-            ],
-        },
-        Stop: {
-            matcher: '',
-            hooks: [
-                {
-                    type: 'command',
-                    command: `bash ${path.join(HOOKS_DIR, 'stop.sh')}`,
-                },
-            ],
-        },
-    };
-}
-function copyHookScripts() {
-    if (!fs.existsSync(HOOKS_DIR)) {
-        fs.mkdirSync(HOOKS_DIR, { recursive: true });
-    }
-    const srcHooksDir = path.join(path.dirname(new URL(import.meta.url).pathname), '../../hooks');
-    for (const file of HOOK_SCRIPT_NAMES) {
-        const src = path.join(srcHooksDir, file);
-        const dest = path.join(HOOKS_DIR, file);
-        if (fs.existsSync(src)) {
-            fs.copyFileSync(src, dest);
-            fs.chmodSync(dest, 0o755);
-        }
-    }
-}
-function backupSettings() {
-    if (!fs.existsSync(SETTINGS_PATH)) {
-        return null;
-    }
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupPath = `${SETTINGS_PATH}.backup-${timestamp}`;
-    fs.copyFileSync(SETTINGS_PATH, backupPath);
-    return backupPath;
-}
-function injectHooks() {
-    let settings = {};
-    if (fs.existsSync(SETTINGS_PATH)) {
-        const content = fs.readFileSync(SETTINGS_PATH, 'utf-8');
-        settings = JSON.parse(content);
-    }
-    if (!settings.hooks) {
-        settings.hooks = {};
-    }
-    const forgeHooks = getForgeHookEntries();
-    for (const [hookType, block] of Object.entries(forgeHooks)) {
-        const existingRaw = settings.hooks[hookType] ?? [];
-        const normalized = existingRaw.map((item) => {
-            const e = parseHookEntry(item);
-            return normalizeLegacyForgeEntry(e);
-        });
-        const alreadyInjected = normalized.some((item) => entryRefersToForge(item));
-        if (!alreadyInjected) {
-            settings.hooks[hookType] = [...normalized, block];
-        }
-        else {
-            settings.hooks[hookType] = normalized;
-        }
-    }
-    // 确保 .claude 目录存在
-    if (!fs.existsSync(CLAUDE_HOME)) {
-        fs.mkdirSync(CLAUDE_HOME, { recursive: true });
-    }
-    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf-8');
-}
-/**
- * 检测 ~/.claude-forge/hooks 脚本与 ~/.claude/settings.json 中 Forge 注入是否完整。
- * Daemon 未运行仅作提示，不纳入 hooksHealthy。
- */
-export function diagnoseForgeHookEnvironment() {
-    const items = [];
-    items.push({
-        id: 'forge_home',
-        label: 'Forge 数据目录',
-        ok: fs.existsSync(FORGE_HOME),
-        detail: FORGE_HOME,
-    });
-    for (const name of HOOK_SCRIPT_NAMES) {
-        const p = path.join(HOOKS_DIR, name);
-        items.push({
-            id: `hook_script_${name.replace(/\W/g, '_')}`,
-            label: `Hook 脚本: ${name}`,
-            ok: fs.existsSync(p),
-            detail: p,
-        });
-    }
-    const forgeTypes = Object.keys(getForgeHookEntries());
-    if (!fs.existsSync(SETTINGS_PATH)) {
-        items.push({
-            id: 'claude_settings',
-            label: 'Claude settings.json',
-            ok: false,
-            detail: `缺失: ${SETTINGS_PATH}`,
-        });
-        for (const hookType of forgeTypes) {
-            items.push({
-                id: `settings_hook_${hookType}`,
-                label: `settings 中 ${hookType} 注入`,
-                ok: false,
-                detail: 'settings 文件不存在，无法检测',
-            });
-        }
-    }
-    else {
-        items.push({
-            id: 'claude_settings',
-            label: 'Claude settings.json',
-            ok: true,
-            detail: SETTINGS_PATH,
-        });
-        try {
-            const content = fs.readFileSync(SETTINGS_PATH, 'utf-8');
-            const settings = JSON.parse(content);
-            for (const hookType of forgeTypes) {
-                const raw = settings.hooks?.[hookType];
-                const normalized = (raw ?? []).map((item) => {
-                    const e = parseHookEntry(item);
-                    return normalizeLegacyForgeEntry(e);
-                });
-                const injected = normalized.some((item) => entryRefersToForge(item));
-                items.push({
-                    id: `settings_hook_${hookType}`,
-                    label: `settings 中 ${hookType} Forge 注入`,
-                    ok: injected,
-                    detail: injected ? '已检测到 Forge 命令' : '未检测到 Forge 命令，可能被移除或未初始化',
-                });
-            }
-        }
-        catch (e) {
-            items.push({
-                id: 'claude_settings_parse',
-                label: 'settings.json 解析',
-                ok: false,
-                detail: e instanceof Error ? e.message : String(e),
-            });
-            for (const hookType of forgeTypes) {
-                items.push({
-                    id: `settings_hook_${hookType}`,
-                    label: `settings 中 ${hookType} 注入`,
-                    ok: false,
-                    detail: 'JSON 解析失败，无法检测',
-                });
-            }
-        }
-    }
-    const daemonUp = isRunning();
-    items.push({
-        id: 'daemon_process',
-        label: 'Daemon 进程',
-        ok: daemonUp,
-        detail: daemonUp ? '运行中' : '未运行；若修复后仍无事件，请执行 cf daemon start 或重启',
-    });
-    const hooksRelevant = items.filter((i) => i.id === 'forge_home' ||
-        i.id.startsWith('hook_script_') ||
-        i.id.startsWith('settings_hook_') ||
-        i.id === 'claude_settings' ||
-        i.id === 'claude_settings_parse');
-    const hooksHealthy = hooksRelevant.every((i) => i.ok);
-    return { items, hooksHealthy };
-}
-/** 重装 Hook 脚本并重新注入 settings.json（不改动项目配置与 API Key） */
-export function repairForgeHookEnvironment() {
-    if (!fs.existsSync(FORGE_HOME)) {
-        fs.mkdirSync(FORGE_HOME, { recursive: true });
-    }
-    copyHookScripts();
-    const backupPath = backupSettings();
-    injectHooks();
-    return { backupPath };
-}
-function removeHooks() {
-    if (!fs.existsSync(SETTINGS_PATH)) {
-        return;
-    }
-    const content = fs.readFileSync(SETTINGS_PATH, 'utf-8');
-    const settings = JSON.parse(content);
-    if (!settings.hooks)
-        return;
-    for (const hookType of Object.keys(settings.hooks)) {
-        const entries = settings.hooks[hookType];
-        if (entries) {
-            const kept = entries.filter((item) => !entryRefersToForge(parseHookEntry(item)));
-            if (kept.length === 0) {
-                delete settings.hooks[hookType];
-            }
-            else {
-                settings.hooks[hookType] = kept;
-            }
-        }
-    }
-    // 如果 hooks 为空，删除整个键
-    if (Object.keys(settings.hooks).length === 0) {
-        delete settings.hooks;
-    }
-    fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf-8');
-}
-export function registerInitCommand(program) {
-    program
-        .command('init')
-        .description('Initialize Claude Forge in the current environment')
-        .action(async () => {
-        info('Initializing Claude Forge...');
-        // 1. 创建 .claude-forge 目录（全局数据目录）
-        if (!fs.existsSync(FORGE_HOME)) {
-            fs.mkdirSync(FORGE_HOME, { recursive: true });
-        }
-        // 1b. 在当前项目目录创建 .claude-forge/ 标记（让 daemon 识别为受管理项目）
-        const projectForgeDir = path.join(process.cwd(), '.claude-forge');
-        if (!fs.existsSync(projectForgeDir)) {
-            fs.mkdirSync(projectForgeDir, { recursive: true });
-            info(`Created project marker: .claude-forge/`);
-        }
-        // 2. 创建默认配置 + 自动检测最佳模型
-        const configPath = path.join(FORGE_HOME, 'config.yaml');
-        const manager = new ConfigManager(configPath);
-        if (!fs.existsSync(configPath)) {
-            manager.save({});
-            info('Created default configuration');
-        }
-        // 自动检测代理支持的最佳模型
-        try {
-            const bestModel = await detectBestModel();
-            if (bestModel) {
-                const current = manager.get();
-                manager.save({ distill: { ...current.distill, model: bestModel } });
-                info(`Auto-detected model: ${bestModel}`);
-            }
-        }
-        catch {
-            warning('Could not auto-detect model, using default');
-        }
-        // 3. 复制 Hook 脚本
-        copyHookScripts();
-        info('Hook scripts installed');
-        // 4. 备份 settings.json
-        const backupPath = backupSettings();
-        if (backupPath) {
-            info(`Settings backed up to ${path.basename(backupPath)}`);
-        }
-        // 5. 注入 Hooks
-        injectHooks();
-        info('Hooks injected into Claude Code settings');
-        // 5b. 同步官方 Convention（BMad、Harness Engineering）
-        try {
-            const { OfficialConventionSync } = await import('../../convention/official-sync.js');
-            const syncReport = new OfficialConventionSync().sync();
-            if (syncReport.added.length > 0) {
-                info(`官方规范已安装：${syncReport.added.join(', ')}`);
-            }
-            if (syncReport.updated.length > 0) {
-                info(`官方规范已更新：${syncReport.updated.join(', ')}`);
-            }
-        }
-        catch (err) {
-            warning(`官方规范同步失败：${err instanceof Error ? err.message : String(err)}`);
-        }
-        // 6. API Key 检测与引导
-        let apiKeyConfigured = !!process.env.ANTHROPIC_API_KEY || !!manager.get().distill.api_key;
-        if (!apiKeyConfigured) {
-            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-            const apiKey = await new Promise((resolve) => {
-                rl.question('  ANTHROPIC_API_KEY 未设置，请输入（直接回车跳过）: ', (val) => {
-                    rl.close();
-                    resolve(val.trim());
-                });
-            });
-            if (apiKey) {
-                const current = manager.get();
-                manager.save({ distill: { ...current.distill, api_key: apiKey } });
-                info('API Key 已保存至 ~/.claude-forge/config.yaml');
-                apiKeyConfigured = true;
-            }
-            else {
-                warning('跳过 API Key 配置，AI 功能将不可用，稍后可运行 `cf config set distill.api_key <key>` 补充');
-            }
-        }
-        // 7. 自动启动 daemon（后台）
-        let daemonStarted = false;
-        if (!isRunning()) {
-            try {
-                const daemonScript = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../daemon/index.js');
-                const child = spawn('node', ['-e', `import('${daemonScript}').then(m => m.startDaemon(false))`], { detached: true, stdio: 'ignore', env: process.env });
-                child.unref();
-                daemonStarted = true;
-                info('Daemon 已在后台启动');
-            }
-            catch {
-                warning('Daemon 启动失败，请手动运行 `cf daemon start`');
-            }
-        }
-        else {
-            daemonStarted = true;
-            info('Daemon 已在运行中');
-        }
-        // 8. 完成提示
-        process.stdout.write('\n');
-        success('Claude Forge 初始化完成！');
-        process.stdout.write('\n');
-        process.stdout.write('  已完成：\n');
-        process.stdout.write('    ✓ Hook 脚本安装至 ~/.claude-forge/hooks/\n');
-        process.stdout.write('    ✓ Claude Code hooks 已注入 settings.json\n');
-        if (apiKeyConfigured)
-            process.stdout.write('    ✓ ANTHROPIC_API_KEY 已配置\n');
-        if (daemonStarted)
-            process.stdout.write('    ✓ Daemon 已在后台运行\n');
-        process.stdout.write('\n');
-        process.stdout.write('  开始使用：\n');
-        process.stdout.write('    在 Claude Code 对话中直接说需求，forge 会自动工作\n');
-        process.stdout.write('    cf              — 打开交互式控制台\n');
-        process.stdout.write('    cf pattern list — 查看可用工作流\n');
-        process.stdout.write('    cf logs         — 查看运行日志\n');
-        process.stdout.write('\n');
-    });
-    program
-        .command('uninit')
-        .description('Remove Claude Forge hooks and configuration')
-        .action(async () => {
-        info('Removing Claude Forge hooks...');
-        // 1. 备份 settings.json
-        const backupPath = backupSettings();
-        if (backupPath) {
-            info(`Settings backed up to ${path.basename(backupPath)}`);
-        }
-        // 2. 移除 Hooks
-        removeHooks();
-        info('Hooks removed from Claude Code settings');
-        success('Claude Forge hooks removed (data preserved in ~/.claude-forge/)');
-    });
-}
-export function registerDoctorCommand(program) {
-    program
-        .command('doctor')
-        .description('检测 Claude Code Hooks 与 Forge 脚本是否完整，可选一键修复')
-        .option('-f, --fix', '重装 ~/.claude-forge/hooks 脚本并重新注入 ~/.claude/settings.json')
-        .action(async (opts) => {
-        const globalOpts = program.opts();
-        const { hooksHealthy, items } = diagnoseForgeHookEnvironment();
-        if (opts.fix) {
-            const { backupPath } = repairForgeHookEnvironment();
-            const after = diagnoseForgeHookEnvironment();
-            if (globalOpts.json) {
-                console.log(JSON.stringify({
-                    repaired: true,
-                    backupPath,
-                    beforeHooksHealthy: hooksHealthy,
-                    hooksHealthy: after.hooksHealthy,
-                    items: after.items,
-                }, null, 2));
-            }
-            else if (!globalOpts.quiet) {
-                heading('【Forge:环境修复】');
-                if (backupPath) {
-                    info(`已备份 settings: ${path.basename(backupPath)}`);
-                }
-                info('已重装 Hook 脚本并完成 settings 注入。');
-                heading('【Forge:环境诊断】（修复后）');
-                for (const it of after.items) {
-                    if (it.ok) {
-                        success(`${it.label} — ${it.detail}`);
-                    }
-                    else if (it.id === 'daemon_process') {
-                        warning(`${it.label} — ${it.detail}`);
-                    }
-                    else {
-                        error(`${it.label} — ${it.detail}`);
-                    }
-                }
-                if (after.hooksHealthy) {
-                    success('Hooks 相关环境已恢复正常。');
-                }
-                else {
-                    warning('修复后仍有未通过项，请根据上述列表排查。');
-                    process.exitCode = 1;
-                }
-            }
-            else if (!after.hooksHealthy) {
-                process.exitCode = 1;
-            }
-            return;
-        }
-        if (globalOpts.json) {
-            console.log(JSON.stringify({ hooksHealthy, items }, null, 2));
-            if (!hooksHealthy) {
-                process.exitCode = 1;
-            }
-            return;
-        }
-        if (!globalOpts.quiet) {
-            heading('【Forge:环境诊断】');
-            for (const it of items) {
-                if (it.ok) {
-                    success(`${it.label} — ${it.detail}`);
-                }
-                else if (it.id === 'daemon_process') {
-                    warning(`${it.label} — ${it.detail}`);
-                }
-                else {
-                    error(`${it.label} — ${it.detail}`);
-                }
-            }
-        }
-        if (hooksHealthy) {
-            if (!globalOpts.quiet) {
-                success('Hooks 相关环境正常。');
-                const daemonItem = items.find((i) => i.id === 'daemon_process');
-                if (daemonItem && !daemonItem.ok) {
-                    info('提示：Daemon 未运行；若 Claude Code 中无编排事件，可执行 cf daemon start。');
-                }
-            }
-            return;
-        }
-        if (!globalOpts.quiet) {
-            warning('检测到 Hooks 环境不完整，请执行: cf doctor --fix（或在 TUI「初始化/卸载」中选择一键修复）。');
-        }
-        process.exitCode = 1;
-    });
-}
-// ── 项目级环境诊断与修复 ────────────────────────────────────────────────────
-/**
- * 检测项目级 .claude-forge/ 目录下关键文件的完整性。
- */
-export function diagnoseProjectEnvironment(projectPath) {
-    const forgeDir = path.join(projectPath, '.claude-forge');
-    const items = [];
-    // 1. 项目标记目录
-    const forgeDirExists = fs.existsSync(forgeDir);
-    items.push({
-        id: 'project_forge_dir',
-        label: '项目 .claude-forge/ 目录',
-        ok: forgeDirExists,
-        detail: forgeDirExists ? forgeDir : '缺失 — 项目未被 Forge 管理，请执行 cf init',
-    });
-    if (!forgeDirExists) {
-        return { items, healthy: false };
-    }
-    // 2. 规范绑定文件
-    const bindingsPath = path.join(forgeDir, 'project-conventions.json');
-    const bindingsExists = fs.existsSync(bindingsPath);
-    let bindings = [];
-    let bindingsValid = false;
-    if (bindingsExists) {
-        try {
-            bindings = JSON.parse(fs.readFileSync(bindingsPath, 'utf-8'));
-            bindingsValid = Array.isArray(bindings);
-        }
-        catch {
-            bindingsValid = false;
-        }
-    }
-    items.push({
-        id: 'project_conventions_json',
-        label: '规范绑定 (project-conventions.json)',
-        ok: bindingsExists && bindingsValid,
-        detail: !bindingsExists
-            ? '缺失 — 规范绑定丢失，需重新绑定'
-            : bindingsValid
-                ? `${bindings.length} 个规范已绑定`
-                : '文件损坏，JSON 解析失败',
-    });
-    // 3. 自定义蒸馏规范
-    const customConvPath = path.join(forgeDir, 'custom-convention.yaml');
-    const hasCustomConv = fs.existsSync(customConvPath);
-    const hasCustomBinding = bindings.some(b => b.convention_id?.startsWith('custom-'));
-    items.push({
-        id: 'project_custom_convention',
-        label: '蒸馏规范 (custom-convention.yaml)',
-        ok: hasCustomConv || !hasCustomBinding,
-        detail: hasCustomConv
-            ? '存在'
-            : hasCustomBinding
-                ? '缺失 — 绑定记录指向自定义规范但文件不存在，需重新 distill'
-                : '未创建（无自定义规范绑定，正常）',
-    });
-    // 4. CLAUDE.md 中 convention 标记一致性
-    const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
-    if (fs.existsSync(claudeMdPath) && bindings.length > 0) {
-        const claudeMd = fs.readFileSync(claudeMdPath, 'utf-8');
-        for (const b of bindings) {
-            const id = b.convention_id;
-            const startTag = `<!-- forge:convention-start:${id} -->`;
-            const hasMarker = claudeMd.includes(startTag);
-            items.push({
-                id: `convention_marker_${id}`,
-                label: `CLAUDE.md 规范标记: ${id}`,
-                ok: hasMarker,
-                detail: hasMarker ? '已注入' : '缺失 — 绑定存在但 CLAUDE.md 中无对应标记',
-            });
-        }
-    }
-    // 5. 蒸馏产物
-    const decisionsPath = path.join(forgeDir, 'decisions.md');
-    items.push({
-        id: 'project_decisions',
-        label: '蒸馏决策日志 (decisions.md)',
-        ok: fs.existsSync(decisionsPath),
-        detail: fs.existsSync(decisionsPath) ? '存在' : '缺失（运行时生成，首次蒸馏后自动创建）',
-    });
-    const timelinePath = path.join(forgeDir, 'timeline.md');
-    items.push({
-        id: 'project_timeline',
-        label: '蒸馏时间线 (timeline.md)',
-        ok: fs.existsSync(timelinePath),
-        detail: fs.existsSync(timelinePath) ? '存在' : '缺失（运行时生成，首次蒸馏后自动创建）',
-    });
-    // 6. Persona
-    const personaPath = path.join(forgeDir, 'persona.md');
-    items.push({
-        id: 'project_persona',
-        label: '项目人设 (persona.md)',
-        ok: fs.existsSync(personaPath),
-        detail: fs.existsSync(personaPath) ? '存在' : '缺失（运行时生成，首次 refine 后自动创建）',
-    });
-    // 7. Refine 状态
-    const refineStatePath = path.join(forgeDir, 'refine-state.json');
-    items.push({
-        id: 'project_refine_state',
-        label: 'Refine 状态 (refine-state.json)',
-        ok: fs.existsSync(refineStatePath),
-        detail: fs.existsSync(refineStatePath) ? '存在' : '缺失（运行时生成，首次 refine 后自动创建）',
-    });
-    // 健康标准：核心文件必须存在（蒸馏产物和 persona 是运行时生成的，不作为必须项）
-    const criticalIds = ['project_forge_dir', 'project_conventions_json', 'project_custom_convention'];
-    const markerIds = items.filter(i => i.id.startsWith('convention_marker_')).map(i => i.id);
-    const healthCheckIds = [...criticalIds, ...markerIds];
-    const healthy = healthCheckIds.every(id => items.find(i => i.id === id)?.ok ?? true);
-    return { items, healthy };
-}
-/**
- * 修复项目级环境：重建丢失的绑定文件和 CLAUDE.md 标记。
- */
-export async function repairProjectEnvironment(projectPath) {
-    const forgeDir = path.join(projectPath, '.claude-forge');
-    const repaired = [];
-    // 1. 确保 .claude-forge/ 存在
-    if (!fs.existsSync(forgeDir)) {
-        fs.mkdirSync(forgeDir, { recursive: true });
-        repaired.push('创建 .claude-forge/ 目录');
-    }
-    // 2. 规范绑定修复
-    const bindingsPath = path.join(forgeDir, 'project-conventions.json');
-    const claudeMdPath = path.join(projectPath, 'CLAUDE.md');
-    let bindings = [];
-    if (fs.existsSync(bindingsPath)) {
-        try {
-            bindings = JSON.parse(fs.readFileSync(bindingsPath, 'utf-8'));
-        }
-        catch {
-            bindings = [];
-        }
-    }
-    // 2a. CLAUDE.md 有 convention 标记但绑定文件缺失 → 从标记反向重建
-    if (fs.existsSync(claudeMdPath)) {
-        const claudeMd = fs.readFileSync(claudeMdPath, 'utf-8');
-        const markerRegex = /<!-- forge:convention-start:([^ ]+) -->/g;
-        let match;
-        const markeredIds = new Set();
-        while ((match = markerRegex.exec(claudeMd)) !== null) {
-            markeredIds.add(match[1]);
-        }
-        // 找出标记存在但绑定缺失的 convention
-        for (const id of markeredIds) {
-            if (!bindings.some(b => b.convention_id === id)) {
-                bindings.push({
-                    convention_id: id,
-                    bound_at: new Date().toISOString(),
-                    project_path: projectPath,
-                });
-                repaired.push(`从 CLAUDE.md 标记恢复绑定: ${id}`);
-            }
-        }
-        if (repaired.some(r => r.includes('恢复绑定'))) {
-            fs.writeFileSync(bindingsPath, JSON.stringify(bindings, null, 2), 'utf-8');
-        }
-    }
-    // 2b. 绑定存在但 CLAUDE.md 标记缺失 → 重新注入
-    if (bindings.length > 0 && fs.existsSync(claudeMdPath)) {
-        const { ConventionManager } = await import('../../convention/convention-manager.js');
-        const manager = new ConventionManager();
-        const claudeMd = fs.readFileSync(claudeMdPath, 'utf-8');
-        for (const b of bindings) {
-            const startTag = `<!-- forge:convention-start:${b.convention_id} -->`;
-            if (!claudeMd.includes(startTag)) {
-                // 尝试加载 convention 并注入
-                try {
-                    const conventions = manager.getActiveConventions(projectPath);
-                    const conv = conventions.find(c => c.id === b.convention_id);
-                    if (conv) {
-                        manager.injectIntoClaudeMd(projectPath, conv);
-                        repaired.push(`重新注入 CLAUDE.md 规范标记: ${b.convention_id}`);
-                    }
-                }
-                catch {
-                    // convention 文件可能也不存在，跳过
-                }
-            }
-        }
-    }
-    // 2c. custom-convention.yaml 缺失但有 custom- 绑定 → 尝试重新 distill
-    const hasCustomBinding = bindings.some(b => b.convention_id?.startsWith('custom-'));
-    const customConvPath = path.join(forgeDir, 'custom-convention.yaml');
-    if (hasCustomBinding && !fs.existsSync(customConvPath)) {
-        try {
-            const { ConventionDistiller } = await import('../../convention/convention-distiller.js');
-            const { ConventionLoader } = await import('../../convention/convention-loader.js');
-            const { ConfigManager } = await import('../../config/index.js');
-            const { ClaudeAPI } = await import('../../utils/claude-api.js');
-            const config = new ConfigManager().get();
-            const apiKey = config.distill.api_key || undefined;
-            const api = new ClaudeAPI(apiKey, config.distill.model, config.distill.base_url || undefined);
-            const loader = new ConventionLoader();
-            const distiller = new ConventionDistiller(api, loader);
-            const sourceConventions = loader.loadAll();
-            if (sourceConventions.length > 0) {
-                await distiller.distill(projectPath, sourceConventions);
-                repaired.push('重新蒸馏生成 custom-convention.yaml');
-            }
-            else {
-                repaired.push('custom-convention.yaml 重建跳过：无已安装的源规范');
-            }
-        }
-        catch (err) {
-            repaired.push(`custom-convention.yaml 重建失败: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return repaired;
-}
-export function registerProjectDoctorCommand(program) {
-    program
-        .command('project-doctor')
-        .description('检测当前项目的 Forge 环境是否完整（规范绑定、蒸馏产物等），可选修复')
-        .option('-p, --project <path>', '项目路径', process.cwd())
-        .option('-f, --fix', '自动修复可恢复的问题')
-        .action(async (opts) => {
-        const globalOpts = program.opts();
-        const projectPath = path.resolve(opts.project);
-        const { healthy, items } = diagnoseProjectEnvironment(projectPath);
-        if (opts.fix) {
-            const repaired = await repairProjectEnvironment(projectPath);
-            const after = diagnoseProjectEnvironment(projectPath);
-            if (globalOpts.json) {
-                console.log(JSON.stringify({ repaired, beforeHealthy: healthy, healthy: after.healthy, items: after.items }, null, 2));
-            }
-            else if (!globalOpts.quiet) {
-                heading('【Forge:项目环境修复】');
-                if (repaired.length > 0) {
-                    for (const r of repaired)
-                        success(`✓ ${r}`);
-                }
-                else {
-                    info('无需修复。');
-                }
-                heading('【Forge:项目环境诊断】（修复后）');
-                for (const it of after.items) {
-                    if (it.ok) {
-                        success(`${it.label} — ${it.detail}`);
-                    }
-                    else if (it.id.startsWith('project_decisions') || it.id.startsWith('project_timeline') || it.id === 'project_persona' || it.id === 'project_refine_state') {
-                        info(`${it.label} — ${it.detail}`);
-                    }
-                    else {
-                        error(`${it.label} — ${it.detail}`);
-                    }
-                }
-                if (after.healthy) {
-                    success('项目环境正常。');
-                }
-                else {
-                    warning('修复后仍有未通过项，请根据上述列表排查。');
-                    process.exitCode = 1;
-                }
-            }
-            else if (!after.healthy) {
-                process.exitCode = 1;
-            }
-            return;
-        }
-        if (globalOpts.json) {
-            console.log(JSON.stringify({ healthy, items }, null, 2));
-            if (!healthy)
-                process.exitCode = 1;
-            return;
-        }
-        if (!globalOpts.quiet) {
-            heading(`【Forge:项目环境诊断】${projectPath}`);
-            for (const it of items) {
-                if (it.ok) {
-                    success(`${it.label} — ${it.detail}`);
-                }
-                else if (it.id.startsWith('project_decisions') || it.id.startsWith('project_timeline') || it.id === 'project_persona' || it.id === 'project_refine_state') {
-                    info(`${it.label} — ${it.detail}`);
-                }
-                else {
-                    error(`${it.label} — ${it.detail}`);
-                }
-            }
-            if (healthy) {
-                success('项目环境正常。');
-            }
-            else {
-                warning('检测到项目环境不完整，请执行: cf project-doctor --fix');
-                process.exitCode = 1;
-            }
-        }
-        else if (!healthy) {
-            process.exitCode = 1;
-        }
-    });
-}
-//# sourceMappingURL=init.js.map