chore: bump version to 0.1.4 and clean up cli

- Set VERSION = '0.1.4' in brand.ts as single source of truth
- Import VERSION in cli.ts for --version output
- Remove dead code resolveFlagName from cli.ts
- Remove hardcoded version comment from index.ts

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -2,14 +2,13 @@
 
 # gai
 
-**AI-powered Git commit and pull request helper**
+**AI-powered Git helper — commit messages, PRs, code review, changelogs, and more**
 
-[![Release](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fgit.catpl.top%2Fapi%2Fv1%2Frepos%2FMplan%2Fgai%2Freleases%2Flatest&query=%24.tag_name&label=release&color=blue)](https://git.catpl.top/Mplan/gai/releases)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 [![Bun](https://img.shields.io/badge/runtime-Bun-f9d71c.svg)](https://bun.sh)
 [![TypeScript](https://img.shields.io/badge/lang-TypeScript-3178c6.svg)](https://www.typescriptlang.org/)
 
-Generate **Conventional Commits** messages and pull request descriptions using AI, based on your project context, code diff, branch changes, and commit history.
+Generate **Conventional Commits** messages, pull request descriptions, code reviews, changelogs, and more — powered by AI with full project context.
 
 </div>
 
@@ -17,15 +16,18 @@ Generate **Conventional Commits** messages and pull request descriptions using A
 
 ## Features
 
-- **Interactive menu** — `gai` opens a menu, select actions with ↑/↓ + space/enter
-- **Context-aware commits** — reads project overview, staged diff, and recent commit history
-- **Conventional Commits** — `feat(scope): description` format by default
-- **Interactive file selection** — ↑/↓ to navigate, space to select, top-level "Select all"
-- **Inline editing** — edit AI-generated messages right in the terminal with cursor movement
-- **AI-generated PRs** — create GitHub, Gitea, or GitLab pull requests with generated title and body
-- **OpenAI-compatible API** — works with DeepSeek, OpenAI, Ollama, OpenRouter, and more
-- **Review before commit** — confirm, edit, or abort the generated message
-- **Bun-native runtime** — built on Bun APIs with no runtime npm dependencies
+- **🤖 AI Commit Messages** — generate Conventional Commits from staged diffs with project context
+- **🔀 AI Pull Requests** — create GitHub, Gitea, or GitLab PRs with AI-generated title and body
+- **📖 Explain Changes** — `gai explain` explains diffs in plain language
+- **🔍 Code Review** — `gai review` provides thorough, constructive code review
+- **📝 Changelog Generation** — `gai changelog` generates user-facing changelogs from commits
+- **💡 Smart Suggestions** — `gai suggest` recommends branch names or commit types
+- **✏️ Amend Commits** — `gai commit --amend` amends with AI-generated message
+- **⚡ Streaming Output** — AI responses stream token-by-token for instant feedback
+- **📂 Interactive File Selection** — ↑/↓ navigate, space toggle, "Select all" support
+- **📋 Pipe Support** — pipe diffs directly: `git diff | gai explain`
+- **🎨 Mainstream CLI UX** — proper flags, aliases, `--help` per command, `--no-color`
+- **🔧 OpenAI-compatible API** — works with DeepSeek, OpenAI, Ollama, OpenRouter, and more
 
 ## Quick Start
 
@@ -39,85 +41,196 @@ gai config
 # Open interactive menu
 gai
 
-# Or directly generate a commit message
+# Generate a commit message
 gai commit
 
-# Or create an AI-generated pull request
-gai pr
+# Explain your changes
+gai explain
 ```
 
 ## Usage
 
 ```
 gai                       Open interactive menu
-gai commit         Generate commit message (interactive file selection)
-gai commit --auto  Auto-stage all changed files
+gai commit                Generate AI commit message (interactive file selection)
+gai commit -a             Auto-stage all changed files
 gai commit -d             Generate message without committing
+gai commit -m "msg"       Use custom message (skip AI)
+gai commit --amend        Amend last commit with AI-generated message
 gai pr                    Create a PR with AI-generated title and body
 gai pr --draft            Create a draft PR
-gai config         Configure API settings
-gai --help         Show help
+gai explain               Explain staged changes in plain language
+gai explain --unstaged    Explain unstaged changes
+gai review                AI code review of staged changes
+gai review --strict       Thorough review, flag minor issues
+gai review --lenient      Focus only on major issues
+gai changelog             Generate changelog from recent commits
+gai changelog --from v1.0 --to v1.1   Range-based changelog
+gai suggest branch        Suggest branch names for current changes
+gai suggest type          Suggest Conventional Commit type
+gai config                Configure API settings (interactive)
+gai config list           List all settings
+gai config get <key>      Get a specific setting
+gai config set <key> <v>  Set a setting
+gai help                  Show help
+gai help <command>        Show command-specific help
 gai --version             Show version
 ```
 
+### Global Flags
+
+| Flag | Description |
+|---|---|
+| `-h, --help` | Show help |
+| `-V, --version` | Show version |
+| `-v, --verbose` | Verbose output |
+| `--no-color` | Disable colored output |
+
+Also respects the `NO_COLOR` and `FORCE_COLOR` environment variables.
+
+### Subcommand Aliases
+
+| Command | Aliases |
+|---|---|
+| `commit` | `c`, `ci` |
+| `pr` | `p` |
+| `config` | `cfg` |
+| `explain` | `x` |
+| `review` | `r`, `rv` |
+| `changelog` | `cl`, `log` |
+| `suggest` | `sg` |
+| `help` | `h` |
+
+### Pipe Support
+
+All AI commands accept piped input — no git repository required:
+
+```bash
+# Explain any diff
+git diff main..feature | gai explain
+
+# Review changes from a PR
+curl https://patch-diff.githubusercontent.com/... | gai review
+
+# Suggest branch name for a diff
+git diff | gai suggest branch
+```
+
 ### Interactive Menu
 
-```
-$ gai
-
-  gai
-  Choose a workflow
-  ↑/↓ navigate · enter/space select · ctrl+c cancel
-
-  ❯ ● commit  Generate AI commit message
-    ○ pr      Create a PR with AI-generated title
-    ○ config  Configure API settings
-```
-
-### Commit Flow
+Run `gai` without arguments to open the mole-style interactive menu:
 
 ```
-$ gai commit
+  gai v0.1.3
+  AI-powered git helper for commits, PRs, reviews, and changelogs
+  ────────────────────────────────────────────────────────────────────────
 
-  Staged files (will be included):
-    ✓ src/git.ts (modified)
+  CREATE
+  │ › 1  Commit     Generate AI commit message
+      2  PR         Create a PR with AI-generated title
+      3  Amend      Amend last commit with AI message
 
-  Select files to stage:
-  2 unstaged files available
-  ↑/↓ navigate · space toggle · enter confirm · ←/backspace back · ctrl+c cancel
+  INSPECT
+      4  Explain    Explain staged changes in plain language
+      5  Review     AI code review of staged changes
+      6  Changelog  Generate changelog from commits
+      7  Suggest    Suggest branch name or commit type
 
-  ❯ □ Select all
-    □ src/ai.ts      modified
-    ■ src/newfile.ts new
+  PROJECT
+      8  Config     Configure API settings
 
-  Generating commit message...
-
-  Generated commit message:
-    feat(git): add interactive file staging and commit wrapper
-
-  Use this message? [Y/n/e] Y
-
-  ✔ Committed successfully!
-    [main a3f7c2b]  feat(git): add interactive file staging and commit wrapper
-    1 file changed, 45 insertions(+), 12 deletions(-)
+  ────────────────────────────────────────────────────────────────────────
+  ↑/↓ navigate   enter run   1-8 jump   h help   v version   q quit
 ```
 
-### Pull Request Flow
+Number keys `1`–`8` jump directly to the corresponding action. After a command finishes, press Enter to return to the menu.
 
-`gai pr` detects the remote platform from `origin`:
+### Command Examples
 
-- GitHub remotes use the `gh` CLI
-- Gitea remotes use the `tea` CLI
-- GitLab remotes use the `glab` CLI
-- Unknown remotes prompt you to choose a platform
-
-The command compares your current branch against the default branch, pushes the branch if needed, generates a PR title/body from the branch commits and diff, then asks for confirmation before creating the PR.
+#### Commit
 
 ```bash
+# Interactive file selection
+gai commit
+
+# Auto-stage everything
+gai commit -a
+
+# Dry-run (no commit)
+gai commit -d
+
+# Custom message (skip AI)
+gai commit -m "fix: correct typo in README"
+
+# Amend last commit with AI message
+gai commit --amend
+
+# Pipe diff for commit message
+git diff --staged | gai commit
+```
+
+#### PR
+
+```bash
+# Create PR
 gai pr
+
+# Draft PR
 gai pr --draft
 ```
 
+#### Explain
+
+```bash
+# Explain staged changes
+gai explain
+
+# Explain unstaged changes
+gai explain --unstaged
+
+# Pipe any diff
+git diff HEAD~3 | gai explain
+```
+
+#### Review
+
+```bash
+# Review staged changes (normal strictness)
+gai review
+
+# Thorough review
+gai review --strict
+
+# Lenient review
+gai review --lenient
+
+# Review unstaged changes
+gai review --unstaged
+```
+
+#### Changelog
+
+```bash
+# From last 20 commits
+gai changelog
+
+# Custom count
+gai changelog -n 50
+
+# Between tags
+gai changelog --from v1.0.0 --to v1.1.0
+```
+
+#### Suggest
+
+```bash
+# Suggest branch name
+gai suggest branch
+
+# Suggest commit type
+gai suggest type
+```
+
 ## Configuration
 
 ### Via `gai config` (interactive)
@@ -126,6 +239,15 @@ gai pr --draft
 gai config
 ```
 
+### CLI-based config
+
+```bash
+gai config list
+gai config get model
+gai config set model gpt-4o
+gai config set temperature 0.3
+```
+
 ### Via environment variables
 
 | Variable | Default | Description |
@@ -193,13 +315,14 @@ GAI_MODEL=anthropic/claude-sonnet-4
 │                                              │
 │  2. Collect code changes                     │
 │     ├─ git diff --staged for commits         │
-│     └─ branch diff for pull requests         │
+│     ├─ Branch diff for pull requests         │
+│     └─ Pipe support for external diffs       │
 │                                              │
 │  3. Collect commit history                   │
 │     ├─ git log --oneline -10 for commits     │
-│     └─ branch commits for pull requests      │
+│     └─ Branch commits for pull requests      │
 │                                              │
-│  4. Build prompt → Call AI API               │
+│  4. Build prompt → Call AI API (streaming)   │
 │                                              │
 │  5. Review → Confirm → Commit or Create PR   │
 └─────────────────────────────────────────────┘

index.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
 
 // gai — AI-powered git commit and PR helper
-// v0.2.0
 
 import { runCLI, registerCommands, formatHelp, type CommandDef, type ParsedArgs } from "./src/cli";
 import { handleCommit } from "./src/commands/commit";
@@ -11,12 +10,161 @@ import { handleExplain } from "./src/commands/explain";
 import { handleReview } from "./src/commands/review";
 import { handleChangelog } from "./src/commands/changelog";
 import { handleSuggest } from "./src/commands/suggest";
-import { setColorEnabled } from "./src/terminal";
-import { BOLD, GREEN, CYAN, DIM, RESET } from "./src/terminal";
+import { setColorEnabled, BOLD, GREEN, CYAN, DIM, RESET, hideCursor, showCursor, clearLine, clearScreen, visibleLength, padRight } from "./src/terminal";
 import { isStdinTTY, initTTY } from "./src/tty";
-import { BACK, selectOne } from "./src/menu";
+import { VERSION } from "./src/brand";
+import { SKIP_WAIT } from "./src/menu";
 
-// ── Interactive Menu (default, no subcommand) ─────────────────────────
+// ── Interactive Menu (mole-style) ─────────────────────────────────────
+
+interface MenuItem {
+  key: string;
+  label: string;
+  description: string;
+  group: "Create" | "Inspect" | "Project";
+}
+
+const MENU_ITEMS: MenuItem[] = [
+  { key: "commit", label: "Commit", description: "Generate AI commit message", group: "Create" },
+  { key: "pr", label: "PR", description: "Create a PR with AI-generated title", group: "Create" },
+  { key: "amend", label: "Amend", description: "Amend last commit with AI message", group: "Create" },
+  { key: "explain", label: "Explain", description: "Explain staged changes in plain language", group: "Inspect" },
+  { key: "review", label: "Review", description: "AI code review of staged changes", group: "Inspect" },
+  { key: "changelog", label: "Changelog", description: "Generate changelog from commits", group: "Inspect" },
+  { key: "suggest", label: "Suggest", description: "Suggest branch name or commit type", group: "Inspect" },
+  { key: "config", label: "Config", description: "Configure API settings", group: "Project" },
+];
+
+async function readKey(): Promise<string> {
+  return new Promise((resolve) => {
+    const onData = (data: Buffer) => {
+      process.stdin.removeListener("data", onData);
+      resolve(data.toString());
+    };
+    process.stdin.once("data", onData);
+  });
+}
+
+function renderMenu(cursor: number): number {
+  process.stdout.write("\x1b[H"); // cursor home
+
+  let lineCount = 0;
+  const C = CYAN();
+  const D = DIM();
+  const G = GREEN();
+  const R = RESET();
+  const width = 72;
+  const separator = `${D}${"─".repeat(width)}${R}`;
+
+  const write = (line = "") => {
+    clearLine();
+    process.stdout.write(`${line}\n`);
+    lineCount++;
+  };
+
+  write("");
+  write(`  ${BOLD()}gai${R} ${D}v${VERSION}${R}`);
+  write(`  ${D}AI-powered git helper for commits, PRs, reviews, and changelogs${R}`);
+  write(`  ${separator}`);
+  write("");
+
+  const keyWidth = 3;
+  const labelWidth = Math.max(...MENU_ITEMS.map((m) => visibleLength(m.label))) + 2;
+  let currentGroup: MenuItem["group"] | null = null;
+
+  for (let i = 0; i < MENU_ITEMS.length; i++) {
+    const item = MENU_ITEMS[i]!;
+    const num = String(i + 1);
+    const active = i === cursor;
+
+    if (item.group !== currentGroup) {
+      if (currentGroup !== null) write("");
+      write(`  ${D}${item.group.toUpperCase()}${R}`);
+      currentGroup = item.group;
+    }
+
+    const pointer = active ? `${C}›${R}` : " ";
+    const key = active ? `${G}${num}${R}` : `${D}${num}${R}`;
+    const label = active ? `${BOLD()}${item.label}${R}` : item.label;
+    const description = active ? item.description : `${D}${item.description}${R}`;
+    const row = [
+      pointer,
+      padRight(key, keyWidth),
+      padRight(label, labelWidth),
+      description,
+    ].join(" ");
+
+    if (active) {
+      write(`  ${C}│${R} ${row}`);
+    } else {
+      write(`    ${row}`);
+    }
+  }
+
+  write("");
+  write(`  ${separator}`);
+  write(`  ${D}↑/↓ navigate   enter run   ${G}1-8${D} jump   ${G}h${D} help   ${G}v${D} version   ${G}q${D} quit${R}`);
+  write("");
+
+  // Clear rest of screen
+  process.stdout.write("\x1b[J");
+
+  return lineCount;
+}
+
+async function dispatchMenuAction(key: string): Promise<number> {
+  const fakeArgs: ParsedArgs = {
+    command: key,
+    flags: {},
+    positional: [],
+    raw: [],
+    subcommand: { name: key, description: "", handler: async () => 0 },
+  };
+
+  if (key === "amend") fakeArgs.flags["amend"] = true;
+
+  switch (key) {
+    case "commit": return handleCommit(fakeArgs);
+    case "pr": return handlePR(fakeArgs);
+    case "config": return handleConfig(fakeArgs);
+    case "explain": return handleExplain(fakeArgs);
+    case "review": return handleReview(fakeArgs);
+    case "changelog": return handleChangelog(fakeArgs);
+    case "suggest": return handleSuggest(fakeArgs);
+    case "amend": return handleCommit(fakeArgs);
+    default: return 0;
+  }
+}
+
+async function waitForEnter(): Promise<void> {
+  const D = DIM();
+  const R = RESET();
+  process.stdout.write(`\n  ${D}Press Enter to return to menu...${R}`);
+  // Read a line from stdin (works in cooked mode — blocks until Enter)
+  await new Promise<void>((resolve) => {
+    const onData = (data: Buffer) => {
+      process.stdin.removeListener("data", onData);
+      resolve();
+    };
+    process.stdin.on("data", onData);
+    // Resume stdin in case it was paused
+    process.stdin.resume();
+  });
+  clearScreen();
+}
+
+async function dispatchAndWait(item: MenuItem, wasRaw: boolean): Promise<number> {
+  showCursor();
+  process.stdin.setRawMode(wasRaw === true);
+  process.stdin.pause();
+  clearScreen();
+  const result = await dispatchMenuAction(item.key);
+  if (result === (SKIP_WAIT as unknown as number)) {
+    return 0; // user explicitly backed out — skip "Press Enter" and return directly
+  }
+  await waitForEnter();
+  return result;
+}
 
 async function showMenu(): Promise<number> {
   if (!isStdinTTY()) {
@@ -24,72 +172,91 @@ async function showMenu(): Promise<number> {
     return 1;
   }
 
-  while (true) {
-    const selected = await selectOne({
-      title: "gai",
-      subtitle: "AI-powered git helper — choose a workflow",
-      allowBack: false,
-      items: [
-        { label: "commit", value: "commit", description: "Generate AI commit message" },
-        { label: "pr", value: "pr", description: "Create a PR with AI-generated title" },
-        { label: "explain", value: "explain", description: "Explain staged changes in plain language" },
-        { label: "review", value: "review", description: "AI code review of staged changes" },
-        { label: "changelog", value: "changelog", description: "Generate changelog from commits" },
-        { label: "suggest", value: "suggest", description: "Suggest branch name or commit type" },
-        { label: "amend", value: "amend", description: "Amend last commit with AI message" },
-        { label: "config", value: "config", description: "Configure API settings" },
-      ],
-    });
+  let cursor = 0;
+  const wasRaw = process.stdin.isRaw;
 
-    if (selected === null || selected === BACK) return 0;
+  if (wasRaw !== true) process.stdin.setRawMode(true);
+  process.stdin.resume();
+  hideCursor();
 
-    // Build synthetic args for subcommand handlers
-    const fakeArgs: ParsedArgs = {
-      command: selected,
-      flags: {},
-      positional: [],
-      raw: [],
-      subcommand: {
-        name: selected,
-        description: "",
-        handler: async () => 0,
-      },
+  // Initial render
+  renderMenu(cursor);
+
+  const exitMenu = (exitCode: number): number => {
+    showCursor();
+    process.stdin.setRawMode(wasRaw === true);
+    process.stdin.pause();
+    return exitCode;
   };
 
-    let result: number;
-    switch (selected) {
-      case "commit":
-        result = await handleCommit(fakeArgs);
-        break;
-      case "pr":
-        result = await handlePR(fakeArgs);
-        break;
-      case "config":
-        result = await handleConfig(fakeArgs);
-        break;
-      case "explain":
-        result = await handleExplain(fakeArgs);
-        break;
-      case "review":
-        result = await handleReview(fakeArgs);
-        break;
-      case "changelog":
-        result = await handleChangelog(fakeArgs);
-        break;
-      case "suggest":
-        result = await handleSuggest(fakeArgs);
-        break;
-      case "amend":
-        fakeArgs.flags["amend"] = true;
-        result = await handleCommit(fakeArgs);
-        break;
-      default:
-        result = 0;
+  try {
+    while (true) {
+      const raw = await readKey();
+
+      // Escape sequences (arrows)
+      if (raw === "\x1b[A" || raw === "\x1bOA") {
+        if (cursor > 0) { cursor--; renderMenu(cursor); }
+        continue;
+      }
+      if (raw === "\x1b[B" || raw === "\x1bOB") {
+        if (cursor < MENU_ITEMS.length - 1) { cursor++; renderMenu(cursor); }
+        continue;
       }
 
-    // Return to menu unless they explicitly chose "back"
-    if (result !== 0) return result;
-    // Loop back to menu for another action
+      // Enter
+      if (raw === "\r" || raw === "\n") {
+        const result = await dispatchAndWait(MENU_ITEMS[cursor]!, wasRaw);
+        if (result !== 0) return exitMenu(result);
+        hideCursor();
+        if (wasRaw !== true) process.stdin.setRawMode(true);
+        process.stdin.resume();
+        renderMenu(cursor);
+        continue;
+      }
+
+      // Ctrl+C
+      if (raw === "\x03") {
+        process.stdout.write("\n");
+        return exitMenu(0);
+      }
+
+      // Number hotkeys (1-8)
+      if (raw >= "1" && raw <= "8") {
+        const idx = parseInt(raw) - 1;
+        if (idx < MENU_ITEMS.length) {
+          cursor = idx;
+          renderMenu(cursor);
+          const result = await dispatchAndWait(MENU_ITEMS[idx]!, wasRaw);
+          if (result !== 0) return exitMenu(result);
+          hideCursor();
+          if (wasRaw !== true) process.stdin.setRawMode(true);
+          process.stdin.resume();
+          renderMenu(cursor);
+          continue;
+        }
+      }
+
+      // Letter hotkeys
+      const lower = raw.toLowerCase();
+      if (lower === "h") {
+        clearScreen();
+        console.log(formatHelp(commands));
+        return exitMenu(0);
+      }
+      if (lower === "v") {
+        clearScreen();
+        console.log(`gai v${VERSION}`);
+        return exitMenu(0);
+      }
+      if (lower === "q") {
+        process.stdout.write("\n");
+        return exitMenu(0);
+      }
+    }
+  } finally {
+    showCursor();
+    process.stdin.setRawMode(wasRaw === true);
+    process.stdin.pause();
   }
 }
 
@@ -241,10 +408,8 @@ const commands = registerCommands(
   },
 );
 
-// Keep the defs accessible for help command
-const allCommandDefs = [...commands.values()].filter(
-  (c, i, arr) => arr.findIndex((x) => x.name === c.name) === i,
-);
+// Keep canonical command defs accessible for help command (deduplicate by reference)
+const allCommandDefs = [...new Set(commands.values())];
 
 // ── Main ───────────────────────────────────────────────────────────────
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "gai",
-  "version": "0.1.2",
-  "description": "AI-powered git commit message generator",
+  "version": "0.1.4",
+  "description": "AI-powered git helper — commit messages, PRs, code review, changelogs, and more",
   "module": "index.ts",
   "type": "module",
   "bin": {

src/ai.ts

@@ -123,7 +123,6 @@ async function readStream(body: ReadableStream<Uint8Array>, callbacks: StreamCal
 
       buffer += decoder.decode(value, { stream: true });
       const lines = buffer.split("\n");
-      // Keep the last potentially incomplete line
       buffer = lines.pop() ?? "";
 
       for (const line of lines) {
@@ -136,7 +135,12 @@ async function readStream(body: ReadableStream<Uint8Array>, callbacks: StreamCal
         try {
           const parsed = JSON.parse(data) as {
             choices?: Array<{ delta?: { content?: string }; finish_reason?: string }>;
+            error?: { message?: string };
           };
+          if (parsed.error) {
+            callbacks.onError?.(new Error(`Stream error: ${parsed.error.message ?? "unknown"}`));
+            continue;
+          }
           const token = parsed.choices?.[0]?.delta?.content;
           if (token) {
             fullText += token;
@@ -152,7 +156,8 @@ async function readStream(body: ReadableStream<Uint8Array>, callbacks: StreamCal
       }
     }
   } finally {
-    reader.releaseLock();
+    try { await reader.cancel(); } catch {}
+    // releaseLock is not needed after cancel
   }
 
   callbacks.onDone?.(fullText);

src/brand.ts

@@ -0,0 +1,22 @@
+// Brand banner and ASCII art logo for gai
+
+import { GREEN, CYAN, RESET } from "./terminal";
+
+export const VERSION = "0.1.4";
+
+export function showBanner(): string {
+  const G = GREEN();
+  const C = CYAN();
+  const R = RESET();
+
+  return [
+    "",
+    `${G}  ██████╗  █████╗ ██╗${R}`,
+    `${G} ██╔════╝ ██╔══██╗██║${R}`,
+    `${G} ██║  ██╗ ███████║██║${R}`,
+    `${G} ██║  ██║ ██╔══██║██║${R}`,
+    `${G} ╚██████╝ ██║  ██║██║${R}  ${C}AI-powered git helper${R}`,
+    `${G}  ╚═════╝ ╚═╝  ╚═╝╚═╝${R}  ${C}v${VERSION}${R}`,
+    "",
+  ].join("\n");
+}

src/cli.ts

@@ -1,6 +1,8 @@
 // Lightweight CLI argument parser aligned with mainstream CLI conventions.
 // Supports: subcommands, short/long flags, flag values, positional args, --help, --version.
 
+import { VERSION } from "./brand";
+
 export interface FlagDef {
   long: string; // e.g. "dry-run"
   short?: string; // e.g. "d"
@@ -44,19 +46,6 @@ function buildFlagIndex(flags: FlagDef[]): Map<string, FlagDef> {
   return index;
 }
 
-function resolveFlagName(raw: string): { flag: FlagDef; value?: string } | null {
-  // "--key=value"
-  const eqIndex = raw.indexOf("=");
-  if (eqIndex !== -1) {
-    const name = raw.slice(0, eqIndex);
-    const value = raw.slice(eqIndex + 1);
-    const allFlags = buildFlagIndex([...GLOBAL_FLAGS]); // we'll rebuild in context
-    // We'll handle = syntax in the main parse loop with proper index
-    return null; // handled inline
-  }
-  return null; // handled inline
-}
-
 function parseArgs(
   rawArgs: string[],
   commands: Map<string, CommandDef>,
@@ -282,7 +271,7 @@ export async function runCLI(rawArgs: string[], commands: Map<string, CommandDef
 
   // Handle --version globally
   if (result.flags["version"]) {
-    console.log("gai v0.2.0");
+    console.log(`gai v${VERSION}`);
     return 0;
   }
 

src/clipboard.ts

@@ -19,7 +19,9 @@ export async function copyToClipboard(text: string): Promise<boolean> {
 			proc.stdin.end();
 			const exitCode = await proc.exited;
 			if (exitCode === 0) return true;
-        } catch {}
+		} catch {
+			// Try next command
+		}
 	}
 
 	return false;

src/commands/changelog.ts

@@ -62,7 +62,7 @@ export async function handleChangelog(args: ParsedArgs): Promise<number> {
   }
 
   try {
-    const callbacks: StreamCallbacks = tty ? {
+    const callbacks: StreamCallbacks | undefined = tty ? {
       onToken: (token) => process.stdout.write(token),
     } : undefined;
 

src/commands/commit.ts

@@ -1,4 +1,3 @@
-import * as readline from "node:readline";
 import {
   isGitRepo,
   getRepoRoot,
@@ -7,30 +6,22 @@ import {
   getStagedDiff,
   getRecentCommits,
   stageFiles,
+  applyFileSelection,
   commit,
 } from "../git";
 import { selectFiles } from "../selector";
-import { BACK } from "../menu";
+import { BACK, SKIP_WAIT } from "../menu";
 import { collectProjectContext } from "../context";
 import { buildPrompt, SYSTEM_PROMPT } from "../prompt";
 import { generateCommitMessage } from "../ai";
 import { copyToClipboard } from "../clipboard";
 import { BOLD, GREEN, YELLOW, CYAN, RED, DIM, RESET } from "../terminal";
 import { isStdinTTY } from "../tty";
+import { ask, editLine } from "../tty-input";
 import type { Config, CommitResult, StreamCallbacks } from "../types";
 import { loadConfig } from "../config";
 import type { ParsedArgs } from "../cli";
 
-function ask(question: string): Promise<string> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
 function printCommitResult(result: CommitResult, msg: string) {
   console.log(`\n  ${GREEN()}${BOLD()}✔ Committed successfully!${RESET()}`);
   const id = result.branch && result.hash
@@ -50,6 +41,19 @@ function printCommitResult(result: CommitResult, msg: string) {
   if (parts.length > 0) console.log(`    ${parts.join(", ")}`);
 }
 
+function printSelectionResult(result: { staged: string[]; unstaged: string[] }) {
+  const parts: string[] = [];
+  if (result.staged.length > 0) {
+    parts.push(`${GREEN()}staged ${result.staged.length}${RESET()}`);
+  }
+  if (result.unstaged.length > 0) {
+    parts.push(`${YELLOW()}unstaged ${result.unstaged.length}${RESET()}`);
+  }
+  if (parts.length > 0) {
+    console.log(`  Updated staging area: ${parts.join(", ")}`);
+  }
+}
+
 async function confirmCommit(message: string): Promise<"y" | "n" | "e"> {
   console.log(`\n  ${BOLD()}Generated commit message:${RESET()}`);
   console.log(`    ${GREEN()}${message}${RESET()}\n`);
@@ -61,99 +65,8 @@ async function confirmCommit(message: string): Promise<"y" | "n" | "e"> {
 }
 
 async function editMessage(current: string): Promise<string | null> {
-  if (!isStdinTTY()) return null;
   process.stdout.write(`  ${DIM()}Edit message (Enter to confirm, Esc to abort):${RESET()}\n`);
-
-  const savedRaw = process.stdin.isRaw;
-  process.stdin.setRawMode(true);
-  process.stdin.resume();
-
-  let buffer = current;
-  let cursor = current.length;
-
-  function render() {
-    process.stdout.write("\x1b[2K\r  > " + buffer);
-    if (cursor < buffer.length) {
-      process.stdout.write(`\x1b[${buffer.length - cursor}D`);
-    }
-  }
-
-  process.stdout.write("  > ");
-  process.stdout.write(buffer);
-
-  return new Promise((resolve) => {
-    let escapeBuf = "";
-
-    process.stdin.on("data", (data: Buffer) => {
-      const key = data.toString();
-
-      if (key === "\x03") {
-        process.stdin.setRawMode(savedRaw === true);
-        process.stdin.pause();
-        process.stdin.removeAllListeners("data");
-        process.stdout.write("\n");
-        resolve(null);
-        return;
-      }
-
-      if (key === "\x1b" || key.startsWith("\x1b[")) {
-        escapeBuf = key;
-        if (key.length >= 3) { handleSeq(key); escapeBuf = ""; }
-        return;
-      }
-
-      if (escapeBuf) {
-        escapeBuf += key;
-        if (/^[A-Za-z~]$/.test(key)) { handleSeq(escapeBuf); escapeBuf = ""; }
-        else if (escapeBuf.length > 8) escapeBuf = "";
-        return;
-      }
-
-      if (key === "\r") {
-        process.stdin.setRawMode(savedRaw === true);
-        process.stdin.pause();
-        process.stdin.removeAllListeners("data");
-        process.stdout.write("\n");
-        const result = buffer.trim();
-        resolve(result || null);
-        return;
-      }
-
-      if (key === "\x7f") {
-        if (cursor > 0) {
-          buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
-          cursor--;
-          render();
-        }
-        return;
-      }
-
-      if (key === "\x01") { if (cursor > 0) { process.stdout.write(`\x1b[${cursor}D`); cursor = 0; } return; }
-      if (key === "\x05") { if (cursor < buffer.length) { process.stdout.write(`\x1b[${buffer.length - cursor}C`); cursor = buffer.length; } return; }
-      if (key === "\x0b") { buffer = buffer.slice(0, cursor); render(); return; }
-      if (key === "\x15") { buffer = buffer.slice(cursor); cursor = 0; render(); return; }
-
-      if (key.charCodeAt(0) >= 32 && key.charCodeAt(0) < 127) {
-        buffer = buffer.slice(0, cursor) + key + buffer.slice(cursor);
-        cursor++;
-        render();
-      }
-    });
-
-    function handleSeq(seq: string) {
-      if (seq === "\x1b[D" || seq === "\x1bOD") {
-        if (cursor > 0) { cursor--; process.stdout.write("\x1b[D"); }
-      } else if (seq === "\x1b[C" || seq === "\x1bOC") {
-        if (cursor < buffer.length) { cursor++; process.stdout.write("\x1b[C"); }
-      } else if (seq === "\x1b[H" || seq === "\x1b[1~" || seq === "\x1bOH") {
-        if (cursor > 0) { process.stdout.write(`\x1b[${cursor}D`); cursor = 0; }
-      } else if (seq === "\x1b[F" || seq === "\x1b[4~" || seq === "\x1bOF") {
-        if (cursor < buffer.length) { process.stdout.write(`\x1b[${buffer.length - cursor}C`); cursor = buffer.length; }
-      } else if (seq === "\x1b[3~") {
-        if (cursor < buffer.length) { buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1); render(); }
-      }
-    }
-  });
+  return editLine(current);
 }
 
 export async function handleCommit(args: ParsedArgs): Promise<number> {
@@ -173,16 +86,22 @@ export async function handleCommit(args: ParsedArgs): Promise<number> {
     const stagedFiles = await getStagedFiles();
     const unstagedFiles = await getUnstagedFiles();
 
-    if (stagedFiles.length === 0 && !amend) {
-      if (autoMode && unstagedFiles.length > 0) {
+    if (!amend && stagedFiles.length === 0 && unstagedFiles.length === 0) {
+      console.error(`\n  ${RED()}Error: Nothing to commit.${RESET()}\n`);
+      return 1;
+    }
+
+    if (!amend && autoMode && unstagedFiles.length > 0) {
       await stageFiles(unstagedFiles.map((f) => f.path));
       console.log(`  ${GREEN()}Auto-staged ${unstagedFiles.length} file(s).${RESET()}`);
-      } else if (unstagedFiles.length > 0) {
+    } else if (!amend) {
+      if (isStdinTTY()) {
+        const selected = await selectFiles(stagedFiles, unstagedFiles);
+        if (selected === BACK) return SKIP_WAIT as unknown as number;
+        printSelectionResult(await applyFileSelection(stagedFiles, unstagedFiles, selected));
+      } else if (stagedFiles.length === 0 && unstagedFiles.length > 0) {
         console.error(`\n  ${RED()}Error: No staged changes. Use -a to auto-stage, or stage files manually.${RESET()}\n`);
         return 1;
-      } else {
-        console.error(`\n  ${RED()}Error: Nothing to commit.${RESET()}\n`);
-        return 1;
       }
     }
 
@@ -215,18 +134,13 @@ export async function handleCommit(args: ParsedArgs): Promise<number> {
     return 0;
   }
 
-  if (unstagedFiles.length > 0) {
-    if (autoMode) {
+  if (autoMode && unstagedFiles.length > 0) {
     await stageFiles(unstagedFiles.map((f) => f.path));
     console.log(`  ${GREEN()}Auto-staged ${unstagedFiles.length} file(s).${RESET()}`);
   } else {
     const selected = await selectFiles(stagedFiles, unstagedFiles);
-      if (selected === BACK) return 0;
-      if (selected.length > 0) {
-        await stageFiles(selected);
-        console.log(`  ${GREEN()}Staged ${selected.length} file(s).${RESET()}`);
-      }
-    }
+    if (selected === BACK) return SKIP_WAIT as unknown as number;
+    printSelectionResult(await applyFileSelection(stagedFiles, unstagedFiles, selected));
   }
 
   const diff = await getStagedDiff();

src/commands/config.ts

@@ -1,6 +1,8 @@
 import { loadConfig, saveConfig } from "../config";
-import { BOLD, GREEN, YELLOW, CYAN, RED, DIM, RESET } from "../terminal";
+import { BOLD, GREEN, YELLOW, CYAN, RED, DIM, RESET, hideCursor, showCursor, clearLine, moveUp, visibleLength } from "../terminal";
 import { isStdinTTY } from "../tty";
+import { SKIP_WAIT } from "../menu";
+import { editLine } from "../tty-input";
 import type { Config } from "../types";
 import type { ParsedArgs } from "../cli";
 
@@ -65,18 +67,6 @@ const CONFIG_FIELDS: ConfigField[] = [
   },
 ];
 
-function visibleLength(value: string) {
-  return value.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-
-function clearLine() {
-  process.stdout.write("\r\x1b[2K");
-}
-
-function moveUp(lines: number) {
-  if (lines > 0) process.stdout.write(`\x1b[${lines}A`);
-}
-
 function renderConfigPage(
   config: Config,
   cursor: number,
@@ -150,29 +140,29 @@ async function interactiveConfig(): Promise<"done" | "back"> {
 
   if (wasRaw !== true) process.stdin.setRawMode(true);
   process.stdin.resume();
-  process.stdout.write("\x1b[?25l");
+  hideCursor();
 
   const render = () => {
     moveUp(renderedCursorRow);
     renderedLines = renderConfigPage(config, cursor, renderedLines, status, editState);
     renderedCursorRow = editState ? 4 + cursor : 0;
-    process.stdout.write(editState ? "\x1b[?25h" : "\x1b[?25l");
+    editState ? showCursor() : hideCursor();
   };
 
   render();
 
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const finish = (value: "done" | "back") => {
+      process.stdin.removeListener("data", onData);
       process.stdin.setRawMode(wasRaw === true);
       process.stdin.pause();
-      process.stdin.removeListener("data", onData);
       moveUp(renderedCursorRow);
       for (let i = 0; i < renderedLines; i++) {
         clearLine();
         process.stdout.write("\n");
       }
       moveUp(renderedLines);
-      process.stdout.write("\x1b[?25h");
+      showCursor();
       resolve(value);
     };
 
@@ -323,7 +313,7 @@ export async function handleConfig(args: ParsedArgs): Promise<number> {
   // gai config (no args) → interactive
   if (positional.length === 0) {
     const result = await interactiveConfig();
-    return result === "back" ? 0 : 0;
+    return result === "back" ? (SKIP_WAIT as unknown as number) : 0;
   }
 
   console.error(`\n  ${RED()}Error: Unknown config subcommand: ${positional[0]}${RESET()}`);

src/commands/explain.ts

@@ -1,8 +1,6 @@
 import { loadConfig } from "../config";
-import { isGitRepo, getStagedDiff, getUnstagedFiles, getRepoRoot, stageFiles } from "../git";
-import { selectFiles } from "../selector";
-import { BACK } from "../menu";
-import { collectProjectContext } from "../context";
+import { collectDiff } from "../diff-source";
+import { BACK, SKIP_WAIT } from "../menu";
 import { EXPLAIN_SYSTEM_PROMPT, buildExplainPrompt } from "../prompt";
 import { callAI } from "../ai";
 import { BOLD, GREEN, RED, DIM, RESET, CYAN } from "../terminal";
@@ -19,85 +17,33 @@ export async function handleExplain(args: ParsedArgs): Promise<number> {
 	}
 
 	const unstaged = args.flags["unstaged"] as boolean;
-  const staged = args.flags["staged"] as boolean;
 	const verbose = args.flags["verbose"] as boolean;
 
-  // Determine which diff to explain
 	let diff: string;
 	let sourceLabel: string;
+	let contextPrefix: string;
 
-  if (unstaged) {
-    if (!(await isGitRepo())) {
-      console.error(`\n  ${RED()}Error: Not a git repository.${RESET()}\n`);
-      return 1;
-    }
 	try {
-      diff = (await Bun.$`git diff`.quiet().text()).trim();
-    } catch {
-      diff = "";
-    }
-    sourceLabel = "unstaged changes";
-  } else {
-    // Default: staged changes (or piped)
-    if (isStdinTTY()) {
-      if (!(await isGitRepo())) {
-        console.error(`\n  ${RED()}Error: Not a git repository.${RESET()}\n`);
+		const result = await collectDiff({ unstaged, includeProjectContext: true });
+		if (result.back) return SKIP_WAIT as unknown as number;
+		diff = result.diff;
+		sourceLabel = result.sourceLabel;
+		contextPrefix = result.contextPrefix;
+	} catch (err) {
+		console.error(`\n  ${RED()}Error: ${err instanceof Error ? err.message : err}${RESET()}\n`);
 		return 1;
 	}
-      diff = await getStagedDiff();
-      sourceLabel = "staged changes";
-
-      // If no staged changes, offer to stage unstaged files
-      if (!diff) {
-        const unstagedFiles = await getUnstagedFiles();
-        if (unstagedFiles.length > 0) {
-          const selected = await selectFiles([], unstagedFiles);
-          if (selected === BACK) return 0;
-          if (selected.length > 0) {
-            await stageFiles(selected);
-            console.log(`  ${GREEN()}Staged ${selected.length} file(s).${RESET()}`);
-            diff = await getStagedDiff();
-          }
-        }
-      }
-    } else {
-      // Read from pipe
-      const chunks: Buffer[] = [];
-      for await (const chunk of process.stdin) {
-        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-      }
-      diff = Buffer.concat(chunks).toString("utf-8").trim();
-      sourceLabel = "piped input";
-    }
-  }
 
 	if (!diff) {
 		console.log(`  ${DIM()}No ${sourceLabel} to explain.${RESET()}`);
 		return 0;
 	}
 
-  if (args.flags["verbose"]) {
+	if (verbose) {
 		console.log(`  ${DIM()}Explaining ${sourceLabel} (${diff.length} bytes)${RESET()}`);
 	}
 
-  const MAX_DIFF_SIZE = 15000;
-  const truncatedDiff = diff.length > MAX_DIFF_SIZE
-    ? diff.substring(0, MAX_DIFF_SIZE) + "\n... (truncated)"
-    : diff;
-
-  // Collect project context for better explanations
-  let contextPrefix = "";
-  try {
-    if (await isGitRepo()) {
-      const repoRoot = await getRepoRoot();
-      const ctx = await collectProjectContext(repoRoot);
-      if (ctx.packageDescription) {
-        contextPrefix = `Project: ${ctx.packageDescription}\n\n`;
-      }
-    }
-  } catch {}
-
-  const userPrompt = contextPrefix + buildExplainPrompt(truncatedDiff);
+	const userPrompt = contextPrefix + buildExplainPrompt(diff);
 
 	if (verbose) {
 		console.log(`  ${DIM()}Model: ${config.model} | API: ${config.apiBase}${RESET()}`);
@@ -109,7 +55,7 @@ export async function handleExplain(args: ParsedArgs): Promise<number> {
 	}
 
 	try {
-    const callbacks: StreamCallbacks = tty ? {
+		const callbacks: StreamCallbacks | undefined = tty ? {
 			onToken: (token) => process.stdout.write(token),
 		} : undefined;
 
@@ -117,7 +63,6 @@ export async function handleExplain(args: ParsedArgs): Promise<number> {
 		if (callbacks) {
 			process.stdout.write("\n");
 		} else {
-      // Non-TTY: print the result directly
 			process.stdout.write(explanation + "\n");
 		}
 	} catch (err) {

src/commands/pr.ts

@@ -1,10 +1,9 @@
-import * as readline from "node:readline";
 import { loadConfig } from "../config";
 import { isGitRepo, getRepoRoot } from "../git";
 import { collectProjectContext } from "../context";
 import { PR_SYSTEM_PROMPT, buildPRPrompt } from "../prompt";
 import { generatePRMessage } from "../ai";
-import { BACK, selectOne } from "../menu";
+import { BACK, SKIP_WAIT, selectOne } from "../menu";
 import {
   getDefaultBranch,
   getBranchName,
@@ -19,19 +18,10 @@ import {
 import type { Platform } from "../pr";
 import { BOLD, GREEN, YELLOW, CYAN, RED, DIM, RESET } from "../terminal";
 import { isStdinTTY } from "../tty";
+import { ask } from "../tty-input";
 import { copyToClipboard } from "../clipboard";
 import type { ParsedArgs } from "../cli";
 
-function ask(question: string): Promise<string> {
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
 async function selectPlatform(hostname: string): Promise<Platform | null | typeof BACK> {
   if (!isStdinTTY()) {
     console.error(`\n  ${RED()}Error: Platform selection requires a TTY.${RESET()}\n`);
@@ -68,7 +58,7 @@ export async function handlePR(args: ParsedArgs): Promise<number> {
   if (!platform) {
     const hostname = (await getRemoteHostname()) || "unknown";
     const chosen = await selectPlatform(hostname);
-    if (chosen === BACK) return 0;
+    if (chosen === BACK) return SKIP_WAIT as unknown as number;
     if (!chosen) {
       console.log("  Aborted.");
       return 0;
@@ -98,7 +88,7 @@ export async function handlePR(args: ParsedArgs): Promise<number> {
       items: [{ label: "Back", value: "back" as const }],
     });
     if (choice === null) process.exit(0);
-    return 0;
+    return SKIP_WAIT as unknown as number;
   }
 
   console.log(`  ${commits.length} commit${commits.length > 1 ? "s" : ""} on this branch`);

src/commands/review.ts

@@ -1,8 +1,6 @@
 import { loadConfig } from "../config";
-import { isGitRepo, getStagedDiff, getUnstagedFiles, getRepoRoot, stageFiles } from "../git";
-import { selectFiles } from "../selector";
-import { BACK } from "../menu";
-import { collectProjectContext } from "../context";
+import { collectDiff } from "../diff-source";
+import { BACK, SKIP_WAIT } from "../menu";
 import { REVIEW_SYSTEM_PROMPT, buildReviewPrompt } from "../prompt";
 import { callAI } from "../ai";
 import { BOLD, GREEN, YELLOW, RED, DIM, RESET, CYAN } from "../terminal";
@@ -29,70 +27,25 @@ export async function handleReview(args: ParsedArgs): Promise<number> {
 
 	let diff: string;
 	let sourceLabel: string;
+	let contextPrefix: string;
 
-  if (unstaged) {
-    if (!(await isGitRepo())) {
-      console.error(`\n  ${RED()}Error: Not a git repository.${RESET()}\n`);
-      return 1;
-    }
 	try {
-      diff = (await Bun.$`git diff`.quiet().text()).trim();
-    } catch {
-      diff = "";
-    }
-    sourceLabel = "unstaged changes";
-  } else if (!isStdinTTY()) {
-    const chunks: Buffer[] = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-    }
-    diff = Buffer.concat(chunks).toString("utf-8").trim();
-    sourceLabel = "piped input";
-  } else {
-    if (!(await isGitRepo())) {
-      console.error(`\n  ${RED()}Error: Not a git repository.${RESET()}\n`);
+		const result = await collectDiff({ unstaged, includeProjectContext: true });
+		if (result.back) return SKIP_WAIT as unknown as number;
+		diff = result.diff;
+		sourceLabel = result.sourceLabel;
+		contextPrefix = result.contextPrefix;
+	} catch (err) {
+		console.error(`\n  ${RED()}Error: ${err instanceof Error ? err.message : err}${RESET()}\n`);
 		return 1;
 	}
-    diff = await getStagedDiff();
-    sourceLabel = "staged changes";
-
-    // If no staged changes, offer to stage unstaged files
-    if (!diff) {
-      const unstagedFiles = await getUnstagedFiles();
-      if (unstagedFiles.length > 0) {
-        const selected = await selectFiles([], unstagedFiles);
-        if (selected === BACK) return 0;
-        if (selected.length > 0) {
-          await stageFiles(selected);
-          console.log(`  ${GREEN()}Staged ${selected.length} file(s).${RESET()}`);
-          diff = await getStagedDiff();
-        }
-      }
-    }
-  }
 
 	if (!diff) {
 		console.log(`  ${DIM()}No ${sourceLabel} to review.${RESET()}`);
 		return 0;
 	}
 
-  const MAX_DIFF_SIZE = 15000;
-  const truncatedDiff = diff.length > MAX_DIFF_SIZE
-    ? diff.substring(0, MAX_DIFF_SIZE) + "\n... (truncated)"
-    : diff;
-
-  let contextPrefix = "";
-  try {
-    if (await isGitRepo()) {
-      const repoRoot = await getRepoRoot();
-      const ctx = await collectProjectContext(repoRoot);
-      if (ctx.packageDescription) {
-        contextPrefix = `Project: ${ctx.packageDescription}\n\n`;
-      }
-    }
-  } catch {}
-
-  const userPrompt = contextPrefix + buildReviewPrompt(truncatedDiff, strictnessFlag);
+	const userPrompt = contextPrefix + buildReviewPrompt(diff, strictnessFlag);
 
 	const strictnessLabel = strictnessFlag === "strict"
 		? `${RED()}strict${RESET()}`
@@ -110,7 +63,7 @@ export async function handleReview(args: ParsedArgs): Promise<number> {
 	}
 
 	try {
-    const callbacks: StreamCallbacks = tty ? {
+		const callbacks: StreamCallbacks | undefined = tty ? {
 			onToken: (token) => process.stdout.write(token),
 		} : undefined;
 

src/commands/suggest.ts

@@ -1,7 +1,6 @@
 import { loadConfig } from "../config";
-import { isGitRepo, getStagedDiff, getUnstagedFiles, stageFiles } from "../git";
-import { selectFiles } from "../selector";
-import { BACK } from "../menu";
+import { collectDiff } from "../diff-source";
+import { BACK, SKIP_WAIT } from "../menu";
 import {
 	SUGGEST_SYSTEM_PROMPT,
 	buildSuggestBranchPrompt,
@@ -30,43 +29,17 @@ export async function handleSuggest(args: ParsedArgs): Promise<number> {
 		return 1;
 	}
 
-  // Get diff (staged, or unstaged if --unstaged, or piped)
+	const unstaged = args.flags["unstaged"] as boolean;
+
 	let diff: string;
-  if (!isStdinTTY()) {
-    const chunks: Buffer[] = [];
-    for await (const chunk of process.stdin) {
-      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
-    }
-    diff = Buffer.concat(chunks).toString("utf-8").trim();
-  } else {
-    if (!(await isGitRepo())) {
-      console.error(`\n  ${RED()}Error: Not a git repository.${RESET()}\n`);
-      return 1;
-    }
 
-    if (args.flags["unstaged"] as boolean) {
 	try {
-        diff = (await Bun.$`git diff`.quiet().text()).trim();
-      } catch {
-        diff = "";
-      }
-    } else {
-      diff = await getStagedDiff();
-
-      // If no staged changes, offer to stage unstaged files
-      if (!diff) {
-        const unstagedFiles = await getUnstagedFiles();
-        if (unstagedFiles.length > 0) {
-          const selected = await selectFiles([], unstagedFiles);
-          if (selected === BACK) return 0;
-          if (selected.length > 0) {
-            await stageFiles(selected);
-            console.log(`  ${GREEN()}Staged ${selected.length} file(s).${RESET()}`);
-            diff = await getStagedDiff();
-          }
-        }
-      }
-    }
+		const result = await collectDiff({ unstaged, includeProjectContext: false });
+		if (result.back) return SKIP_WAIT as unknown as number;
+		diff = result.diff;
+	} catch (err) {
+		console.error(`\n  ${RED()}Error: ${err instanceof Error ? err.message : err}${RESET()}\n`);
+		return 1;
 	}
 
 	if (!diff) {
@@ -74,20 +47,14 @@ export async function handleSuggest(args: ParsedArgs): Promise<number> {
 		return 0;
 	}
 
-  const MAX_DIFF_SIZE = 15000;
-  const truncatedDiff = diff.length > MAX_DIFF_SIZE
-    ? diff.substring(0, MAX_DIFF_SIZE) + "\n... (truncated)"
-    : diff;
-
 	if (verbose) {
 		console.log(`  ${DIM()}Model: ${config.model} | API: ${config.apiBase}${RESET()}`);
 	}
 
 	if (mode === "branch") {
-    return handleSuggestBranch(config, truncatedDiff);
-  } else {
-    return handleSuggestType(config, truncatedDiff);
+		return handleSuggestBranch(config, diff);
 	}
+	return handleSuggestType(config, diff);
 }
 
 async function handleSuggestBranch(config: Config, diff: string): Promise<number> {

src/diff-source.ts

@@ -0,0 +1,98 @@
+// Shared diff-source helper used by explain, review, suggest, and commit commands.
+// Handles the common pattern of: detecting where to get a diff from
+// (staged, unstaged, or piped stdin), optionally presenting an interactive
+// file selector, applying truncation, and collecting project context.
+
+import { isGitRepo, getStagedFiles, getStagedDiff, getUnstagedFiles, getRepoRoot, applyFileSelection } from "./git";
+import { selectFiles } from "./selector";
+import { BACK } from "./menu";
+import { collectProjectContext } from "./context";
+import { isStdinTTY } from "./tty";
+
+export interface DiffSourceResult {
+	diff: string;
+	sourceLabel: string;
+	contextPrefix: string;
+	back: boolean;
+}
+
+const MAX_DIFF_SIZE = 15000;
+
+/**
+ * Collect a diff from the appropriate source based on flags and TTY state.
+ *
+ * - If `unstaged` is true: uses `git diff` (unstaged changes)
+ * - If TTY (interactive): shows file selector for staged/unstaged, then uses staged diff
+ * - If piped (non-TTY): reads diff from stdin
+ *
+ * Returns the diff, a human-readable source label, project context prefix,
+ * and whether the user pressed back.
+ */
+export async function collectDiff(opts: {
+	unstaged?: boolean;
+	includeProjectContext?: boolean;
+} = {}): Promise<DiffSourceResult> {
+	const { unstaged = false, includeProjectContext = true } = opts;
+
+	let diff: string;
+	let sourceLabel: string;
+	let contextPrefix = "";
+
+	if (unstaged) {
+		if (!(await isGitRepo())) {
+			throw new Error("Not a git repository.");
+		}
+		try {
+			diff = (await Bun.$`git diff`.quiet().text()).trim();
+		} catch {
+			diff = "";
+		}
+		sourceLabel = "unstaged changes";
+	} else if (isStdinTTY()) {
+		if (!(await isGitRepo())) {
+			throw new Error("Not a git repository.");
+		}
+		const stagedFiles = await getStagedFiles();
+		const unstagedFiles = await getUnstagedFiles();
+		sourceLabel = "selected changes";
+
+		if (stagedFiles.length > 0 || unstagedFiles.length > 0) {
+			const selected = await selectFiles(stagedFiles, unstagedFiles);
+			if (selected === BACK) {
+				return { diff: "", sourceLabel, contextPrefix, back: true };
+			}
+			await applyFileSelection(stagedFiles, unstagedFiles, selected);
+		}
+		diff = await getStagedDiff();
+	} else {
+		// Piped input (non-TTY)
+		const chunks: Buffer[] = [];
+		for await (const chunk of process.stdin) {
+			chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+		}
+		diff = Buffer.concat(chunks).toString("utf-8").trim();
+		sourceLabel = "piped input";
+	}
+
+	// Truncate large diffs
+	if (diff.length > MAX_DIFF_SIZE) {
+		diff = diff.substring(0, MAX_DIFF_SIZE) + "\n... (truncated)";
+	}
+
+	// Collect project context for better AI responses
+	if (includeProjectContext && diff) {
+		try {
+			if (await isGitRepo()) {
+				const repoRoot = await getRepoRoot();
+				const ctx = await collectProjectContext(repoRoot);
+				if (ctx.packageDescription) {
+					contextPrefix = `Project: ${ctx.packageDescription}\n\n`;
+				}
+			}
+		} catch {
+			// Context collection is best-effort
+		}
+	}
+
+	return { diff, sourceLabel, contextPrefix, back: false };
+}

src/git.ts

@@ -37,12 +37,17 @@ function parseNameStatus(output: string): FileEntry[] {
   return output
     .trim()
     .split("\n")
-    .filter(Boolean)
+    .filter((line) => line.trim())
     .map((line) => {
-      const [status, ...pathParts] = line.split("\t");
-      const path = pathParts[pathParts.length - 1] ?? "";
-      return { path, status: status!, label: statusToLabel(status!) };
-    });
+      const tabIdx = line.indexOf("\t");
+      if (tabIdx === -1) return null;
+      const status = line.slice(0, tabIdx);
+      // Join path parts back (paths may contain escaped chars but not tabs)
+      const path = line.slice(tabIdx + 1);
+      if (!status || !path) return null;
+      return { path, status, label: statusToLabel(status) };
+    })
+    .filter((entry): entry is FileEntry => entry !== null);
 }
 
 export async function getStagedFiles(): Promise<FileEntry[]> {
@@ -98,6 +103,33 @@ export async function stageFiles(paths: string[]): Promise<void> {
   await Bun.$`git add -- ${paths}`;
 }
 
+export async function unstageFiles(paths: string[]): Promise<void> {
+  if (paths.length === 0) return;
+  try {
+    await Bun.$`git restore --staged -- ${paths}`.quiet();
+  } catch {
+    await Bun.$`git rm --cached -r -- ${paths}`.quiet();
+  }
+}
+
+export async function applyFileSelection(
+  stagedFiles: FileEntry[],
+  unstagedFiles: FileEntry[],
+  selectedPaths: string[],
+): Promise<{ staged: string[]; unstaged: string[] }> {
+  const selected = new Set(selectedPaths);
+  const stagedPaths = new Set(stagedFiles.map((file) => file.path));
+  const unstagedPaths = new Set(unstagedFiles.map((file) => file.path));
+
+  const toUnstage = [...stagedPaths].filter((path) => !selected.has(path));
+  const toStage = [...selected].filter((path) => unstagedPaths.has(path));
+
+  await unstageFiles(toUnstage);
+  await stageFiles(toStage);
+
+  return { staged: toStage, unstaged: toUnstage };
+}
+
 export async function commit(
   message: string,
 ): Promise<{ branch: string; hash: string; files: number; insertions: number; deletions: number }> {
@@ -113,7 +145,7 @@ export async function commit(
     throw new Error(stderr.trim() || `git commit failed (exit code ${exitCode})`);
   }
 
-  const branchHashMatch = stdout.match(/\[(\S+)\s+([0-9a-f]{7,})/);
+  const branchHashMatch = stdout.match(/\[(\S+)\s+(?:\(root-commit\)\s+)?([0-9a-f]{7,})/);
   const branch = branchHashMatch?.[1] ?? "";
   const hash = branchHashMatch?.[2] ?? "";
 

src/menu.ts

@@ -1,4 +1,4 @@
-import { BOLD, GREEN, CYAN, DIM, RESET } from "./terminal";
+import { BOLD, GREEN, CYAN, DIM, RESET, hideCursor, showCursor, clearLine, moveUp, visibleLength, padRight } from "./terminal";
 import { isStdinTTY } from "./tty";
 
 const UP = "\x1b[A";
@@ -15,6 +15,10 @@ const BACKSPACE = "\x7f";
 export const BACK = Symbol("prompt-back");
 export type PromptBack = typeof BACK;
 
+// Sent by command handlers to skip the "Press Enter to return" wait in the
+// interactive menu when the user explicitly backed out of a sub-menu.
+export const SKIP_WAIT = Symbol("skip-wait");
+
 export interface Choice<T> {
   label: string;
   value: T;
@@ -39,22 +43,7 @@ interface MultiPromptOptions<T> extends BasePromptOptions {
   doneLabel?: string;
 }
 
-function hideCursor() { process.stdout.write("\x1b[?25l"); }
-function showCursor() { process.stdout.write("\x1b[?25h"); }
-
-function moveUp(lines: number) {
-  if (lines > 0) process.stdout.write(`\x1b[${lines}A`);
-}
-
-function clearLine() {
-  process.stdout.write("\r\x1b[2K");
-}
-
-function visibleLength(value: string) {
-  return value.replace(/\x1b\[[0-9;]*m/g, "").length;
-}
-
-function padLabel(label: string, width: number) {
+function padLabel(label: string, width: number): string {
   return label + " ".repeat(Math.max(1, width - visibleLength(label)));
 }
 
@@ -88,7 +77,8 @@ function clearPrompt(lines: number) {
   moveUp(lines);
 }
 
-function normalizeKey(key: string, escapeBuf: string) {
+function normalizeKey(key: string, escapeBuf: string): { action: string | null; escapeBuf: string } {
+  // Single-chunk actions
   if (key === UP || key === ALT_UP) return { action: "up", escapeBuf: "" };
   if (key === DOWN || key === ALT_DOWN) return { action: "down", escapeBuf: "" };
   if (key === LEFT || key === ALT_LEFT || key === BACKSPACE) return { action: "back", escapeBuf: "" };
@@ -96,14 +86,20 @@ function normalizeKey(key: string, escapeBuf: string) {
   if (key === ENTER) return { action: "enter", escapeBuf: "" };
   if (key === CTRL_C) return { action: "cancel", escapeBuf: "" };
 
-  if (key === "\x1b" || key.startsWith("\x1b[")) return { action: null, escapeBuf: key };
+  // Start of an escape sequence — buffer it
+  if (key === "\x1b" || key.startsWith("\x1b[") || key.startsWith("\x1bO")) {
+    return { action: null, escapeBuf: key };
+  }
 
+  // Continue buffering an escape sequence
   if (escapeBuf) {
     const next = escapeBuf + key;
     if (next === UP || next === ALT_UP) return { action: "up", escapeBuf: "" };
     if (next === DOWN || next === ALT_DOWN) return { action: "down", escapeBuf: "" };
     if (next === LEFT || next === ALT_LEFT) return { action: "back", escapeBuf: "" };
-    return { action: null, escapeBuf: /^[A-Za-z~]$/.test(key) || next.length > 8 ? "" : next };
+    // If key is a terminal character (letter/digit/~) or buffer got too long, flush
+    if (/^[A-Za-z~0-9]$/.test(key) || next.length > 10) return { action: null, escapeBuf: "" };
+    return { action: null, escapeBuf: next };
   }
 
   return { action: null, escapeBuf: "" };
@@ -164,15 +160,25 @@ export async function selectOne<T>(
   const render = () => {
     renderedLines = renderPrompt(createLines(options, "single", cursor), renderedLines);
   };
-  render();
 
-  return new Promise((resolve) => {
-    const finish = (value: T | null | PromptBack) => {
+  const cleanup = () => {
     process.stdin.setRawMode(wasRaw === true);
     process.stdin.pause();
-      process.stdin.removeListener("data", onData);
     clearPrompt(renderedLines);
     showCursor();
+  };
+
+  try {
+    render();
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+
+  return new Promise((resolve, reject) => {
+    const finish = (value: T | null | PromptBack) => {
+      process.stdin.removeListener("data", onData);
+      cleanup();
       if (value === null && options.cancelMessage) {
         process.stdout.write(`  ${options.cancelMessage}\n`);
       }
@@ -180,6 +186,7 @@ export async function selectOne<T>(
     };
 
     const onData = (data: Buffer) => {
+      try {
         const result = normalizeKey(data.toString(), escapeBuf);
         escapeBuf = result.escapeBuf;
 
@@ -190,6 +197,10 @@ export async function selectOne<T>(
         else if (result.action === "space" || result.action === "enter") {
           finish(options.items[cursor]!.value);
         }
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
     };
 
     process.stdin.on("data", onData);
@@ -221,6 +232,7 @@ export async function selectMany<T>(
     if (!options.selectAllLabel) return;
     items[0]!.selected = items.slice(1).every((item) => item.selected);
   };
+  syncSelectAll();
 
   const toggle = (index: number) => {
     const item = items[index]!;
@@ -238,15 +250,25 @@ export async function selectMany<T>(
       renderedLines,
     );
   };
-  render();
 
-  return new Promise((resolve) => {
-    const finish = (value: T[] | null | PromptBack) => {
+  const cleanup = () => {
     process.stdin.setRawMode(wasRaw === true);
     process.stdin.pause();
-      process.stdin.removeListener("data", onData);
     clearPrompt(renderedLines);
     showCursor();
+  };
+
+  try {
+    render();
+  } catch (err) {
+    cleanup();
+    throw err;
+  }
+
+  return new Promise((resolve, reject) => {
+    const finish = (value: T[] | null | PromptBack) => {
+      process.stdin.removeListener("data", onData);
+      cleanup();
       if (value === null && options.cancelMessage) {
         process.stdout.write(`  ${options.cancelMessage}\n`);
       }
@@ -254,6 +276,7 @@ export async function selectMany<T>(
     };
 
     const onData = (data: Buffer) => {
+      try {
         const result = normalizeKey(data.toString(), escapeBuf);
         escapeBuf = result.escapeBuf;
 
@@ -265,6 +288,10 @@ export async function selectMany<T>(
         else if (result.action === "enter") {
           finish(items.filter((item) => item.selected && item.value !== null).map((item) => item.value as T));
         }
+      } catch (err) {
+        cleanup();
+        reject(err);
+      }
     };
 
     process.stdin.on("data", onData);

src/pr.ts

@@ -124,6 +124,36 @@ export async function getRemoteHostname(): Promise<string | null> {
   }
 }
 
+const PLATFORM_CLI: Record<Platform, {
+  bin: string;
+  args: (title: string, body: string, base: string, draft: boolean) => string[];
+  label: string;
+}> = {
+  github: {
+    bin: "gh",
+    args: (title, body, base, draft) => {
+      const a = ["pr", "create", "--title", title, "--body", body, "--base", base];
+      if (draft) a.push("--draft");
+      return a;
+    },
+    label: "gh pr create",
+  },
+  gitlab: {
+    bin: "glab",
+    args: (title, body, base, draft) => {
+      const a = ["mr", "create", "--title", title, "--description", body, "--target-branch", base];
+      if (draft) a.push("--draft");
+      return a;
+    },
+    label: "glab mr create",
+  },
+  gitea: {
+    bin: "tea",
+    args: (title, body, base, _draft) => ["pulls", "create", "--title", title, "--description", body, "--base", base],
+    label: "tea pulls create",
+  },
+};
+
 export async function createPR(
   platform: Platform,
   title: string,
@@ -131,20 +161,8 @@ export async function createPR(
   base: string,
   draft: boolean,
 ): Promise<string> {
-  if (platform === "github") {
-    const args = [
-      "pr",
-      "create",
-      "--title",
-      title,
-      "--body",
-      body,
-      "--base",
-      base,
-    ];
-    if (draft) args.push("--draft");
-
-    const proc = Bun.spawn(["gh", ...args], {
+  const cli = PLATFORM_CLI[platform];
+  const proc = Bun.spawn([cli.bin, ...cli.args(title, body, base, draft)], {
     stdout: "pipe",
     stderr: "pipe",
   });
@@ -153,69 +171,7 @@ export async function createPR(
   const stderr = await new Response(proc.stderr).text();
 
   if (exitCode !== 0) {
-      throw new Error(
-        stderr.trim() || `gh pr create failed (exit code ${exitCode})`,
-      );
-    }
-
-    const match = stdout.match(/(https?:\/\/[^\s]+)/);
-    return match?.[1] ?? stdout.trim();
-  }
-
-  if (platform === "gitlab") {
-    const args = [
-      "mr",
-      "create",
-      "--title",
-      title,
-      "--description",
-      body,
-      "--target-branch",
-      base,
-    ];
-    if (draft) args.push("--draft");
-
-    const proc = Bun.spawn(["glab", ...args], {
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-    const exitCode = await proc.exited;
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-
-    if (exitCode !== 0) {
-      throw new Error(
-        stderr.trim() || `glab mr create failed (exit code ${exitCode})`,
-      );
-    }
-
-    const match = stdout.match(/(https?:\/\/[^\s]+)/);
-    return match?.[1] ?? stdout.trim();
-  }
-
-  const args = [
-    "pulls",
-    "create",
-    "--title",
-    title,
-    "--description",
-    body,
-    "--base",
-    base,
-  ];
-
-  const proc = Bun.spawn(["tea", ...args], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  const exitCode = await proc.exited;
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-
-  if (exitCode !== 0) {
-    throw new Error(
-      stderr.trim() || `tea pulls create failed (exit code ${exitCode})`,
-    );
+    throw new Error(stderr.trim() || `${cli.label} failed (exit code ${exitCode})`);
   }
 
   const match = stdout.match(/(https?:\/\/[^\s]+)/);

src/selector.ts

@@ -1,44 +1,54 @@
 import type { FileEntry } from "./types";
-import { BOLD, GREEN, YELLOW, RESET } from "./terminal";
 import { isStdinTTY } from "./tty";
 import { BACK, selectMany } from "./menu";
 import type { PromptBack } from "./menu";
 
+function mergeFiles(stagedFiles: FileEntry[], unstagedFiles: FileEntry[]) {
+  const files = new Map<string, FileEntry & { staged: boolean; unstaged: boolean }>();
+
+  for (const file of stagedFiles) {
+    files.set(file.path, { ...file, staged: true, unstaged: false });
+  }
+
+  for (const file of unstagedFiles) {
+    const existing = files.get(file.path);
+    if (existing) {
+      existing.unstaged = true;
+      existing.label = existing.label === file.label
+        ? existing.label
+        : `${existing.label}, ${file.label}`;
+    } else {
+      files.set(file.path, { ...file, staged: false, unstaged: true });
+    }
+  }
+
+  return [...files.values()];
+}
+
 export async function selectFiles(
   stagedFiles: FileEntry[],
   unstagedFiles: FileEntry[],
 ): Promise<string[] | PromptBack> {
-  if (unstagedFiles.length === 0) return [];
+  const files = mergeFiles(stagedFiles, unstagedFiles);
+  if (files.length === 0) return [];
 
-  if (stagedFiles.length > 0) {
-    process.stdout.write(`\n  ${BOLD()}Staged files (will be included):${RESET()}\n`);
-    for (const f of stagedFiles) {
-      process.stdout.write(`    ${GREEN()}✓${RESET()} ${f.path} (${YELLOW()}${f.label}${RESET()})\n`);
-    }
-  }
-
-  if (!isStdinTTY()) return [];
+  if (!isStdinTTY()) return stagedFiles.map((file) => file.path);
 
   const selected = await selectMany({
-    title: "Select files to stage",
-    subtitle: `${unstagedFiles.length} unstaged file${unstagedFiles.length > 1 ? "s" : ""} available`,
+    title: "Select files for this action",
+    subtitle: `${stagedFiles.length} staged, ${unstagedFiles.length} unstaged`,
     selectAllLabel: "Select all",
     cancelMessage: "Aborted.",
-    items: unstagedFiles.map((f) => ({
+    items: files.map((f) => ({
       label: f.path,
       value: f.path,
       description: f.label,
+      selected: f.staged,
     })),
   });
 
   if (selected === null) process.exit(1);
   if (selected === BACK) return BACK;
 
-  if (selected.length > 0) {
-    process.stdout.write(
-      `  ${GREEN()}Staged ${selected.length} file(s):${RESET()} ${selected.join(", ")}\n`,
-    );
-  }
-
   return selected;
 }

src/terminal.ts

@@ -1,8 +1,10 @@
-// Terminal styling utilities.
+// Terminal styling and rendering utilities.
 // Respects NO_COLOR convention, --no-color flag, and TTY detection.
 
 import { isStdoutTTY } from "./tty";
 
+// ── Color support ─────────────────────────────────────────────────────
+
 let _enabled: boolean | null = null;
 
 export function setColorEnabled(enabled: boolean): void {
@@ -14,11 +16,19 @@ export function isColorEnabled(): boolean {
 
 	// Respect NO_COLOR: https://no-color.org/
 	if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "") {
+		_enabled = false;
 		return false;
 	}
-  if (!isStdoutTTY()) return false;
-  if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") return true;
+	if (!isStdoutTTY()) {
+		_enabled = false;
+		return false;
+	}
+	if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0") {
+		_enabled = true;
+		return true;
+	}
 
+	_enabled = true;
 	return true;
 }
 
@@ -33,3 +43,35 @@ export const YELLOW = () => s("\x1b[33m");
 export const CYAN = () => s("\x1b[36m");
 export const RED = () => s("\x1b[31m");
 export const RESET = () => s("\x1b[0m");
+
+// ── Terminal rendering helpers ───────────────────────────────────────
+
+export function hideCursor(): void {
+	process.stdout.write("\x1b[?25l");
+}
+
+export function showCursor(): void {
+	process.stdout.write("\x1b[?25h");
+}
+
+export function clearLine(): void {
+	process.stdout.write("\r\x1b[2K");
+}
+
+export function moveUp(lines: number): void {
+	if (lines > 0) process.stdout.write(`\x1b[${lines}A`);
+}
+
+export function clearScreen(): void {
+	process.stdout.write("\x1b[2J\x1b[H");
+}
+
+/** Calculate visible length of a string, stripping ANSI escape codes. */
+export function visibleLength(value: string): number {
+	return value.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+
+/** Pad a string to the given visible width (accounting for ANSI codes). */
+export function padRight(value: string, width: number): string {
+	return value + " ".repeat(Math.max(0, width - visibleLength(value)));
+}

src/tty-input.ts

@@ -0,0 +1,163 @@
+// Shared TTY input utilities used by command handlers.
+// Provides a simple line-input "ask" helper and a reusable inline
+// raw-mode text editor (used by both commit message editing and
+// interactive config editing).
+
+import * as readline from "node:readline";
+import { isStdinTTY } from "./tty";
+
+// ── Simple line input (cooked mode) ──────────────────────────────────
+
+export function ask(question: string): Promise<string> {
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+	return new Promise((resolve) => {
+		rl.question(question, (answer) => {
+			rl.close();
+			resolve(answer.trim());
+		});
+	});
+}
+
+// ── Inline raw-mode editor ────────────────────────────────────────────
+//
+// Provides a simple line editor that runs in raw mode and supports:
+//   - Left/Right arrows, Home/End for cursor movement
+//   - Backspace / Delete for character removal
+//   - Ctrl+A (beginning), Ctrl+E (end), Ctrl+K (kill to end), Ctrl+U (kill to start)
+//   - Enter to confirm, Ctrl+C / Esc to cancel
+//
+// Returns the edited string, or null if the user cancelled.
+
+export interface EditResult {
+	value: string | null;
+}
+
+export async function editLine(initial: string): Promise<string | null> {
+	if (!isStdinTTY()) return null;
+
+	const savedRaw = process.stdin.isRaw;
+	process.stdin.setRawMode(true);
+	process.stdin.resume();
+
+	let buffer = initial;
+	let cursor = initial.length;
+
+	function render() {
+		// Clear line, move to start, show prompt + buffer, then reposition cursor
+		process.stdout.write("\r\x1b[2K  > " + buffer);
+		if (cursor < buffer.length) {
+			process.stdout.write(`\x1b[${buffer.length - cursor}D`);
+		}
+	}
+
+	process.stdout.write("  > " + buffer);
+
+	return new Promise((resolve) => {
+		let escapeBuf = "";
+
+		function finish(value: string | null) {
+			process.stdin.setRawMode(savedRaw === true);
+			process.stdin.pause();
+			process.stdin.removeAllListeners("data");
+			process.stdout.write("\n");
+			resolve(value);
+		}
+
+		function handleEscapeSeq(seq: string) {
+			switch (seq) {
+				case "\x1b[D": case "\x1bOD": // Left
+					if (cursor > 0) { cursor--; process.stdout.write("\x1b[D"); }
+					break;
+				case "\x1b[C": case "\x1bOC": // Right
+					if (cursor < buffer.length) { cursor++; process.stdout.write("\x1b[C"); }
+					break;
+				case "\x1b[H": case "\x1b[1~": case "\x1bOH": // Home
+					if (cursor > 0) { process.stdout.write(`\x1b[${cursor}D`); cursor = 0; }
+					break;
+				case "\x1b[F": case "\x1b[4~": case "\x1bOF": // End
+					if (cursor < buffer.length) { process.stdout.write(`\x1b[${buffer.length - cursor}C`); cursor = buffer.length; }
+					break;
+				case "\x1b[3~": // Delete
+					if (cursor < buffer.length) { buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1); render(); }
+					break;
+			}
+		}
+
+		process.stdin.on("data", (data: Buffer) => {
+			const key = data.toString();
+
+			// Ctrl+C
+			if (key === "\x03") { finish(null); return; }
+			// Esc
+			if (key === "\x1b") {
+				if (escapeBuf) {
+					// Already buffering — check if this completes a sequence
+					const next = escapeBuf + key;
+					if (/^(\x1b\[[0-9;]*[A-Za-z~]|\x1bO[A-Z])$/.test(next)) {
+						handleEscapeSeq(next);
+						escapeBuf = "";
+					} else {
+						// Treat lone Esc as cancel
+						finish(null);
+					}
+					return;
+				}
+				escapeBuf = "\x1b";
+				return;
+			}
+
+			// Buffering an escape sequence
+			if (escapeBuf) {
+				escapeBuf += key;
+				// Check if this completes a valid sequence
+				if (/^(\x1b\[[0-9;]*[A-Za-z~]|\x1bO[A-Z])$/.test(escapeBuf)) {
+					handleEscapeSeq(escapeBuf);
+					escapeBuf = "";
+				} else if (escapeBuf.length > 10 || /^[A-Za-z~]$/.test(key)) {
+					// Timeout or terminator that didn't match — discard
+					escapeBuf = "";
+				}
+				return;
+			}
+
+			// Enter
+			if (key === "\r" || key === "\n") {
+				const result = buffer.trim();
+				finish(result || null);
+				return;
+			}
+
+			// Backspace
+			if (key === "\x7f") {
+				if (cursor > 0) {
+					buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
+					cursor--;
+					render();
+				}
+				return;
+			}
+
+			// Ctrl+A → beginning of line
+			if (key === "\x01") {
+				if (cursor > 0) { process.stdout.write(`\x1b[${cursor}D`); cursor = 0; }
+				return;
+			}
+			// Ctrl+E → end of line
+			if (key === "\x05") {
+				if (cursor < buffer.length) { process.stdout.write(`\x1b[${buffer.length - cursor}C`); cursor = buffer.length; }
+				return;
+			}
+			// Ctrl+K → kill to end
+			if (key === "\x0b") { buffer = buffer.slice(0, cursor); render(); return; }
+			// Ctrl+U → kill to start
+			if (key === "\x15") { buffer = buffer.slice(cursor); cursor = 0; render(); return; }
+
+			// Printable characters
+			if (key >= " " && key !== "\x7f") {
+				buffer = buffer.slice(0, cursor) + key + buffer.slice(cursor);
+				cursor += key.length;
+				render();
+			}
+		});
+	});
+}

src/tty.ts

@@ -23,14 +23,13 @@ export function isStdinTTY(): boolean {
 }
 
 export function isStdoutTTY(): boolean {
-  // Use a heuristic for stdout — check if we're in a terminal
-  if (process.env.TERM || process.env.TERM_PROGRAM) return true;
-  if (process.env.NO_COLOR) return false;
-  // Try fstat on fd 1 (stdout)
+  // Primary check: fstat on fd 1 (stdout) — most reliable
   try {
     const stat = fstatSync(1);
     return stat.isCharacterDevice();
   } catch {
+    // Fall back to TERM heuristic only when fstat fails
+    if (process.env.TERM || process.env.TERM_PROGRAM) return true;
     return false;
   }
 }

src/types.ts

@@ -12,22 +12,21 @@ export interface FileEntry {
   label: string;
 }
 
-export interface ProjectContext {
+export interface BaseContext {
   readme: string | null;
   packageDescription: string | null;
   structure: string | null;
-  recentCommits: string[];
   diff: string;
 }
 
-export interface PRContext {
-  readme: string | null;
-  packageDescription: string | null;
-  structure: string | null;
+export interface ProjectContext extends BaseContext {
+  recentCommits: string[];
+}
+
+export interface PRContext extends BaseContext {
   branchName: string;
   baseBranch: string;
   branchCommits: string[];
-  diff: string;
 }
 
 export interface CommitResult {