@winspan/claude-forge 8.41.0 → 8.50.6

package/src/cli/commands/menu.ts

@@ -0,0 +1,356 @@
+import readline from 'readline';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+import type { Command } from 'commander';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../../../package.json') as { version: string };
+
+export function registerMenuCommand(program: Command): void {
+  program
+    .command('menu')
+    .description('Interactive menu for common operations')
+    .action(async () => {
+      await showMainMenu();
+    });
+}
+
+async function showMainMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m╔════════════════════════════════════════╗\x1b[0m');
+  console.log(`\x1b[36m║  Claude Forge v${version.padEnd(24)}║\x1b[0m`);
+  console.log('\x1b[36m╚════════════════════════════════════════╝\x1b[0m\n');
+
+  console.log('  \x1b[33m[1]\x1b[0m 🚀 运行与状态');
+  console.log('  \x1b[33m[2]\x1b[0m 📊 会话与日志');
+  console.log('  \x1b[33m[3]\x1b[0m ⚙️  项目治理');
+  console.log('  \x1b[33m[4]\x1b[0m 🤖 AI 配置');
+  console.log('  \x1b[33m[5]\x1b[0m 📡 MCP Server');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 退出\n');
+
+  const choice = await prompt('请选择');
+
+  switch (choice) {
+    case '1': await showRuntimeMenu(); break;
+    case '2': await showSessionMenu(); break;
+    case '3': await showGovernanceMenu(); break;
+    case '4': await showAIConfigMenu(); break;
+    case '5': await showMcpMenu(); break;
+    case '0': process.exit(0);
+    default:
+      console.log('\x1b[31m无效选择\x1b[0m');
+      await waitForKey();
+  }
+  await showMainMenu();
+}
+
+async function showRuntimeMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m═══ 🚀 运行与状态 ═══\x1b[0m\n');
+  console.log('  \x1b[33m[1]\x1b[0m 启动 daemon');
+  console.log('  \x1b[33m[2]\x1b[0m 停止 daemon');
+  console.log('  \x1b[33m[3]\x1b[0m 查看状态');
+  console.log('  \x1b[33m[4]\x1b[0m 打开 Web Dashboard');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 返回\n');
+
+  const choice = await prompt('请选择');
+  switch (choice) {
+    case '1': await runCommand('daemon', ['start']); await waitForKey(); break;
+    case '2': await runCommand('daemon', ['stop']); await waitForKey(); break;
+    case '3': await runCommand('status', []); await waitForKey(); break;
+    case '4': openDashboard(); await waitForKey(); break;
+    case '0': return;
+    default: console.log('\x1b[31m无效选择\x1b[0m'); await waitForKey();
+  }
+  await showRuntimeMenu();
+}
+
+async function showSessionMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m═══ 📊 会话与日志 ═══\x1b[0m\n');
+  console.log('  \x1b[33m[1]\x1b[0m 最近会话（按会话分组）');
+  console.log('  \x1b[33m[2]\x1b[0m 最近事件（平铺）');
+  console.log('  \x1b[33m[3]\x1b[0m 查看注入历史');
+  console.log('  \x1b[33m[4]\x1b[0m 实时跟踪（follow）');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 返回\n');
+
+  const choice = await prompt('请选择');
+  switch (choice) {
+    case '1': await runCommand('logs', ['-n', '20']); await waitForKey(); break;
+    case '2': await runCommand('logs', ['--flat', '-n', '50']); await waitForKey(); break;
+    case '3': await runCommand('logs', ['--injections', '-n', '10']); await waitForKey(); break;
+    case '4': await runCommand('logs', ['--follow']); break;
+    case '0': return;
+    default: console.log('\x1b[31m无效选择\x1b[0m'); await waitForKey();
+  }
+  await showSessionMenu();
+}
+
+async function showGovernanceMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m═══ ⚙️  项目治理 ═══\x1b[0m\n');
+  console.log('  \x1b[33m[1]\x1b[0m 管理 CLAUDE.md');
+  console.log('  \x1b[33m[2]\x1b[0m 查看技能列表');
+  console.log('  \x1b[33m[3]\x1b[0m 查看配置');
+  console.log('  \x1b[33m[4]\x1b[0m 初始化项目');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 返回\n');
+
+  const choice = await prompt('请选择');
+  switch (choice) {
+    case '1': await runCommand('claudemd', ['--help']); await waitForKey(); break;
+    case '2': await runCommand('skills', ['list']); await waitForKey(); break;
+    case '3': await runCommand('config', ['show']); await waitForKey(); break;
+    case '4': await runCommand('init', []); await waitForKey(); break;
+    case '0': return;
+    default: console.log('\x1b[31m无效选择\x1b[0m'); await waitForKey();
+  }
+  await showGovernanceMenu();
+}
+
+function runCommand(cmd: string, args: string[]): Promise<void> {
+  return new Promise((resolve) => {
+    console.log(`\n\x1b[90m$ cf ${cmd} ${args.join(' ')}\x1b[0m\n`);
+    const child = spawn('node', [process.argv[1], cmd, ...args], {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+    });
+    child.on('close', () => resolve());
+  });
+}
+
+function openDashboard(): void {
+  console.log('\x1b[32m正在打开 Web Dashboard...\x1b[0m');
+  console.log('访问: \x1b[36mhttp://localhost:3721\x1b[0m\n');
+  const open = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  spawn(open, ['http://localhost:3721'], { detached: true, stdio: 'ignore' }).unref();
+}
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(`\x1b[32m${question}: \x1b[0m`, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function waitForKey(): Promise<void> {
+  return new Promise((resolve) => {
+    console.log('\n\x1b[90m按任意键继续...\x1b[0m');
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.once('data', () => {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+      resolve();
+    });
+  });
+}
+
+async function showAIConfigMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m═══ 🤖 AI 配置 ═══\x1b[0m\n');
+  console.log('  \x1b[33m[1]\x1b[0m 查看当前配置');
+  console.log('  \x1b[33m[2]\x1b[0m 设置 API Key');
+  console.log('  \x1b[33m[3]\x1b[0m 设置 Base URL');
+  console.log('  \x1b[33m[4]\x1b[0m 选择模型');
+  console.log('  \x1b[33m[5]\x1b[0m 测试连接');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 返回\n');
+
+  const choice = await prompt('请选择');
+  switch (choice) {
+    case '1': await showCurrentAIConfig(); await waitForKey(); break;
+    case '2': await setAPIKey(); await waitForKey(); break;
+    case '3': await setBaseURL(); await waitForKey(); break;
+    case '4': await selectModel(); await waitForKey(); break;
+    case '5': await testConnection(); await waitForKey(); break;
+    case '0': return;
+    default: console.log('\x1b[31m无效选择\x1b[0m'); await waitForKey();
+  }
+  await showAIConfigMenu();
+}
+
+async function showCurrentAIConfig(): Promise<void> {
+  try {
+    const { ConfigManager } = await import('../../core/config.js');
+    const { FORGE_PATHS } = await import('../../core/constants.js');
+    const configManager = new ConfigManager();
+    const config = configManager.get();
+
+    const maskApiKey = (key: string): string => {
+      if (!key || key.length < 10) return '(未设置)';
+      return key.slice(0, 6) + '***' + key.slice(-4);
+    };
+
+    console.log('\n\x1b[36m当前 AI 配置：\x1b[0m');
+    console.log(`  API Key:   ${maskApiKey(config.ai.api_key)}`);
+    console.log(`  Base URL:  ${config.ai.base_url || '(未设置)'}`);
+    console.log(`  Model:     ${config.ai.model}`);
+    console.log(`  Provider:  ${config.ai.provider}`);
+    console.log(`\n配置文件: ${FORGE_PATHS.config()}`);
+  } catch (err) {
+    console.log(`\x1b[31m读取配置失败: ${err}\x1b[0m`);
+  }
+}
+
+async function setAPIKey(): Promise<void> {
+  try {
+    const apiKey = await prompt('请输入 API Key');
+    if (!apiKey) {
+      console.log('\x1b[31mAPI Key 不能为空\x1b[0m');
+      return;
+    }
+
+    const { ConfigManager } = await import('../../core/config.js');
+    const configManager = new ConfigManager();
+    const config = configManager.get();
+    config.ai.api_key = apiKey;
+    configManager.save();
+
+    console.log('\x1b[32m✓ API Key 已保存\x1b[0m');
+    console.log('\x1b[90m提示: 重启 daemon 后生效\x1b[0m');
+  } catch (err) {
+    console.log(`\x1b[31m保存失败: ${err}\x1b[0m`);
+  }
+}
+
+async function setBaseURL(): Promise<void> {
+  try {
+    const baseUrl = await prompt('请输入 Base URL (留空使用默认)');
+
+    const { ConfigManager } = await import('../../core/config.js');
+    const configManager = new ConfigManager();
+    const config = configManager.get();
+    config.ai.base_url = baseUrl || undefined;
+    configManager.save();
+
+    console.log('\x1b[32m✓ Base URL 已保存\x1b[0m');
+    console.log('\x1b[90m提示: 重启 daemon 后生效\x1b[0m');
+  } catch (err) {
+    console.log(`\x1b[31m保存失败: ${err}\x1b[0m`);
+  }
+}
+
+async function selectModel(): Promise<void> {
+  try {
+    console.log('\n\x1b[36m正在获取模型列表...\x1b[0m');
+
+    const response = await fetch('http://localhost:3721/api/ai/models');
+    if (!response.ok) {
+      const text = await response.text();
+      console.log(`\x1b[31m获取模型列表失败: ${text}\x1b[0m`);
+      console.log('\x1b[90m提示: 请先配置 API Key 和 Base URL，并确保 daemon 正在运行\x1b[0m');
+      return;
+    }
+
+    const data = await response.json() as { data?: Array<{ id: string }> };
+    const models = data.data || [];
+
+    if (models.length === 0) {
+      console.log('\x1b[31m未找到可用模型\x1b[0m');
+      return;
+    }
+
+    console.log('\n\x1b[36m可用模型：\x1b[0m');
+    models.forEach((m, i) => {
+      console.log(`  \x1b[33m[${i + 1}]\x1b[0m ${m.id}`);
+    });
+    console.log('  \x1b[33m[0]\x1b[0m 取消\n');
+
+    const choice = await prompt('请选择模型');
+    const idx = parseInt(choice) - 1;
+
+    if (choice === '0') return;
+    if (idx < 0 || idx >= models.length) {
+      console.log('\x1b[31m无效选择\x1b[0m');
+      return;
+    }
+
+    const selectedModel = models[idx].id;
+    const { ConfigManager } = await import('../../core/config.js');
+    const configManager = new ConfigManager();
+    const config = configManager.get();
+    config.ai.model = selectedModel;
+    configManager.save();
+
+    console.log(`\x1b[32m✓ 已选择模型: ${selectedModel}\x1b[0m`);
+    console.log('\x1b[90m提示: 重启 daemon 后生效\x1b[0m');
+  } catch (err) {
+    console.log(`\x1b[31m操作失败: ${err}\x1b[0m`);
+  }
+}
+
+async function testConnection(): Promise<void> {
+  try {
+    console.log('\n\x1b[36m正在测试连接...\x1b[0m');
+
+    const { ConfigManager } = await import('../../core/config.js');
+    const configManager = new ConfigManager();
+    const config = configManager.get();
+
+    const apiKey = config.ai.api_key;
+    const baseUrl = config.ai.base_url || 'https://api.anthropic.com';
+    const model = config.ai.model;
+
+    if (!apiKey) {
+      console.log('\x1b[31m请先配置 API Key\x1b[0m');
+      return;
+    }
+
+    const messagesUrl = baseUrl.endsWith('/v1')
+      ? `${baseUrl}/messages`
+      : `${baseUrl}/v1/messages`;
+
+    const response = await fetch(messagesUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 10,
+        messages: [{ role: 'user', content: 'ping' }],
+      }),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      console.log(`\x1b[31m连接失败: ${response.status} ${text}\x1b[0m`);
+      return;
+    }
+
+    const data = await response.json() as { model?: string };
+    console.log(`\x1b[32m✓ 连接成功！\x1b[0m`);
+    console.log(`  模型: ${data.model || model}`);
+  } catch (err) {
+    console.log(`\x1b[31m测试失败: ${err}\x1b[0m`);
+  }
+}
+
+async function showMcpMenu(): Promise<void> {
+  console.clear();
+  console.log('\x1b[36m═══ 📡 MCP Server ═══\x1b[0m\n');
+  console.log('  \x1b[33m[1]\x1b[0m 查看状态');
+  console.log('  \x1b[33m[2]\x1b[0m 注册到 Claude Code');
+  console.log('  \x1b[33m[3]\x1b[0m 取消注册');
+  console.log('');
+  console.log('  \x1b[33m[0]\x1b[0m 返回\n');
+
+  const choice = await prompt('请选择');
+  switch (choice) {
+    case '1': await runCommand('mcp', ['status']); await waitForKey(); break;
+    case '2': await runCommand('mcp', ['register']); await waitForKey(); break;
+    case '3': await runCommand('mcp', ['unregister']); await waitForKey(); break;
+    case '0': return;
+    default: console.log('\x1b[31m无效选择\x1b[0m'); await waitForKey();
+  }
+  await showMcpMenu();
+}

