@claude-transcripts/cli 0.3.3 → 0.4.0

package/README.md

@@ -109,6 +109,7 @@ upgrades in place: it's idempotent and keeps your history.
 | `doctor [options]` | Smoke-test the write/read/search path end-to-end |
 | `hook [action] [options]` | The Claude Code hook, and its registration |
 | `statusline [action] [options]` | The Claude Code statusline indicator (recording / off), and its registration |
+| `completions <shell>` | Print a shell completion script to eval or source from your shell's rc |
 
 **Global options** (every command)
 

package/dist/{app-vcj5svg7.js → app-a93wk4rv.js}

@@ -1,13 +1,13 @@
 // @bun
 import {
-  CLI_SPEC,
   isFlag,
   cliCommandsByGroup,
   cliUsage,
   cliArgHint,
   cliArgLabel,
+  CLI_SPEC,
   COMMANDS
-} from "./cli-d7a6svha.js";
+} from "./cli-fptk6bgx.js";
 import {
   __toESM,
   __commonJS,

package/dist/{cli-d7a6svha.js → cli-fptk6bgx.js}

@@ -1,4 +1,385 @@
 // @bun
+// packages/shared/src/model/cli-project.ts
+var isFlag = (a) => a.name.startsWith("--");
+function cliArgType(a) {
+  if (a.type)
+    return a.type;
+  if (a.choices)
+    return "string";
+  if (typeof a.default === "number")
+    return "number";
+  if (typeof a.default === "string")
+    return "string";
+  return isFlag(a) ? "boolean" : "string";
+}
+function cliCommandsByGroup(spec) {
+  return spec.groups.map((g) => ({ ...g, commands: spec.commands.filter((c) => c.group === g.key) })).filter((g) => g.commands.length > 0);
+}
+function cliUsage(cmd) {
+  const parts = (cmd.args ?? []).filter((a) => !isFlag(a)).map((a) => a.required ? `<${a.name}>` : `[${a.name}]`);
+  const hasFlags = (cmd.args ?? []).some(isFlag);
+  return [cmd.name, ...parts, ...hasFlags ? ["[options]"] : []].join(" ");
+}
+function cliArgHint(a) {
+  const bits = [];
+  if (a.choices)
+    bits.push(a.choices.join(" | "));
+  if (a.default !== undefined && a.default !== false)
+    bits.push(`default ${a.default}`);
+  return bits.length ? `(${bits.join("; ")})` : "";
+}
+function cliArgLabel(a) {
+  if (!isFlag(a))
+    return a.name;
+  switch (cliArgType(a)) {
+    case "number":
+      return `${a.name} <n>`;
+    case "string":
+      return `${a.name} <value>`;
+    default:
+      return a.name;
+  }
+}
+function validateCliArgs(spec, cmd, parsed) {
+  const errors = [];
+  const args = cmd.args ?? [];
+  const known = new Map;
+  for (const a of [...spec.globalArgs, ...args])
+    if (isFlag(a))
+      known.set(a.name.slice(2), a);
+  for (const [key, value] of Object.entries(parsed.options)) {
+    const def = known.get(key);
+    if (!def) {
+      errors.push(`unknown option --${key}`);
+      continue;
+    }
+    errors.push(...checkValue(def, value));
+  }
+  const positionals = args.filter((a) => !isFlag(a));
+  positionals.forEach((def, i) => {
+    const value = parsed.positionals[i];
+    if (value === undefined) {
+      if (def.required)
+        errors.push(`missing required argument <${def.name}>`);
+      return;
+    }
+    errors.push(...checkValue(def, value));
+  });
+  return errors;
+}
+function checkValue(def, value) {
+  const type = cliArgType(def);
+  const label = isFlag(def) ? def.name : `<${def.name}>`;
+  if (typeof value === "boolean") {
+    return type === "boolean" ? [] : [`${label} needs a value`];
+  }
+  if (type === "boolean")
+    return [`${label} takes no value (got "${value}")`];
+  if (def.choices && !def.choices.includes(value)) {
+    return [`${label} must be one of ${def.choices.join(" | ")} (got "${value}")`];
+  }
+  if (type === "number" && !/^-?\d+(\.\d+)?$/.test(value)) {
+    return [`${label} must be a number (got "${value}")`];
+  }
+  return [];
+}
+var COMPLETION_SHELLS = ["bash", "zsh", "fish"];
+function toCompletions(spec, shell, bin) {
+  const model = completionModel(spec);
+  const fn = `_${bin.replace(/[^A-Za-z0-9]/g, "_")}`;
+  switch (shell) {
+    case "bash":
+      return bashCompletions(model, bin, fn);
+    case "zsh":
+      return zshCompletions(model, bin, fn);
+    case "fish":
+      return fishCompletions(model, bin, fn);
+  }
+}
+var takesValue = (a) => isFlag(a) && cliArgType(a) !== "boolean";
+function completionModel(spec) {
+  const flags = new Map;
+  const valued = [];
+  const choices = [];
+  for (const c of spec.commands) {
+    const all = [...(c.args ?? []).filter(isFlag), ...spec.globalArgs.filter(isFlag)];
+    flags.set(c.name, all);
+    for (const a of all) {
+      if (!takesValue(a))
+        continue;
+      valued.push(`${c.name}:${a.name}`);
+      if (a.choices)
+        choices.push([`${c.name}:${a.name}`, a.choices]);
+    }
+    (c.args ?? []).filter((a) => !isFlag(a)).forEach((a, i) => {
+      if (a.choices)
+        choices.push([`${c.name}:${i + 1}`, a.choices]);
+    });
+  }
+  const leading = spec.globalArgs.filter((a) => isFlag(a) && !takesValue(a));
+  return { commands: spec.commands, leading, flags, valued, choices };
+}
+var header = (shell, bin) => `# ${shell} completion for ${bin} \u2014 generated from CLI_SPEC; do not edit.`;
+var names = (args) => args.map((a) => a.name).join(" ");
+function bashCompletions(m, bin, fn) {
+  const flagCases = m.commands.map((c) => `    ${c.name}) printf '%s' "${names(m.flags.get(c.name) ?? [])}" ;;`).join(`
+`);
+  const choiceCases = m.choices.map(([k, v]) => `    ${k}) printf '%s' "${v.join(" ")}" ;;`).join(`
+`);
+  return `${header("bash", bin)}
+# Load it with:  eval "$(${bin} completions bash)"   (e.g. in ~/.bashrc)
+# Works with bash 3.2+ and needs no bash-completion package.
+
+# Does flag \`cmd:--flag\` ($1) take a value?
+${fn}_valued() {
+  case "$1" in
+    ${m.valued.length ? `${m.valued.join("|")}) return 0 ;;` : ""}
+  esac
+  return 1
+}
+
+# The values to offer for $1 \u2014 \`cmd:--flag\` or \`cmd:<positional index>\`.
+${fn}_choices() {
+  case "$1" in
+${choiceCases}
+  esac
+}
+
+# The flags command $1 accepts, its own and the global ones.
+${fn}_flags() {
+  case "$1" in
+${flagCases}
+  esac
+}
+
+${fn}() {
+  # Split the line ourselves: COMP_WORDS also breaks at ":" and "=", which would turn
+  # \`--webapi http://x\` into four words and miscount everything after it.
+  local line="\${COMP_LINE:0:COMP_POINT}" cur cmd npos=0 flag="" i n w
+  local -a words
+  read -ra words <<<"$line"
+  [[ $line == *[[:space:]] || \${#words[@]} -eq 0 ]] && words+=("")
+  n=\${#words[@]}
+  cur="\${words[n - 1]}"
+  COMPREPLY=()
+  # \`--flag=value\`: bash replaces only the part after "=", which compgen can't target.
+  [[ $cur == *=* ]] && return 0
+
+  if ((n == 2)); then
+    if [[ $cur == -* ]]; then
+      COMPREPLY=($(compgen -W "${names(m.leading)}" -- "$cur"))
+    else
+      COMPREPLY=($(compgen -W "${m.commands.map((c) => c.name).join(" ")}" -- "$cur"))
+    fi
+    return 0
+  fi
+
+  # Only the first word is the command; after a leading flag nothing runs a command.
+  cmd="\${words[1]}"
+  [[ $cmd == -* ]] && return 0
+
+  # Count positionals the way parseFlags reads them: a bare --flag takes the next word
+  # as its value unless that word is another --flag.
+  for ((i = 2; i < n - 1; i++)); do
+    w="\${words[i]}"
+    if [[ -n $flag && $w != --* ]]; then
+      flag=""
+      continue
+    fi
+    flag=""
+    case "$w" in
+      --*=*) ;;
+      --*) flag="$w" ;;
+      *) npos=$((npos + 1)) ;;
+    esac
+  done
+
+  if [[ -n $flag ]] && ${fn}_valued "$cmd:$flag"; then
+    COMPREPLY=($(compgen -W "$(${fn}_choices "$cmd:$flag")" -- "$cur"))
+  elif [[ $cur == -* || -n $flag ]]; then
+    COMPREPLY=($(compgen -W "$(${fn}_flags "$cmd")" -- "$cur"))
+  else
+    COMPREPLY=($(compgen -W "$(${fn}_choices "$cmd:$((npos + 1))")" -- "$cur"))
+  fi
+  return 0
+}
+
+complete -F ${fn} ${bin}
+`;
+}
+var zshQ = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+var zshEntry = (name, desc = "") => zshQ(`${name.replace(/:/g, "\\:")}:${desc}`);
+function zshCompletions(m, bin, fn) {
+  const entries = (args) => args.map((a) => zshEntry(a.name, a.description)).join(" ");
+  const flagCases = m.commands.map((c) => `    (${c.name}) reply=(${entries(m.flags.get(c.name) ?? [])}) ;;`).join(`
+`);
+  const choiceCases = m.choices.map(([k, v]) => `    (${k}) reply=(${v.join(" ")}) ;;`).join(`
+`);
+  const commands = m.commands.map((c) => `    ${zshEntry(c.name, c.summary)}`).join(`
+`);
+  return `#compdef ${bin}
+${header("zsh", bin)}
+# Load it with:  eval "$(${bin} completions zsh)"   (after compinit, e.g. in ~/.zshrc)
+# or save it as \`${fn}\` in a directory on $fpath.
+
+${fn}_valued() {
+  case $1 in
+    (${m.valued.join("|")}) return 0 ;;
+  esac
+  return 1
+}
+
+${fn}_choices() {
+  reply=()
+  case $1 in
+${choiceCases}
+  esac
+}
+
+${fn}_flags() {
+  reply=()
+  case $1 in
+${flagCases}
+  esac
+}
+
+${fn}() {
+  local cur=$words[CURRENT] cmd=$words[2] npos=0 flag="" i w
+  local -a reply commands
+  commands=(
+${commands}
+  )
+
+  if (( CURRENT == 2 )); then
+    if [[ $cur == -* ]]; then
+      reply=(${entries(m.leading)})
+      _describe -t options option reply
+    else
+      _describe -t commands '${bin} command' commands
+    fi
+    return
+  fi
+
+  # Only the first word is the command; after a leading flag nothing runs a command.
+  [[ $cmd == -* ]] && return 1
+
+  # Count positionals the way parseFlags reads them: a bare --flag takes the next word
+  # as its value unless that word is another --flag.
+  for (( i = 3; i < CURRENT; i++ )); do
+    w=$words[i]
+    if [[ -n $flag && $w != --* ]]; then
+      flag=""
+      continue
+    fi
+    flag=""
+    case $w in
+      (--*=*) ;;
+      (--*) flag=$w ;;
+      (*) npos=$((npos + 1)) ;;
+    esac
+  done
+
+  if [[ $cur == --*=* ]]; then
+    flag=\${cur%%=*}
+    ${fn}_valued "$cmd:$flag" || return 1
+    compset -P '*='
+  fi
+
+  if [[ -n $flag ]] && ${fn}_valued "$cmd:$flag"; then
+    ${fn}_choices "$cmd:$flag"
+    if (( $#reply )); then compadd -a reply; else _message value; fi
+  elif [[ $cur == -* || -n $flag ]]; then
+    ${fn}_flags "$cmd"
+    _describe -t options option reply
+  else
+    ${fn}_choices "$cmd:$((npos + 1))"
+    (( $#reply )) && compadd -a reply
+  fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+  ${fn} "$@"
+else
+  compdef ${fn} ${bin}
+fi
+`;
+}
+var fishQ = (s) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+function fishCompletions(m, bin, fn) {
+  const c = `complete -c ${bin}`;
+  const flagLine = (cond, a, cmd) => {
+    const parts = [c, "-n", fishQ(cond), "-l", a.name.slice(2)];
+    if (takesValue(a)) {
+      const ch = m.choices.find(([k]) => k === `${cmd}:${a.name}`)?.[1];
+      parts.push(ch ? `-xa ${fishQ(ch.join(" "))}` : "-x");
+    }
+    if (a.description)
+      parts.push("-d", fishQ(a.description));
+    return parts.join(" ");
+  };
+  const lines = [];
+  for (const cmd of m.commands) {
+    lines.push(`${c} -n ${fn}_at_command -a ${cmd.name} -d ${fishQ(cmd.summary)}`);
+  }
+  for (const a of m.leading)
+    lines.push(flagLine(`${fn}_at_command`, a));
+  for (const cmd of m.commands) {
+    lines.push("");
+    for (const [key, values] of m.choices) {
+      const [name, pos] = key.split(":");
+      if (name !== cmd.name || pos?.startsWith("--"))
+        continue;
+      lines.push(`${c} -n '${fn}_at_positional ${cmd.name} ${pos}' -a ${fishQ(values.join(" "))}`);
+    }
+    for (const a of m.flags.get(cmd.name) ?? [])
+      lines.push(flagLine(`${fn}_in ${cmd.name}`, a, cmd.name));
+  }
+  return `${header("fish", bin)}
+# Load it with:  ${bin} completions fish | source   (e.g. in ~/.config/fish/config.fish)
+# or save it as ~/.config/fish/completions/${bin}.fish
+
+# Nothing typed after the binary yet: the next word is the command.
+function ${fn}_at_command
+    test (count (commandline -opc)) -eq 1
+end
+
+# The command (the first word, and only the first) is $argv[1].
+function ${fn}_in
+    set -l t (commandline -opc)
+    test "$t[2]" = "$argv[1]"
+end
+
+# The word being completed is positional $argv[2] of command $argv[1]. Positionals
+# are counted the way parseFlags reads them: a bare --flag takes the next word as its
+# value unless that word is another --flag.
+function ${fn}_at_positional
+    set -l t (commandline -opc)
+    test "$t[2]" = "$argv[1]"; or return 1
+    set -l npos 0
+    set -l flag 0
+    for w in $t[3..-1]
+        if test $flag = 1; and not string match -q -- '--*' $w
+            set flag 0
+            continue
+        end
+        set flag 0
+        switch $w
+            case '--*=*'
+            case '--*'
+                set flag 1
+            case '*'
+                set npos (math $npos + 1)
+        end
+    end
+    test $flag = 0; and test $npos -eq (math $argv[2] - 1)
+end
+
+${c} -f
+${lines.join(`
+`)}
+`;
+}
+
 // packages/shared/src/model/cli.ts
 var WEBAPI = {
   name: "--webapi",
@@ -318,95 +699,24 @@ var CLI_SPEC = {
         { name: "--dry-run", description: "with `install`: show the change without writing" }
       ],
       examples: ["statusline install", "statusline status"]
+    },
+    {
+      name: "completions",
+      group: "admin",
+      summary: "Print a shell completion script to eval or source from your shell's rc",
+      args: [
+        {
+          name: "shell",
+          required: true,
+          choices: COMPLETION_SHELLS,
+          description: "the shell to complete for"
+        }
+      ],
+      examples: ["completions bash", "completions fish | source"]
     }
   ]
 };
 
