feat(cli): /hooks /permissions /agents /skills /export slash commands (#127)

Adds five read-only inspector slash commands (all from the deferred parity
list), reusing existing data sources:

- /hooks       — events configured in settings.json (matcher + handler types)
- /permissions — allow/ask/deny rules + default mode (read-only view)
- /agents      — sub-agents from .deepcode/agents/ (loadSubAgents)
- /skills      — built-in + user + project skills (reuses list-cmd.listSkills)
- /export      — write the current conversation to a markdown file

Registered in BUILTIN_COMMANDS; BEHAVIOR_PARITY updated (these + the already-
shipped /vim flip from 🔄 to ✅/🟡).

Tests: +6 (commands.test.ts) — /hooks empty + populated, /permissions rules,
/agents + /skills against a temp project dir, /export writes a file + the
empty-history case. CLI suite 91 green.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: oratis

apps/cli/src/commands.test.ts

@@ -333,3 +333,90 @@ describe('built-in command behavior', () => {
     });
   });
 });
+
+describe('inspector + export commands', () => {
+  const reg = new CommandRegistry();
+  let cwd: string;
+  beforeEach(async () => {
+    cwd = await mkdtemp(join(tmpdir(), 'dc-cmds-'));
+  });
+  afterEach(async () => {
+    await rm(cwd, { recursive: true, force: true });
+  });
+
+  it('/hooks lists configured events or reports none', async () => {
+    const none = await reg.match('/hooks')!.cmd.run([], makeContext());
+    expect(none.join('\n')).toMatch(/No hooks configured/);
+
+    const ctx = makeContext({
+      settings: {
+        hooks: { Stop: [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'echo hi' }] }] },
+      },
+    });
+    const out = await reg.match('/hooks')!.cmd.run([], ctx);
+    expect(out.join('\n')).toMatch(/Stop:/);
+    expect(out.join('\n')).toMatch(/command \(match: Bash\)/);
+  });
+
+  it('/permissions shows rules + default mode', async () => {
+    const none = await reg.match('/permissions')!.cmd.run([], makeContext());
+    expect(none.join('\n')).toMatch(/No permission rules/);
+
+    const ctx = makeContext({
+      settings: {
+        permissions: { defaultMode: 'plan', allow: ['Bash(npm test:*)'], deny: ['Bash(rm:*)'] },
+      },
+    });
+    const out = (await reg.match('/permissions')!.cmd.run([], ctx)).join('\n');
+    expect(out).toMatch(/default mode: plan/);
+    expect(out).toMatch(/Bash\(npm test:\*\)/);
+    expect(out).toMatch(/Bash\(rm:\*\)/);
+  });
+
+  it('/agents lists a project sub-agent', async () => {
+    const dir = join(cwd, '.deepcode', 'agents');
+    const fs = await import('node:fs/promises');
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(
+      join(dir, 'explorer.md'),
+      '---\nname: explorer\ndescription: read-only explorer\n---\nExplore.\n',
+    );
+    const out = (await reg.match('/agents')!.cmd.run([], makeContext({ cwd }))).join('\n');
+    expect(out).toMatch(/explorer/);
+    expect(out).toMatch(/read-only explorer/);
+  });
+
+  it('/skills lists a project skill', async () => {
+    const dir = join(cwd, '.deepcode', 'skills', 'greet');
+    const fs = await import('node:fs/promises');
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(
+      join(dir, 'SKILL.md'),
+      '---\nname: greet\ndescription: say hi\n---\nGreet.\n',
+    );
+    const out = (await reg.match('/skills')!.cmd.run([], makeContext({ cwd }))).join('\n');
+    expect(out).toMatch(/greet/);
+    expect(out).toMatch(/\[project\]/);
+  });
+
+  it('/export writes a markdown file and reports the path', async () => {
+    const fs = await import('node:fs/promises');
+    const ctx = makeContext({
+      cwd,
+      history: [
+        { role: 'user', content: [{ type: 'text', text: 'hello' }] },
+        { role: 'assistant', content: [{ type: 'text', text: 'hi there' }] },
+      ],
+    });
+    const out = (await reg.match('/export')!.cmd.run([], ctx)).join('\n');
+    expect(out).toMatch(/Exported 2 messages/);
+    const written = await fs.readFile(join(cwd, 'deepcode-sess-xyz.md'), 'utf8');
+    expect(written).toContain('## User');
+    expect(written).toContain('hi there');
+  });
+
+  it('/export reports nothing to export with empty history', async () => {
+    const out = await reg.match('/export')!.cmd.run([], makeContext({ history: [] }));
+    expect(out.join('\n')).toMatch(/Nothing to export/);
+  });
+});

apps/cli/src/commands.ts

@@ -567,6 +567,146 @@ function restoreCodeMessage(
   return `✓ Restored ${target.filePath} from snapshot #${target.seq}`;
 }
 
