feat(cli): add /recap, /login, /logout, /pr_comments parity commands (#157)

oratis · t · claude · web-flow · commit 6f193a765397 · 2026-06-04T14:32:28.000+08:00
* feat(cli): add /recap, /login, /logout, /pr_comments parity commands Four Claude-Code slash commands that were missing (🔄 in BEHAVIOR_PARITY): - /recap — provider-summarized recap of the session so far (ctx.provider + ctx.history → runTurn; honest empty/no-provider states) - /login [key] — show auth status, or store a new DeepSeek API key (applies on next launch); /logout — clear stored creds + exit - /pr_comments — `gh pr view` comments for the current branch's PR (graceful no-gh / no-PR handling); pure formatPrComments renderer Adds credsStore to SessionContext (REPL-injected) for /login + /logout. Tests (parity-commands.test.ts, 9 cases): /recap via a mock provider + empty/ no-provider; /login + /logout against a forceFile CredentialsStore under a temp HOME (never the keychain, never real creds); formatPrComments rendering + the no-PR/no-gh fallback. Full CLI suite: 133 pass. Verified the real `gh pr view` JSON shape matches the parser. Flips the /recap, /login//logout, /pr_comments rows in BEHAVIOR_PARITY → ✅. (Overlaps the open #154 audit on those rows — see PR note.) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore(cli): prettier-format parity-commands.test.ts Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: t <t@t> Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
diff --git a/apps/cli/src/commands.ts b/apps/cli/src/commands.ts
@@ -2,6 +2,8 @@
 // Spec: docs/DEVELOPMENT_PLAN.md §3.6 (30+ commands; M2 ships a core subset)
 
 import type {
+  ContentBlock,
+  CredentialsStore,
   DeepCodeSettings,
   McpClientHandle,
   Provider,
@@ -47,13 +49,66 @@ async function runGit(
   }
 }
 
+/** Run a `gh` (GitHub CLI) subcommand in `cwd`, never throwing. `code` is the
+ *  spawn errno (e.g. 'ENOENT' when gh isn't installed). */
+async function runGh(
+  cwd: string,
+  args: string[],
+): Promise<{ ok: boolean; stdout: string; stderr: string; code?: string }> {
+  try {
+    const { stdout, stderr } = await execFileAsync('gh', args, {
+      cwd,
+      env: gitEnv(),
+      maxBuffer: 8 * 1024 * 1024,
+    });
+    return { ok: true, stdout, stderr };
+  } catch (err) {
+    const e = err as { stdout?: string; stderr?: string; message?: string; code?: string };
+    return {
+      ok: false,
+      stdout: e.stdout ?? '',
+      stderr: e.stderr ?? e.message ?? 'gh failed',
+      code: e.code,
+    };
+  }
+}
+
+/** PR comments payload from `gh pr view --json`. */
+interface PrCommentsData {
+  number: number;
+  title: string;
+  comments?: Array<{ author?: { login?: string }; body?: string; createdAt?: string }>;
+}
+
+/** Render the `gh pr view` comments JSON into display lines (pure — unit-tested). */
+export function formatPrComments(data: PrCommentsData): string[] {
+  const comments = data.comments ?? [];
+  if (comments.length === 0) {
+    return [`PR #${data.number} — ${data.title}`, '', 'No comments yet.'];
+  }
+  const lines: string[] = [
+    `PR #${data.number} — ${data.title}  (${comments.length} comment${comments.length === 1 ? '' : 's'})`,
+    '',
+  ];
+  for (const c of comments) {
+    const who = c.author?.login ? `@${c.author.login}` : '(unknown)';
+    const when = c.createdAt ? ` · ${c.createdAt.slice(0, 10)}` : '';
+    lines.push(`${who}${when}`);
+    for (const ln of (c.body ?? '').trim().split('\n')) lines.push(`  ${ln}`);
+    lines.push('');
+  }
+  return lines;
+}
+
 export interface SessionContext {
   cwd: string;
   model: string;
   mode: string;
   effort: string;
   settings: DeepCodeSettings;
   creds: Credentials;
+  /** Credentials store (REPL-injected) — backs /login and /logout. */
+  credsStore?: CredentialsStore;
   sessionId: string;
   sessions: SessionManager;
   usage: { inputTokens: number; outputTokens: number; reasoningTokens: number };
@@ -870,6 +925,97 @@ export const BugCommand: SlashCommand = {
   },
 };
 
+export const RecapCommand: SlashCommand = {
+  name: '/recap',
+  description: 'Summarize the conversation so far.',
+  async run(_args, ctx) {
+    if (!ctx.provider) return ['(/recap requires a provider — none configured.)'];
+    const history = ctx.history ?? [];
+    if (history.length === 0) return ['Nothing to recap yet — the conversation is empty.'];
+    const result = await ctx.provider.runTurn({
+      model: ctx.model,
+      systemPrompt:
+        'Recap this coding session for the user: the goal, what was explored or changed ' +
+        '(files, key findings), decisions made, and what is still in progress. Use short ' +
+        'bullet points. No preamble.',
+      tools: [],
+      messages: [
+        ...history,
+        {
+          role: 'user',
+          content: [{ type: 'text', text: 'Recap where we are in this session so far.' }],
+        },
+      ],
+    });
+    const text = result.content
+      .filter((b: ContentBlock) => b.type === 'text')
+      .map((b: ContentBlock) => (b as { text: string }).text)
+      .join('\n')
+      .trim();
+    return text ? text.split('\n') : ['(no recap produced)'];
+  },
+};
+
+export const LoginCommand: SlashCommand = {
+  name: '/login',
+  description: 'Set or replace the stored DeepSeek API key.',
+  async run(args, ctx) {
+    if (!ctx.credsStore) return ['(/login unavailable — no credentials store.)'];
+    const key = args[0]?.trim();
+    if (!key) {
+      const authed = !!(ctx.creds?.apiKey || ctx.creds?.authToken);
+      return [
+        authed ? 'Authenticated with a DeepSeek API key.' : 'Not authenticated.',
+        'Usage: /login <DEEPSEEK_API_KEY>   — stores a new key (applies on next launch).',
+      ];
+    }
+    await ctx.credsStore.save({ ...ctx.creds, apiKey: key });
+    return [
+      'Saved a new DeepSeek API key.',
+      'Restart `deepcode` for it to take effect in a new session.',
+    ];
+  },
+};
+
+export const LogoutCommand: SlashCommand = {
+  name: '/logout',
+  description: 'Clear stored DeepSeek credentials and exit.',
+  async run(_args, ctx) {
+    if (!ctx.credsStore) return ['(/logout unavailable — no credentials store.)'];
+    await ctx.credsStore.clear();
+    ctx.exitRequested = true;
+    return [
+      'Logged out — stored DeepSeek credentials cleared.',
+      'Run `deepcode` to sign in again.',
+    ];
+  },
+};
+
+export const PrCommentsCommand: SlashCommand = {
+  name: '/pr_comments',
+  description: "Show comments on the current branch's pull request (needs gh).",
+  async run(_args, ctx) {
+    const res = await runGh(ctx.cwd, ['pr', 'view', '--json', 'number,title,comments']);
+    if (!res.ok) {
+      if (res.code === 'ENOENT') {
+        return ['/pr_comments needs the GitHub CLI (`gh`). Install: https://cli.github.com'];
+      }
+      const err = res.stderr.trim();
+      if (/no (pull requests|default remote|open)|not found|no git remotes/i.test(err)) {
+        return ['No open pull request found for the current branch.'];
+      }
+      return [`/pr_comments failed: ${err || 'unknown error'}`];
+    }
+    let data: PrCommentsData;
+    try {
+      data = JSON.parse(res.stdout) as PrCommentsData;
+    } catch {
+      return ['/pr_comments: could not parse gh output.'];
+    }
+    return formatPrComments(data);
+  },
+};
+
 export const BUILTIN_COMMANDS: SlashCommand[] = [
   HelpCommand,
   ClearCommand,
@@ -899,6 +1045,10 @@ export const BUILTIN_COMMANDS: SlashCommand[] = [
   DiffCommand,
   ReleaseNotesCommand,
   BugCommand,
+  RecapCommand,
+  LoginCommand,
+  LogoutCommand,
+  PrCommentsCommand,
 ];
 
 // ──────────────────────────────────────────────────────────────────────────
diff --git a/apps/cli/src/parity-commands.test.ts b/apps/cli/src/parity-commands.test.ts
@@ -0,0 +1,136 @@
+// Tests for the parity slash commands: /recap, /login, /logout, /pr_comments.
+// Credentials tests use a forceFile store under a temp HOME (never the keychain,
+// never real creds). /recap uses a mock provider; /pr_comments' renderer is pure.
+
+import { afterEach, describe, expect, it } from 'vitest';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { CredentialsStore, SessionManager } from '@deepcode/core';
+import { CommandRegistry, formatPrComments, type SessionContext } from './commands.js';
+
+const reg = new CommandRegistry();
+const tmps: string[] = [];
+async function tmpHome(): Promise<string> {
+  const d = await mkdtemp(join(tmpdir(), 'dc-parity-'));
+  tmps.push(d);
+  return d;
+}
+afterEach(async () => {
+  await Promise.all(tmps.splice(0).map((d) => rm(d, { recursive: true, force: true })));
+});
+
+function ctx(overrides: Partial<SessionContext> = {}): SessionContext {
+  return {
+    cwd: '/tmp/x',
+    model: 'deepseek-chat',
+    mode: 'default',
+    effort: 'medium',
+    settings: {},
+    creds: { apiKey: 'sk-test' },
+    sessionId: 's1',
+    sessions: new SessionManager({ root: '/tmp/x' }),
+    usage: { inputTokens: 0, outputTokens: 0, reasoningTokens: 0 },
+    ...overrides,
+  };
+}
+
+const mockProvider = {
+  runTurn: async () => ({
+    content: [{ type: 'text', text: '- explored repo\n- decided on plan' }],
+    stopReason: 'end_turn',
+    usage: { inputTokens: 1, outputTokens: 1, reasoningTokens: 0 },
+  }),
+} as unknown as SessionContext['provider'];
+
+describe('/recap', () => {
+  it('summarizes the conversation via the provider', async () => {
+    const out = await reg.match('/recap')!.cmd.run(
+      [],
+      ctx({
+        provider: mockProvider,
+        history: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+      }),
+    );
+    expect(out.join('\n')).toContain('explored repo');
+  });
+
+  it('reports an empty conversation', async () => {
+    const out = await reg
+      .match('/recap')!
+      .cmd.run([], ctx({ provider: mockProvider, history: [] }));
+    expect(out.join('\n')).toMatch(/nothing to recap/i);
+  });
+
+  it('needs a provider', async () => {
+    const out = await reg
+      .match('/recap')!
+      .cmd.run([], ctx({ history: [{ role: 'user', content: [{ type: 'text', text: 'x' }] }] }));
+    expect(out.join('\n')).toMatch(/requires a provider/i);
+  });
+});
+
+describe('/login + /logout', () => {
+  it('/logout clears stored credentials and requests exit', async () => {
+    const home = await tmpHome();
+    const store = new CredentialsStore({ home, forceFile: true });
+    await store.save({ apiKey: 'sk-willbecleared' });
+    const c = ctx({ credsStore: store, creds: { apiKey: 'sk-willbecleared' } });
+    const out = await reg.match('/logout')!.cmd.run([], c);
+    expect(out.join('\n')).toMatch(/logged out/i);
+    expect(c.exitRequested).toBe(true);
+    expect((await store.load()).apiKey).toBeFalsy();
+  });
+
+  it('/login <key> saves a new key', async () => {
+    const home = await tmpHome();
+    const store = new CredentialsStore({ home, forceFile: true });
+    const out = await reg
+      .match('/login')!
+      .cmd.run(['sk-brandnew456'], ctx({ credsStore: store, creds: {} }));
+    expect(out.join('\n')).toMatch(/saved/i);
+    expect((await store.load()).apiKey).toBe('sk-brandnew456');
+  });
+
+  it('/login with no arg shows status + usage', async () => {
+    const home = await tmpHome();
+    const store = new CredentialsStore({ home, forceFile: true });
+    const out = await reg
+      .match('/login')!
+      .cmd.run([], ctx({ credsStore: store, creds: { apiKey: 'sk-existing' } }));
+    expect(out.join('\n')).toMatch(/authenticated/i);
+    expect(out.join('\n')).toMatch(/usage: \/login/i);
+  });
+});
+
+describe('/pr_comments', () => {
+  it('formatPrComments renders comments with author + body', () => {
+    const lines = formatPrComments({
+      number: 42,
+      title: 'My PR',
+      comments: [
+        {
+          author: { login: 'alice' },
+          body: 'looks good\nship it',
+          createdAt: '2026-06-04T01:00:00Z',
+        },
+      ],
+    }).join('\n');
+    expect(lines).toContain('PR #42 — My PR');
+    expect(lines).toContain('@alice');
+    expect(lines).toContain('looks good');
+    expect(lines).toContain('ship it');
+  });
+
+  it('formatPrComments handles a PR with no comments', () => {
+    const lines = formatPrComments({ number: 7, title: 'Quiet PR', comments: [] }).join('\n');
+    expect(lines).toMatch(/no comments/i);
+  });
+
+  it('reports gracefully outside a PR / without gh', async () => {
+    const dir = await tmpHome();
+    const out = (await reg.match('/pr_comments')!.cmd.run([], ctx({ cwd: dir }))).join('\n');
+    // Whether gh is installed or not, we must not throw and must say something sane.
+    expect(out).toMatch(/no open pull request|needs the github cli|failed/i);
+  });
+});
diff --git a/apps/cli/src/repl.ts b/apps/cli/src/repl.ts
@@ -418,6 +418,7 @@ export async function startRepl(opts: ReplOpts): Promise<number> {
     effort,
     settings,
     creds,
+    credsStore,
     sessionId: session.id,
     sessions,
     usage: { inputTokens: 0, outputTokens: 0, reasoningTokens: 0 },
diff --git a/docs/BEHAVIOR_PARITY.md b/docs/BEHAVIOR_PARITY.md
@@ -37,7 +37,7 @@ Legend: `✅` matches · `🟡` matches with caveats · `🔄` deferred · `⚠
 | `/plugins`            | ✓           | ✓                  | ✅ — lists wired plugins + contributed hook events + warnings (M5.2)                       |
 | `/compact`            | ✓           | ✓                  | ✅ — manual `/compact` + automatic threshold trigger in the agent loop                     |
 | `/btw`                | ✓           | ✗                  | 🔄                                                                                         |
-| `/recap`              | ✓           | ✗                  | 🔄                                                                                         |
+| `/recap`              | ✓           | ✓                  | ✅ — provider-summarized recap of the session so far                                       |
 | `/rewind`             | ✓           | ✓                  | ✅ — 5 ops (code/conversation/both/summarize-from/up-to); `Esc Esc` bound                  |
 | `/voice`              | ✓           | ✗                  | 🔄 M8                                                                                      |
 | `/teleport`           | ✓           | ✗                  | 🔄 M8                                                                                      |
@@ -46,11 +46,11 @@ Legend: `✅` matches · `🟡` matches with caveats · `🔄` deferred · `⚠
 | `/batch`              | ✓           | ✗                  | 🔄                                                                                         |
 | `/tasks`              | ✓           | ✗                  | 🔄                                                                                         |
 | `/plan`               | ✓           | ✗                  | 🔄 — set via `/mode plan` in DeepCode                                                      |
-| `/login` / `/logout`  | ✓           | ✗                  | 🔄 — DeepCode currently uses re-onboarding (clear creds + restart)                         |
+| `/login` / `/logout`  | ✓           | ✓                  | ✅ — /logout clears creds + exits; /login <key> stores a new key (next launch)             |
 | `/export`             | ✓           | ✓                  | ✅ — writes the conversation to a markdown file                                            |
 | `/bug`                | ✓           | ✗                  | 🔄                                                                                         |
 | `/upgrade`            | ✓           | ✓ (hint only)      | 🟡                                                                                         |
-| `/pr_comments`        | ✓           | ✗                  | 🔄                                                                                         |
+| `/pr_comments`        | ✓           | ✓                  | ✅ — `gh pr view` comments for the current branch's PR                                     |
 | `/review`             | ✓           | ✗ (skill avail)    | 🟡 — via Skill tool                                                                        |
 | `/security-review`    | ✓           | ✗ (skill avail)    | 🟡 — via Skill tool                                                                        |
 | `/schedule`           | ✓           | ✗ (skill avail)    | 🟡                                                                                         |