-// packages/shared/src/model/cli-project.ts
-var isFlag = (a) => a.name.startsWith("--");
-function cliArgType(a) {
-  if (a.type)
-    return a.type;
-  if (a.choices)
-    return "string";
-  if (typeof a.default === "number")
-    return "number";
-  if (typeof a.default === "string")
-    return "string";
-  return isFlag(a) ? "boolean" : "string";
-}
-function cliCommandsByGroup(spec) {
-  return spec.groups.map((g) => ({ ...g, commands: spec.commands.filter((c) => c.group === g.key) })).filter((g) => g.commands.length > 0);
-}
-function cliUsage(cmd) {
-  const parts = (cmd.args ?? []).filter((a) => !isFlag(a)).map((a) => a.required ? `<${a.name}>` : `[${a.name}]`);
-  const hasFlags = (cmd.args ?? []).some(isFlag);
-  return [cmd.name, ...parts, ...hasFlags ? ["[options]"] : []].join(" ");
-}
-function cliArgHint(a) {
-  const bits = [];
-  if (a.choices)
-    bits.push(a.choices.join(" | "));
-  if (a.default !== undefined && a.default !== false)
-    bits.push(`default ${a.default}`);
-  return bits.length ? `(${bits.join("; ")})` : "";
-}
-function cliArgLabel(a) {
-  if (!isFlag(a))
-    return a.name;
-  switch (cliArgType(a)) {
-    case "number":
-      return `${a.name} <n>`;
-    case "string":
-      return `${a.name} <value>`;
-    default:
-      return a.name;
-  }
-}
-function validateCliArgs(spec, cmd, parsed) {
-  const errors = [];
-  const args = cmd.args ?? [];
-  const known = new Map;
-  for (const a of [...spec.globalArgs, ...args])
-    if (isFlag(a))
-      known.set(a.name.slice(2), a);
-  for (const [key, value] of Object.entries(parsed.options)) {
-    const def = known.get(key);
-    if (!def) {
-      errors.push(`unknown option --${key}`);
-      continue;
-    }
-    errors.push(...checkValue(def, value));
-  }
-  const positionals = args.filter((a) => !isFlag(a));
-  positionals.forEach((def, i) => {
-    const value = parsed.positionals[i];
-    if (value === undefined) {
-      if (def.required)
-        errors.push(`missing required argument <${def.name}>`);
-      return;
-    }
-    errors.push(...checkValue(def, value));
-  });
-  return errors;
-}
-function checkValue(def, value) {
-  const type = cliArgType(def);
-  const label = isFlag(def) ? def.name : `<${def.name}>`;
-  if (typeof value === "boolean") {
-    return type === "boolean" ? [] : [`${label} needs a value`];
-  }
-  if (type === "boolean")
-    return [`${label} takes no value (got "${value}")`];
-  if (def.choices && !def.choices.includes(value)) {
-    return [`${label} must be one of ${def.choices.join(" | ")} (got "${value}")`];
-  }
-  if (type === "number" && !/^-?\d+(\.\d+)?$/.test(value)) {
-    return [`${label} must be a number (got "${value}")`];
-  }
-  return [];
-}
-
 // packages/shared/src/couch-url.ts
 var DEFAULT_COUCHDB_HOST = "127.0.0.1";
 var DEFAULT_COUCHDB_PORT = "7652";