+export const HooksCommand: SlashCommand = {
+  name: '/hooks',
+  description: 'List hooks configured in settings.json.',
+  run(_args, ctx) {
+    const hooks = ctx.settings.hooks ?? {};
+    const events = Object.keys(hooks);
+    if (events.length === 0) {
+      return ['No hooks configured.', '', 'Add them in settings.json under "hooks".'];
+    }
+    const lines = ['Configured hooks:'];
+    for (const event of events) {
+      const matchers = hooks[event as keyof typeof hooks] ?? [];
+      lines.push(`  ${event}:`);
+      for (const m of matchers) {
+        const match = m.matcher ? ` (match: ${m.matcher})` : '';
+        const types = m.hooks.map((h) => h.type).join(', ');
+        lines.push(`     - ${types}${match}`);
+      }
+    }
+    return lines;
+  },
+};
+
+export const PermissionsCommand: SlashCommand = {
+  name: '/permissions',
+  description: 'Show permission rules from settings.json.',
+  run(_args, ctx) {
+    const p = ctx.settings.permissions;
+    if (!p) return ['No permission rules configured (DeepCode asks before risky tools).'];
+    const lines = ['Permissions:'];
+    if (p.defaultMode) lines.push(`  default mode: ${p.defaultMode}`);
+    for (const kind of ['allow', 'ask', 'deny'] as const) {
+      const rules = p[kind] ?? [];
+      if (rules.length > 0) {
+        lines.push(`  ${kind}:`);
+        for (const r of rules) lines.push(`     ${r}`);
+      }
+    }
+    if ((p.additionalDirectories ?? []).length > 0) {
+      lines.push(`  additionalDirectories: ${p.additionalDirectories!.join(', ')}`);
+    }
+    return lines.length === 1 ? ['Permissions: (no rules; default mode only)'] : lines;
+  },
+};
+
+export const AgentsCommand: SlashCommand = {
+  name: '/agents',
+  description: 'List available sub-agents (.deepcode/agents/*.md).',
+  async run(_args, ctx) {
+    try {
+      const { loadSubAgents } = await import('@deepcode/core');
+      const agents = await loadSubAgents({ cwd: ctx.cwd });
+      if (agents.length === 0) {
+        return [
+          'No sub-agents found.',
+          'Add one as .deepcode/agents/<name>.md with a name/description frontmatter.',
+        ];
+      }
+      const lines = [`Sub-agents (${agents.length}):`];
+      for (const a of agents) {
+        lines.push(
+          `  ${a.qualifiedName}  [${a.source}]` +
+            (a.frontmatter.description ? ` — ${a.frontmatter.description}` : ''),
+        );
+      }
+      return lines;
+    } catch (err) {
+      return [`(Error loading sub-agents: ${(err as Error).message})`];
+    }
+  },
+};
+
+export const SkillsCommand: SlashCommand = {
+  name: '/skills',
+  description: 'List available skills (built-in + user + project).',
+  async run(_args, ctx) {
+    try {
+      const { listSkills } = await import('./list-cmd.js');
+      const rows = await listSkills({ cwd: ctx.cwd });
+      if (rows.length === 0) return ['No skills found.'];
+      const lines = [`Skills (${rows.length}):`];
+      for (const s of rows) {
+        lines.push(`  ${s.name}  [${s.source}]` + (s.description ? ` — ${s.description}` : ''));
+      }
+      return lines;
+    } catch (err) {
+      return [`(Error loading skills: ${(err as Error).message})`];
+    }
+  },
+};
+
+export const ExportCommand: SlashCommand = {
+  name: '/export',
+  description: 'Export the current conversation to a markdown file (/export [path]).',
+  async run(args, ctx) {
+    const history = ctx.history ?? [];
+    if (history.length === 0) return ['Nothing to export yet.'];
+    try {
+      const fs = await import('node:fs/promises');
+      const path = await import('node:path');
+      const target = args[0]
+        ? path.resolve(ctx.cwd, args[0])
+        : path.join(ctx.cwd, `deepcode-${ctx.sessionId}.md`);
+      await fs.writeFile(target, historyToMarkdown(history), 'utf8');
+      return [`✓ Exported ${history.length} messages → ${target}`];
+    } catch (err) {
+      return [`(Export failed: ${(err as Error).message})`];
+    }
+  },
+};
+
+/** Render a conversation as readable markdown (text + tool calls). */
+function historyToMarkdown(history: StoredMessage[]): string {
+  const out: string[] = ['# DeepCode conversation export', ''];
+  for (const msg of history) {
+    out.push(`## ${msg.role === 'user' ? 'User' : 'Assistant'}`, '');
+    for (const block of msg.content) {
+      if (block.type === 'text') out.push(block.text, '');
+      else if (block.type === 'thinking') out.push(`> _(thinking)_ ${block.text}`, '');
+      else if (block.type === 'tool_use')
+        out.push(
+          '```json',
+          `// tool: ${block.name}`,
+          JSON.stringify(block.input, null, 2),
+          '```',
+          '',
+        );
+      else if (block.type === 'tool_result')
+        out.push(
+          '```',
+          `// result${block.is_error ? ' (error)' : ''}`,
+          block.content.slice(0, 4000),
+          '```',
+          '',
+        );
+    }
+  }
+  return out.join('\n');
+}
+
 export const BUILTIN_COMMANDS: SlashCommand[] = [
   HelpCommand,
   ClearCommand,
@@ -587,6 +727,11 @@ export const BUILTIN_COMMANDS: SlashCommand[] = [
   KeybindingsCommand,
   VimCommand,
   RewindCommand,
+  HooksCommand,
+  PermissionsCommand,
+  AgentsCommand,
+  SkillsCommand,
+  ExportCommand,
 ];
 
 // ──────────────────────────────────────────────────────────────────────────