package/src/cli/commands/skills.ts

@@ -0,0 +1,185 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import type { Command } from 'commander';
+import { loadOfficialSkills } from '../../skills/official-skills.js';
+import { SkillRegistry } from '../../skills/registry.js';
+import { skillInvoke } from '../../skills/tools/skill-invoke.js';
+import { skillList } from '../../skills/tools/skill-list.js';
+
+const SKILLS_DIR = path.join(homedir(), '.claude', 'skills');
+
+function resolveBuiltinDir(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  return path.join(path.dirname(thisFile), '../../skills/official');
+}
+
+interface ListOptions {
+  keywords?: string;
+  json?: boolean;
+}
+
+interface InvokeOptions {
+  reason?: string;
+  json?: boolean;
+}
+
+/**
+ * List skills with optional keyword filter and JSON output.
+ * Delegates to the shared skillList() tool so CLI and Agent share one code path.
+ */
+async function listSkills(options: ListOptions): Promise<void> {
+  const registry = new SkillRegistry();
+  const keywords = options.keywords
+    ? options.keywords
+        .split(',')
+        .map(k => k.trim())
+        .filter(k => k.length > 0)
+    : undefined;
+
+  const result = await skillList({ keywords }, { skillRegistry: registry });
+
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (result.total === 0) {
+    console.log('No skills found.');
+    return;
+  }
+
+  // Human-readable output. Include `isOfficial` hint via registry lookup.
+  console.log(`Available skills (${result.total}):\n`);
+  for (const s of result.skills) {
+    const full = registry.get(s.id);
+    const type = full?.isOfficial ? 'official' : 'user';
+    console.log(`- ${s.id} [${type}]`);
+    console.log(`  name: ${s.name}`);
+    if (s.description) {
+      console.log(`  description: ${s.description}`);
+    }
+    if (s.keywords.length > 0) {
+      console.log(`  keywords: ${s.keywords.join(', ')}`);
+    }
+    console.log();
+  }
+}
+
+/**
+ * Invoke a skill by id, printing its full methodology content.
+ * Exit code 1 on failure so Bash callers can detect errors.
+ */
+async function invokeSkill(skillId: string, options: InvokeOptions): Promise<void> {
+  const registry = new SkillRegistry();
+
+  try {
+    const result = await skillInvoke(
+      { skill_id: skillId, reason: options.reason },
+      { skillRegistry: registry },
+    );
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    console.log(`# ${result.skill_name}`);
+    if (result.keywords.length > 0) {
+      console.log(`\n> keywords: ${result.keywords.join(', ')}`);
+    }
+    console.log();
+    console.log(result.content);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+  }
+}
+
+function registerSkillSubcommands(skills: Command): void {
+  skills
+    .command('sync')
+    .description('Write official skills to ~/.claude/skills/')
+    .option('-f, --force', 'Overwrite existing files regardless of version')
+    .action((options: { force?: boolean }) => {
+      syncSkills(options);
+    });
+
+  skills
+    .command('list')
+    .description('List all skills (official + user) with optional keyword filter')
+    .option('--keywords <keywords>', 'Comma-separated keywords to filter by')
+    .option('--json', 'Output as JSON (machine-readable)')
+    .action(async (options: ListOptions) => {
+      await listSkills(options);
+    });
+
+  skills
+    .command('invoke <skill_id>')
+    .description('Invoke a skill and print its full methodology content')
+    .option('--reason <reason>', 'Reason for invoking (used for audit log)')
+    .option('--json', 'Output as JSON (machine-readable)')
+    .action(async (skillId: string, options: InvokeOptions) => {
+      await invokeSkill(skillId, options);
+    });
+}
+
+export function register(program: Command): void {
+  // Primary command: `cf skills ...`
+  const skills = program
+    .command('skills')
+    .description('Manage official and user skills (list | invoke | sync)');
+  registerSkillSubcommands(skills);
+
+  // Singular alias: `cf skill ...` — preferred for Agent Bash calls where
+  // `cf skill invoke <id>` reads more naturally than the plural form.
+  const skill = program
+    .command('skill')
+    .description('Alias of `skills` (list | invoke | sync)');
+  registerSkillSubcommands(skill);
+}
+function syncSkills(options: { force?: boolean }): void {
+  if (!fs.existsSync(SKILLS_DIR)) {
+    fs.mkdirSync(SKILLS_DIR, { recursive: true });
+  }
+
+  let added = 0;
+  let skipped = 0;
+  let updated = 0;
+
+  const officialSkills = loadOfficialSkills(resolveBuiltinDir());
+
+  for (const skill of officialSkills) {
+    const filePath = path.join(SKILLS_DIR, `${skill.name}.md`);
+    const exists = fs.existsSync(filePath);
+
+    if (exists && !options.force) {
+      // Check version to decide if update is needed
+      const existing = fs.readFileSync(filePath, 'utf-8');
+      const versionMatch = existing.match(/^version:\s*(.+)$/m);
+      const existingVersion = versionMatch ? versionMatch[1].trim() : '0.0.0';
+
+      if (existingVersion === skill.version) {
+        skipped++;
+        continue;
+      }
+
+      // Version mismatch - update
+      fs.writeFileSync(filePath, skill.content, 'utf-8');
+      updated++;
+      console.log(`  updated: ${skill.name} (${existingVersion} -> ${skill.version})`);
+    } else if (exists && options.force) {
+      fs.writeFileSync(filePath, skill.content, 'utf-8');
+      updated++;
+      console.log(`  updated: ${skill.name} (forced)`);
+    } else {
+      fs.writeFileSync(filePath, skill.content, 'utf-8');
+      added++;
+      console.log(`  added: ${skill.name}`);
+    }
+  }
+
+  console.log(`\nSync complete: ${added} added, ${updated} updated, ${skipped} skipped`);
+}

