@claude-transcripts/cli 0.3.3 → 0.5.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-2rqkxqp9.js}

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

package/dist/{cli-d7a6svha.js → cli-byvjee1b.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) {
@@ -3567,13 +3885,189 @@ async function runExport(argv) {
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 
+// packages/cli/src/lib/statusline.ts
+import { statSync } from "fs";
+var STALL_AFTER_MS = 60000;
+var HOOK_SILENT_AFTER_MS = 5 * 60000;
+function transcriptMtimeMs(path) {
+  if (typeof path !== "string" || !path)
+    return null;
+  try {
+    return statSync(path).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function hookSilent(lastActivityMs, transcriptMs) {
+  if (!transcriptMs || lastActivityMs <= 0)
+    return false;
+  return transcriptMs - lastActivityMs > HOOK_SILENT_AFTER_MS;
+}
+function lastWrite(ms, now) {
+  return ms > 0 ? `last write ${ago(ms, now)}` : "no write landed";
+}
+function ago(ms, now) {
+  const s = Math.max(0, Math.round((now - ms) / 1000));
+  if (s < 60)
+    return `${s}s ago`;
+  const m = Math.round(s / 60);
+  if (m < 60)
+    return `${m}m ago`;
+  return `${Math.round(m / 60)}h ago`;
+}
+function versionLabel(version = VERSION) {
+  return `ct@${version === DEV_VERSION ? "dev" : version}`;
+}
+function whereLabel(t) {
+  const host = t.couchUrl.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+  return `${t.sessionsDb}@${host}`;
+}
+function storeState(s, now) {
+  if (s.lastFailureMs > s.lastWriteMs && now - s.lastWriteMs > STALL_AFTER_MS)
+    return "failing";
+  return s.lastWriteMs > 0 ? "healthy" : "idle";
+}
+var GLYPH = { rec: "\u25CF", stalled: "\u25D0", ready: "\u25CC", off: "\u25CB" };
+function sessionLink(webapiUrl, sessionId) {
+  return webapiUrl ? `${webapiUrl.replace(/\/$/, "")}/app/sessions/${sessionId}` : null;
+}
+function renderStatusline(state, now = Date.now(), opts = {}) {
+  return formatStatusline(statuslineLine(state, now), opts);
+}
+function statuslineLine(state, now = Date.now()) {
+  const version = versionLabel(state.version);
+  if (!state.configured)
+    return { state: "off", version, note: "no instance configured" };
+  const t = state.targets;
+  if (!t)
+    return { state: "off", version, note: "not recording this session" };
+  const c = state.counts;
+  const counted = c ? { events: c.events, tools: Object.values(c.tools).reduce((a, b) => a + b, 0) } : { events: 0 };
+  const line = (state, rest) => ({
+    state,
+    version,
+    ...counted,
+    ...rest
+  });
+  const stores = t.stores?.length ? t.stores : null;
+  if (!stores) {
+    const where = whereLabel(t);
+    const age = lastWrite(t.lastWriteMs, now);
+    if (hookSilent(Math.max(t.lastWriteMs, t.lastFailureMs), state.transcriptMtimeMs)) {
+      return line("stalled", { note: "hook silent", age, where });
+    }
+    if (t.lastFailureMs > t.lastWriteMs && now - t.lastWriteMs > STALL_AFTER_MS) {
+      return line("stalled", { age, where });
+    }
+    if (t.lastWriteMs <= 0)
+      return line("ready", { age: "no write yet", where });
+    return line("rec", { age: ago(t.lastWriteMs, now), where });
+  }
+  const direct = stores.find((s) => s.kind === "direct") ?? stores[0];
+  const headline = direct ?? { label: whereLabel(t), lastWriteMs: 0, lastFailureMs: 0 };
+  const lastActivity = Math.max(...stores.flatMap((s) => [s.lastWriteMs, s.lastFailureMs]));
+  if (hookSilent(lastActivity, state.transcriptMtimeMs)) {
+    const newest = stores.reduce((a, b) => b.lastWriteMs > a.lastWriteMs ? b : a, headline);
+    return line("stalled", {
+      note: "hook silent",
+      age: lastWrite(newest.lastWriteMs, now),
+      where: newest.label
+    });
+  }
+  if (direct && storeState(direct, now) === "healthy") {
+    return line("rec", { age: ago(direct.lastWriteMs, now), where: direct.label });
+  }
+  const healthyMirrors = stores.filter((s) => s !== direct && storeState(s, now) === "healthy");
+  const first = healthyMirrors[0];
+  if (first) {
+    return line("rec", {
+      qualifier: "(mirror)",
+      age: ago(first.lastWriteMs, now),
+      where: first.label,
+      ...healthyMirrors.length > 1 ? { more: `+${healthyMirrors.length - 1}` } : {}
+    });
+  }
+  if (stores.some((s) => storeState(s, now) === "failing")) {
+    const best = Math.max(...stores.map((s) => s.lastWriteMs));
+    return line("stalled", { age: lastWrite(best, now), where: headline.label });
+  }
+  return line("ready", { age: "no write yet", where: headline.label });
+}
+var SGR = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+var STATE_COLOR = {
+  rec: SGR.green,
+  stalled: SGR.yellow,
+  ready: SGR.cyan,
+  off: SGR.dim
+};
+var SHRINK = [
+  ({ tools: _, ...l }) => l,
+  (l) => l.where ? { ...l, where: shortWhere(l.where) } : l,
+  ({ events: _, ...l }) => l,
+  ({ age: _, ...l }) => l,
+  ({ where: _, more: __, ...l }) => l
+];
+function shortWhere(where) {
+  const at = where.indexOf("@");
+  if (at > 0)
+    return where.slice(0, at);
+  const host = where.startsWith("[") ? where.slice(0, where.indexOf("]") + 1) : where.split(":")[0];
+  if (!host || host.startsWith("[") || /^\d+(\.\d+){3}$/.test(host))
+    return host || where;
+  return host.split(".")[0] || host;
+}
+function formatStatusline(line, opts = {}) {
+  let l = line;
+  if (opts.columns && opts.columns > 0) {
+    for (const shrink of SHRINK) {
+      if ([...draw(l, {})].length <= opts.columns)
+        break;
+      l = shrink(l);
+    }
+  }
+  return draw(l, opts);
+}
+function draw(l, opts) {
+  const paint = (code, s) => opts.color ? `${code}${s}${SGR.reset}` : s;
+  const dim = (s) => paint(SGR.dim, s);
+  const color = STATE_COLOR[l.state];
+  const head = [
+    paint(color, `${GLYPH[l.state]}`),
+    l.version,
+    paint(color, l.state),
+    ...l.qualifier ? [paint(SGR.yellow, l.qualifier)] : []
+  ].join(" ");
+  const counts = l.events === undefined ? undefined : l.tools === undefined ? `${l.events} ev` : `${l.events} ev \xB7 ${l.tools} tools`;
+  const details = [
+    l.note && (l.note === "hook silent" ? paint(SGR.yellow, l.note) : l.note),
+    counts && dim(counts),
+    l.age && dim(l.age)
+  ].filter(Boolean);
+  const sep = dim(" \xB7 ");
+  let out = [head, ...details].join(sep);
+  if (l.where) {
+    const label = opts.link ? osc8(opts.link, l.where) : l.where;
+    out += `${dim(" \u2192")} ${label}${l.more ? ` ${l.more}` : ""}`;
+  }
+  return out;
+}
+function osc8(url, text) {
+  return `\x1B]8;;${url}\x1B\\${text}\x1B]8;;\x1B\\`;
+}
+
 // packages/cli/src/hook/runtime.ts
 import {
   closeSync,
   openSync,
   readFileSync as readFileSync4,
   readSync,
-  statSync,
+  statSync as statSync2,
   unlinkSync,
   writeFileSync as writeFileSync2
 } from "fs";
@@ -3960,7 +4454,7 @@ function makeChunkState(sessionId) {
         return true;
       } catch {
         try {
-          if (Date.now() - statSync(lockFile).mtimeMs > STALE_LOCK_MS) {
+          if (Date.now() - statSync2(lockFile).mtimeMs > STALE_LOCK_MS) {
             unlinkSync(lockFile);
             closeSync(openSync(lockFile, "wx"));
             return true;
@@ -3975,7 +4469,7 @@ function makeChunkState(sessionId) {
       } catch {}
     },
     readTail(path, offset) {
-      const size = statSync(path).size;
+      const size = statSync2(path).size;
       if (size <= offset)
         return "";
       const fd = openSync(path, "r");
@@ -4051,20 +4545,19 @@ function commonFields(ctx) {
 }
 
 // packages/cli/src/hook/announce.ts
-function sessionLink(webapiUrl, sessionId) {
-  return webapiUrl ? `${webapiUrl.replace(/\/$/, "")}/app/sessions/${sessionId}` : null;
-}
 function recordingBanner(targets, sessionId) {
-  const where = [`couchdb://${targets.couchUrl.replace(/^https?:\/\//, "")}/${targets.sessionsDb}`];
+  const also = [];
   if (targets.bucket)
-    where.push(`s3://${targets.bucket}`);
+    also.push(`s3://${targets.bucket}`);
   if (targets.mirrors.length) {
-    where.push(`mirrors: ${targets.mirrors.map(hostOf).join(", ")}`);
+    also.push(`mirrors: ${targets.mirrors.map(hostOf).join(", ")}`);
   }
+  const head = `\u25CF Claude Transcripts recording \u2192 ${whereLabel(targets)}${also.length ? ` (+ ${also.join(", ")})` : ""}`;
   const link = sessionLink(targets.webapiUrl, sessionId);
-  return `Claude Transcripts \u2014 recording to ${where.join(" + ")}${link ? ` \xB7 ${link}` : ""}`;
+  return link ? `${head}
+  ${link}` : head;
 }
-var NOT_RECORDING_BANNER = "Claude Transcripts \u2014 not recording (no instance configured). Run `claude-transcripts install`.";
+var NOT_RECORDING_BANNER = "\u25CB Claude Transcripts not recording \u2014 no instance configured. Run `claude-transcripts install`.";
 function sessionStartEnvelope(out) {
   if (!out.systemMessage && !out.additionalContext)
     return null;
@@ -4088,7 +4581,7 @@ function emitSessionStart(out) {
 }
 
 // packages/cli/src/hook/handlers.ts
-import { readFileSync as readFileSync5, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync5, statSync as statSync3 } from "fs";
 
 // packages/cli/src/hook/recall.ts
 var FACTS_TIMEOUT_MS = 2000;
@@ -4162,7 +4655,7 @@ var seedSessionStart = async (ctx) => {
 };
 function fileSize(path) {
   try {
-    return path ? statSync2(path).size : null;
+    return path ? statSync3(path).size : null;
   } catch {
     return null;
   }
@@ -4671,7 +5164,7 @@ async function runHook(argv) {
 }
 
 // packages/cli/src/commands/import.ts
-import { existsSync as existsSync4, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, statSync as statSync4 } from "fs";
 import { join as join7 } from "path";
 var BATCH = 500;
 function num(n) {
@@ -4890,7 +5383,7 @@ async function runImport(argv) {
       const path = join7(dir, rel);
       await putStream(`/api/ingest/${sessionId}/transcript`, path, "application/x-ndjson");
       blobs++;
-      blobBytes += statSync3(path).size;
+      blobBytes += statSync4(path).size;
     }
     console.log(`  blobs    ${blobs} restored, ${formatBytes(blobBytes)}${skipped ? ` (${skipped} skipped)` : ""}`);
   } else {
@@ -4912,6 +5405,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,102 +6009,31 @@ 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 };
 }
-
-// packages/cli/src/commands/statusline.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname6 } from "path";
-
-// packages/cli/src/lib/statusline.ts
-import { statSync as statSync4 } from "fs";
-var STALL_AFTER_MS = 60000;
-var HOOK_SILENT_AFTER_MS = 5 * 60000;
-function transcriptMtimeMs(path) {
-  if (typeof path !== "string" || !path)
-    return null;
-  try {
-    return statSync4(path).mtimeMs;
-  } catch {
-    return null;
+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})` };
   }
-}
-function hookSilent(lastActivityMs, transcriptMs) {
-  if (!transcriptMs || lastActivityMs <= 0)
-    return false;
-  return transcriptMs - lastActivityMs > HOOK_SILENT_AFTER_MS;
-}
-function lastWrite(ms, now) {
-  return ms > 0 ? `last write ${ago(ms, now)}` : "no write landed";
-}
-function ago(ms, now) {
-  const s = Math.max(0, Math.round((now - ms) / 1000));
-  if (s < 60)
-    return `${s}s ago`;
-  const m = Math.round(s / 60);
-  if (m < 60)
-    return `${m}m ago`;
-  return `${Math.round(m / 60)}h ago`;
-}
-function versionLabel(version = VERSION) {
-  return `ct@${version === DEV_VERSION ? "dev" : version}`;
-}
-function whereLabel(t) {
-  const host = t.couchUrl.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
-  return `${t.sessionsDb}@${host}`;
-}
-function storeState(s, now) {
-  if (s.lastFailureMs > s.lastWriteMs && now - s.lastWriteMs > STALL_AFTER_MS)
-    return "failing";
-  return s.lastWriteMs > 0 ? "healthy" : "idle";
-}
-function renderStatusline(state, now = Date.now()) {
-  const ct = versionLabel(state.version);
-  if (!state.configured)
-    return `\u25CB ${ct} off \xB7 no instance configured`;
-  const t = state.targets;
-  if (!t)
-    return `\u25CB ${ct} off \xB7 not recording this session`;
-  const c = state.counts;
-  const toolCalls = c ? Object.values(c.tools).reduce((a, b) => a + b, 0) : 0;
-  const counts = c ? `${c.events} ev \xB7 ${toolCalls} tools` : "0 ev";
-  const stores = t.stores?.length ? t.stores : null;
-  if (!stores) {
-    const last = lastWrite(t.lastWriteMs, now);
-    if (hookSilent(Math.max(t.lastWriteMs, t.lastFailureMs), state.transcriptMtimeMs)) {
-      return `\u25D0 ${ct} stalled \xB7 hook silent \xB7 ${counts} \xB7 ${last} \u2192 ${whereLabel(t)}`;
-    }
-    if (t.lastFailureMs > t.lastWriteMs && now - t.lastWriteMs > STALL_AFTER_MS) {
-      return `\u25D0 ${ct} stalled \xB7 ${counts} \xB7 ${last} \u2192 ${whereLabel(t)}`;
-    }
-    if (t.lastWriteMs <= 0)
-      return `\u25CC ${ct} ready \xB7 ${counts} \xB7 no write yet \u2192 ${whereLabel(t)}`;
-    return `\u25CF ${ct} rec \xB7 ${counts} \xB7 ${ago(t.lastWriteMs, now)} \u2192 ${whereLabel(t)}`;
-  }
-  const direct = stores.find((s) => s.kind === "direct") ?? stores[0];
-  const headline = direct ?? { label: whereLabel(t), lastWriteMs: 0, lastFailureMs: 0 };
-  const lastActivity = Math.max(...stores.flatMap((s) => [s.lastWriteMs, s.lastFailureMs]));
-  if (hookSilent(lastActivity, state.transcriptMtimeMs)) {
-    const newest = stores.reduce((a, b) => b.lastWriteMs > a.lastWriteMs ? b : a, headline);
-    return `\u25D0 ${ct} stalled \xB7 hook silent \xB7 ${counts} \xB7 ${lastWrite(newest.lastWriteMs, now)} \u2192 ${newest.label}`;
-  }
-  if (direct && storeState(direct, now) === "healthy") {
-    return `\u25CF ${ct} rec \xB7 ${counts} \xB7 ${ago(direct.lastWriteMs, now)} \u2192 ${direct.label}`;
-  }
-  const healthyMirrors = stores.filter((s) => s !== direct && storeState(s, now) === "healthy");
-  const first = healthyMirrors[0];
-  if (first) {
-    const more = healthyMirrors.length > 1 ? ` +${healthyMirrors.length - 1}` : "";
-    return `\u25CF ${ct} rec (mirror) \xB7 ${counts} \xB7 ${ago(first.lastWriteMs, now)} \u2192 ${first.label}${more}`;
-  }
-  if (stores.some((s) => storeState(s, now) === "failing")) {
-    const best = Math.max(...stores.map((s) => s.lastWriteMs));
-    return `\u25D0 ${ct} stalled \xB7 ${counts} \xB7 ${lastWrite(best, now)} \u2192 ${headline.label}`;
+  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 `\u25CC ${ct} ready \xB7 ${counts} \xB7 no write yet \u2192 ${headline.label}`;
+  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";
+import { dirname as dirname6 } from "path";
 function readSettings2(path) {
   try {
     return JSON.parse(readFileSync11(path, "utf8"));
@@ -5639,6 +6062,10 @@ async function render() {
       targets,
       counts: id ? makeCounts(id).read() : null,
       transcriptMtimeMs: targets ? transcriptMtimeMs(input.transcript_path) : null
+    }, Date.now(), {
+      color: !process.env.NO_COLOR,
+      link: targets && id ? sessionLink(targets.webapiUrl, id) : null,
+      columns: Number(process.env.COLUMNS) || undefined
     });
     process.stdout.write(`${line}
 `);
@@ -5922,7 +6349,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 +6763,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 +6831,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 +6842,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 +7082,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 +7118,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 +7130,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 +7175,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-byvjee1b.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-2rqkxqp9.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.5.0",
   "type": "module",
   "description": "Claude Transcripts CLI — browse, search, back up, and administer your self-hosted Claude Code session history.",
   "keywords": [