@@ -2854,6 +3164,14 @@ async function runBackfill(argv) {
   return failed > 0 ? 1 : 0;
 }
 
+// packages/cli/src/commands/completions.ts
+var BIN = "claude-transcripts";
+async function runCompletions(argv) {
+  const shell = parseFlags(argv).positionals[0];
+  process.stdout.write(toCompletions(CLI_SPEC, shell, BIN));
+  return 0;
+}
+
 // packages/cli/src/commands/doctor.ts
 import { hostname as hostname2 } from "os";
 function buildTranscript(sessionId, cwd, ts) {
@@ -4912,6 +5230,7 @@ async function runImport(argv) {
 
 // packages/cli/src/commands/install.ts
 import { existsSync as existsSync8, readFileSync as readFileSync12 } from "fs";
+import { join as join9 } from "path";
 
 // packages/cli/src/lib/assets.ts
 import {
@@ -5515,8 +5834,27 @@ async function provisionGarage(env, bucket, instanceEnvPath) {
     S3_SECRET_KEY: secretKey
   });
   steps.push({ name: "garage:key", ok: true, detail: `created ${accessKey}` });
+  const stale = await removeStaleKeys(api, accessKey);
+  if (stale)
+    steps.push(stale);
   return { steps, env: next };
 }
+async function removeStaleKeys(api, keep) {
+  const list = await api("GET", "/v2/ListKeys");
+  if (!list.ok || !Array.isArray(list.json)) {
+    return { name: "garage:stale-keys", ok: false, detail: `list failed (HTTP ${list.status})` };
+  }
+  const stale = list.json.filter((k) => k?.name === KEY_NAME && typeof k.id === "string" && k.id !== keep).map((k) => k.id);
+  if (stale.length === 0)
+    return null;
+  const failed = [];
+  for (const id of stale) {
+    const del = await api("POST", `/v2/DeleteKey?id=${encodeURIComponent(id)}`);
+    if (!del.ok)
+      failed.push(`${id} (HTTP ${del.status})`);
+  }
+  return failed.length ? { name: "garage:stale-keys", ok: false, detail: `could not delete ${failed.join(", ")}` } : { name: "garage:stale-keys", ok: true, detail: `deleted ${stale.join(", ")}` };
+}
 
 // packages/cli/src/commands/statusline.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
@@ -5922,7 +6260,7 @@ async function runInstall(argv) {
 install: done.`);
   console.log(`  UI       http://127.0.0.1:${env.WEBAPI_PORT}/app`);
   console.log(`  API      http://127.0.0.1:${env.WEBAPI_PORT}/api/docs`);
-  console.log(`  data     docker volumes (survive uninstall unless --purge)`);
+  console.log(`  data     ${join9(paths.deployDir, "data")} (survives uninstall unless --purge)`);
   console.log("  remove   claude-transcripts uninstall");
   return 0;
 }
@@ -6336,15 +6674,15 @@ async function runSessions(argv) {
 // packages/cli/src/commands/setup.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname7, join as join9 } from "path";
-var REPO_ROOT = join9(import.meta.dir, "..", "..", "..", "..");
-var HOOK_DIR = join9(REPO_ROOT, "hooks");
-var HOOK_CONFIG_PATH = process.env.CT_HOOK_CONFIG ?? join9(homedir3(), ".config", "claude-transcripts", "config.json");
+import { dirname as dirname7, join as join10 } from "path";
+var REPO_ROOT = join10(import.meta.dir, "..", "..", "..", "..");
+var HOOK_DIR = join10(REPO_ROOT, "hooks");
+var HOOK_CONFIG_PATH = process.env.CT_HOOK_CONFIG ?? join10(homedir3(), ".config", "claude-transcripts", "config.json");
 var GLOBAL_SETTINGS = installPaths().claudeSettings;
-var PROJECT_SETTINGS = join9(process.cwd(), ".claude", "settings.json");
+var PROJECT_SETTINGS = join10(process.cwd(), ".claude", "settings.json");
 function loadRepoConfig() {
-  const live = join9(REPO_ROOT, "config", "config.json");
-  const template = join9(REPO_ROOT, "config", "config.template.json");
+  const live = join10(REPO_ROOT, "config", "config.json");
+  const template = join10(REPO_ROOT, "config", "config.template.json");
   return JSON.parse(readFileSync13(existsSync10(live) ? live : template, "utf8"));
 }
 function couchHeaders(auth) {
@@ -6404,7 +6742,7 @@ function readSettings3(path) {
 function globalRegistrationBlockedBy(settingsPath = GLOBAL_SETTINGS) {
   return pluginRegistration(settingsPath, readSettings3(settingsPath));
 }
-var DISPATCH_PATH = join9(HOOK_DIR, "scripts", "dispatch.ts");
+var DISPATCH_PATH = join10(HOOK_DIR, "scripts", "dispatch.ts");
 function dispatchCommand() {
   return hookLaunch(`bun run "${DISPATCH_PATH}"`);
 }
@@ -6415,7 +6753,7 @@ function isRegistered(path) {
 }
 function registerGlobal(dryRun) {
   const cmd = dispatchCommand();
-  const generated = JSON.parse(readFileSync13(join9(HOOK_DIR, "hooks", "hooks.json"), "utf8"));
+  const generated = JSON.parse(readFileSync13(join10(HOOK_DIR, "hooks", "hooks.json"), "utf8"));
   const settings = readSettings3(GLOBAL_SETTINGS);
   const hooks = settings.hooks ?? {};
   for (const [event, groups] of Object.entries(generated.hooks)) {
@@ -6655,12 +6993,30 @@ async function runTurns(argv) {
 }
 
 // packages/cli/src/commands/uninstall.ts
-import { existsSync as existsSync12, rmSync } from "fs";
+import { existsSync as existsSync12, readdirSync, rmSync } from "fs";
+import { join as join11 } from "path";
+var DATA_SUBDIR = "data";
+function removeDeployDir(deployDir, purge) {
+  if (purge) {
+    rmSync(deployDir, { recursive: true, force: true });
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync(deployDir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry !== DATA_SUBDIR)
+      rmSync(join11(deployDir, entry), { recursive: true, force: true });
+  }
+}
 async function confirmPurge(auto) {
   if (auto)
     return true;
   process.stdout.write(`
-uninstall: --purge DELETES ALL RECORDED HISTORY (CouchDB + S3 volumes).
+uninstall: --purge DELETES ALL RECORDED HISTORY (CouchDB + S3 data).
 ` + "Type 'delete my history' to confirm: ");
   const line = (await new Response(Bun.stdin.stream()).text()).trim();
   return line === "delete my history";
@@ -6673,10 +7029,11 @@ async function runUninstall(argv) {
     console.error("uninstall: not confirmed \u2014 nothing was removed.");
     return 1;
   }
-  console.log("uninstall: deregistering the hook");
+  console.log("uninstall: deregistering the hook and the statusline");
   await runHook(["uninstall"]);
+  await runStatusline(["uninstall"]);
   if (existsSync12(paths.instanceEnv)) {
-    console.log(`uninstall: stopping the stack${purge ? " and deleting volumes" : ""}`);
+    console.log("uninstall: stopping the stack");
     try {
       const env = loadOrCreateInstanceEnv(paths.instanceEnv);
       await composeDown({ paths, env, app: true }, purge);
@@ -6684,17 +7041,28 @@ async function runUninstall(argv) {
       console.warn(`uninstall: could not stop the stack (continuing): ${err.message}`);
     }
   }
-  for (const target of [paths.hookConfig, paths.instanceEnv, paths.deployDir, paths.versionFile]) {
+  const targets = [paths.instanceEnv, paths.versionFile, ...purge ? [paths.hookConfig] : []];
+  for (const target of targets) {
     try {
       rmSync(target, { recursive: true, force: true });
     } catch {}
   }
+  const dataDir = join11(paths.deployDir, DATA_SUBDIR);
+  try {
+    removeDeployDir(paths.deployDir, purge);
+  } catch (err) {
+    console.error(`uninstall: could not remove ${paths.deployDir}: ${err.message}`);
+    if (purge)
+      console.error(`uninstall: delete ${dataDir} by hand to finish the purge`);
+    return 1;
+  }
   console.log("uninstall: removed generated config and deployment assets");
   if (purge) {
     rmSync(paths.appConfig, { force: true });
     console.log("uninstall: purged history and app config");
   } else {
-    console.log(`uninstall: history kept in Docker volumes; ${paths.appConfig} left in place`);
+    console.log(`uninstall: history kept in ${dataDir}`);
+    console.log(`uninstall: ${paths.hookConfig} and ${paths.appConfig} left in place`);
     console.log("uninstall: re-run with --purge to delete the data too");
   }
   console.log(`uninstall: the binary itself is still at ${paths.binDir}/claude-transcripts`);
@@ -6718,7 +7086,8 @@ var COMMANDS = {
   doctor: runDoctor,
   sessions: runSessions,
   search: runSearch,
-  turns: runTurns
+  turns: runTurns,
+  completions: runCompletions
 };
 
-export { CLI_SPEC, isFlag, cliCommandsByGroup, cliUsage, cliArgHint, cliArgLabel, validateCliArgs, parseFlags, VERSION, COMMANDS };
+export { isFlag, cliCommandsByGroup, cliUsage, cliArgHint, cliArgLabel, validateCliArgs, CLI_SPEC, parseFlags, VERSION, COMMANDS };

package/dist/cli.js

@@ -1,19 +1,19 @@
 #!/usr/bin/env bun
 // @bun
 import {
-  CLI_SPEC,
   cliUsage,
   validateCliArgs,
+  CLI_SPEC,
   parseFlags,
   VERSION,
   COMMANDS
-} from "./cli-d7a6svha.js";
+} from "./cli-fptk6bgx.js";
 
 // packages/cli/src/cli.tsx
 var [, , first, ...rest] = process.argv;
 var USAGE_ERROR = 2;
 async function showHelp(props, stream = process.stdout) {
-  const { renderHelp } = await import("./app-vcj5svg7.js");
+  const { renderHelp } = await import("./app-a93wk4rv.js");
   renderHelp(props, stream);
 }
 var argv = first === undefined ? [] : [first, ...rest];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-transcripts/cli",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "type": "module",
   "description": "Claude Transcripts CLI — browse, search, back up, and administer your self-hosted Claude Code session history.",
   "keywords": [