package/src/cli/commands/stats.ts

@@ -0,0 +1,74 @@
+/**
+ * CLI Command: cf stats
+ *
+ * 查询统计信息
+ */
+
+import { Command } from 'commander';
+import { SQLiteStorage } from '../../core/storage/sqlite.js';
+import chalk from 'chalk';
+import path from 'node:path';
+import { homedir } from 'node:os';
+
+export function createStatsCommand(): Command {
+  const cmd = new Command('stats');
+  cmd.description('查询统计信息');
+
+  cmd
+    .option('-d, --days <days>', '统计天数', '7')
+    .option('-p, --project <path>', '项目路径')
+    .action((options: { days: string; project?: string }) => {
+      const dbPath = path.join(homedir(), '.claude-forge', 'data.db');
+      const storage = new SQLiteStorage(dbPath);
+
+      const days = parseInt(options.days);
+      const now = Date.now();
+      const startTime = now - days * 24 * 60 * 60 * 1000;
+
+      // 查询统计数据
+      const sessions = storage.querySessions({ limit: 1000 });
+      const events = storage.queryEvents({ limit: 10000 });
+
+      // 过滤时间范围
+      const recentSessions = sessions.filter(s => {
+        const time = new Date(s.start_time).getTime();
+        return time >= startTime;
+      });
+
+      const recentEvents = events.filter(e => {
+        const time = new Date(e.timestamp).getTime();
+        return time >= startTime;
+      });
+
+      // 工具使用统计
+      const toolUsage: Record<string, number> = {};
+      recentEvents.forEach(e => {
+        if (e.tool_name) {
+          toolUsage[e.tool_name] = (toolUsage[e.tool_name] || 0) + 1;
+        }
+      });
+
+      // 输出统计信息
+      console.log(chalk.bold(`\n📊 Statistics (Last ${days} days)\n`));
+
+      console.log(chalk.cyan('Sessions:'));
+      console.log(`  Total: ${recentSessions.length}`);
+      console.log(`  Avg events per session: ${Math.round(recentEvents.length / recentSessions.length || 0)}`);
+      console.log();
+
+      console.log(chalk.cyan('Events:'));
+      console.log(`  Total: ${recentEvents.length}`);
+      console.log();
+
+      console.log(chalk.cyan('Tool Usage:'));
+      Object.entries(toolUsage)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .forEach(([tool, count]) => {
+          console.log(`  ${tool}: ${count}`);
+        });
+      console.log();
+    });
+
+  return cmd;
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import type { Command } from 'commander';
+import { FORGE_HOME, FORGE_PATHS } from '../../core/constants.js';
+import { ConfigManager } from '../../core/config.js';
+
+const PID_FILE = path.join(FORGE_HOME, 'daemon.pid');
+
+function readPid(): number | null {
+  if (!fs.existsSync(PID_FILE)) return null;
+  const content = fs.readFileSync(PID_FILE, 'utf-8').trim();
+  const pid = parseInt(content, 10);
+  return isNaN(pid) ? null : pid;
+}
+
+function isRunning(): boolean {
+  const pid = readPid();
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveDbPath(): string {
+  try {
+    const cfg = new ConfigManager().get();
+    const raw = cfg.storage?.path ?? FORGE_PATHS.database();
+    return raw.startsWith('~') ? path.join(homedir(), raw.slice(1)) : raw;
+  } catch {
+    return FORGE_PATHS.database();
+  }
+}
+
+export function register(program: Command): void {
+  program
+    .command('status')
+    .description('Show Forge daemon status')
+    .action(async () => {
+      // Daemon status
+      const pid = readPid();
+      if (pid && isRunning()) {
+        console.log(`Daemon: running (PID: ${pid})`);
+      } else {
+        console.log('Daemon: stopped');
+        if (pid) {
+          console.log('  Stale PID file found, daemon may have crashed');
+        }
+        console.log('  Run: cf daemon start');
+      }
+
+      // Config status
+      const configPath = FORGE_PATHS.config();
+      console.log(`Config: ${fs.existsSync(configPath) ? configPath : 'not initialized'}`);
+
+      // Database status
+      const dbPath = resolveDbPath();
+      if (fs.existsSync(dbPath)) {
+        const stats = fs.statSync(dbPath);
+        const sizeMB = (stats.size / 1024 / 1024).toFixed(1);
+        console.log(`Database: ${dbPath} (${sizeMB} MB)`);
+      } else {
+        console.log(`Database: not initialized (expected at ${dbPath})`);
+      }
+    });
+}