@say8425/cc-statusline 3.0.0 → 3.1.0

package/README.md

@@ -55,6 +55,7 @@ Add the following to `~/.claude/settings.json`:
 - **Cost**: Session cost in USD
 - **Context**: Token usage with percentage (color-coded)
 - **Git Diff**: File count, insertions, deletions
+- **Clickable Diff Viewer**: Click `✏️` to open a local diff viewer (Pierre `@pierre/diffs` + `@pierre/trees`) in your browser — file tree, working-tree / vs-base modes, watch mode (auto-refresh), file folding, and in-app search (`Cmd/Ctrl+F`) across the full diff, including deleted lines
 - **PR URL**: Clickable OSC 8 hyperlink
 - **Worktree Support**: Shows real project name when running in a `cc --worktree` session
 - **TrueColor**: Dynamic colors based on thresholds
@@ -77,7 +78,7 @@ Add the following to `~/.claude/settings.json`:
 | 📊    | 5-hour utilization %     |
 | ⏰    | Weekly limit reset time  |
 | 📅    | 7-day utilization %      |
-| ✏️    | Uncommitted changes      |
+| ✏️    | Uncommitted changes (click to open diff viewer) |
 | 📎    | Pull request link        |
 
 ## Usage Metrics

package/dist/index.js

@@ -1,30 +1,425 @@
 #!/usr/bin/env bun
 // @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// src/git/branch.ts
+// src/diff-server/config.ts
+import { homedir } from "os";
+import { join } from "path";
+function resolveDiffPort(env = process.env) {
+  const raw = env.CC_STATUSLINE_DIFF_PORT;
+  if (!raw)
+    return DEFAULT_DIFF_PORT;
+  const n = Number.parseInt(raw, 10);
+  return Number.isInteger(n) && n > 0 && n < 65536 ? n : DEFAULT_DIFF_PORT;
+}
+function isDiffViewerDisabled(env = process.env) {
+  return env.CC_STATUSLINE_DIFF_DISABLE === "1";
+}
+function getCacheDir(env = process.env) {
+  const base = env.XDG_CACHE_HOME || join(env.HOME || homedir(), ".cache");
+  return join(base, "cc-statusline");
+}
+var DEFAULT_DIFF_PORT = 49573;
+var init_config = () => {};
+
+// src/diff-server/token.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function getTokenPath(env = process.env) {
+  return join2(getCacheDir(env), "diff-server.token");
+}
+function generateToken() {
+  return crypto.randomUUID().replaceAll("-", "");
+}
+function readTokenSync(env = process.env) {
+  try {
+    const value = readFileSync(getTokenPath(env), "utf8").trim();
+    return value || null;
+  } catch {
+    return null;
+  }
+}
+function ensureToken(env = process.env) {
+  const existing = readTokenSync(env);
+  if (existing)
+    return existing;
+  const token = generateToken();
+  mkdirSync(getCacheDir(env), { recursive: true, mode: 448 });
+  writeFileSync(getTokenPath(env), token, { mode: 384 });
+  return token;
+}
+var init_token = __esm(() => {
+  init_config();
+});
+
+// src/diff-server/diff.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
 var {$ } = globalThis.Bun;
+async function isGitRepo(repo) {
+  try {
+    const out = await $`git -C ${repo} rev-parse --is-inside-work-tree 2>/dev/null`.text();
+    return out.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+async function refExists(repo, ref) {
+  const r = await $`git -C ${repo} rev-parse --verify --quiet ${ref}`.nothrow().quiet();
+  return r.exitCode === 0;
+}
+async function prBaseName(repo) {
+  try {
+    const out = await $`gh pr view --json baseRefName -q .baseRefName`.cwd(repo).nothrow().quiet().text();
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function defaultBranchName(repo) {
+  const r = await $`git -C ${repo} rev-parse --abbrev-ref origin/HEAD 2>/dev/null`.nothrow().quiet();
+  if (r.exitCode !== 0)
+    return null;
+  const t = r.text().trim();
+  if (!t.startsWith("origin/"))
+    return null;
+  const name = t.slice("origin/".length);
+  return name && name !== "HEAD" ? name : null;
+}
+async function resolveBaseRef(repo) {
+  const named = await prBaseName(repo) ?? await defaultBranchName(repo);
+  const candidates = named ? [`origin/${named}`, named] : ["origin/main", "origin/master", "main", "master"];
+  for (const ref of candidates) {
+    if (await refExists(repo, ref)) {
+      const base = ref.startsWith("origin/") ? ref.slice("origin/".length) : ref;
+      return { base, ref };
+    }
+  }
+  return { base: named, ref: null };
+}
+async function showBytes(repo, rev, path) {
+  const buf = await $`git -C ${repo} show ${`${rev}:${path}`} 2>/dev/null`.nothrow().arrayBuffer();
+  return new Uint8Array(buf);
+}
+function readWorkingBytes(repo, path) {
+  try {
+    return new Uint8Array(readFileSync2(join4(repo, path)));
+  } catch {
+    return new Uint8Array;
+  }
+}
+async function buildFile(repo, base, status, name, oldName) {
+  const oldBytes = status === "added" || status === "untracked" ? new Uint8Array : await showBytes(repo, base, oldName ?? name);
+  const newBytes = status === "deleted" ? new Uint8Array : readWorkingBytes(repo, name);
+  const binary = oldBytes.includes(0) || newBytes.includes(0);
+  const decoder = new TextDecoder;
+  return {
+    name,
+    ...oldName ? { oldName } : {},
+    status,
+    binary,
+    oldContents: binary ? "" : decoder.decode(oldBytes),
+    newContents: binary ? "" : decoder.decode(newBytes)
+  };
+}
+async function getDiffFiles(repo, opts = {}) {
+  const base = opts.mode === "base" && opts.ref ? (await $`git -C ${repo} merge-base ${opts.ref} HEAD 2>/dev/null`.nothrow().text()).trim() : "HEAD";
+  const files = [];
+  if (base) {
+    const nameStatus = await $`git -C ${repo} diff --name-status ${base} 2>/dev/null`.nothrow().text();
+    for (const line of nameStatus.split(`
+`)) {
+      if (!line.trim())
+        continue;
+      const parts = line.split("\t");
+      const code = parts[0] ?? "";
+      if (code.startsWith("R")) {
+        files.push(await buildFile(repo, base, "renamed", parts[2] ?? "", parts[1]));
+      } else if (code.startsWith("A")) {
+        files.push(await buildFile(repo, base, "added", parts[1] ?? ""));
+      } else if (code.startsWith("D")) {
+        files.push(await buildFile(repo, base, "deleted", parts[1] ?? ""));
+      } else {
+        files.push(await buildFile(repo, base, "modified", parts[1] ?? ""));
+      }
+    }
+  }
+  if (opts.untracked) {
+    const listed = await $`git -C ${repo} ls-files --others --exclude-standard 2>/dev/null`.nothrow().text();
+    for (const path of listed.split(`
+`).map((s) => s.trim()).filter(Boolean)) {
+      files.push(await buildFile(repo, base, "untracked", path));
+    }
+  }
+  return files;
+}
+var init_diff = () => {};
+
+// src/diff-server/server.ts
+var exports_server = {};
+__export(exports_server, {
+  startDiffServer: () => startDiffServer
+});
+import { resolve } from "path";
+async function resolveBaseCached(repo) {
+  const now = Date.now();
+  const hit = baseCache.get(repo);
+  if (hit && now - hit.at < BASE_TTL_MS)
+    return hit.value;
+  const value = await resolveBaseRef(repo);
+  baseCache.set(repo, { value, at: now });
+  return value;
+}
+function createHandler(cfg) {
+  const viewerRoot = resolve(cfg.viewerDir);
+  return async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname === "/api/ping") {
+      return new Response(null, {
+        status: 204,
+        headers: { "x-cc-statusline": "1" }
+      });
+    }
+    if (url.pathname === "/api/diff") {
+      if (url.searchParams.get("token") !== cfg.token) {
+        return new Response("forbidden", { status: 403 });
+      }
+      const repo = url.searchParams.get("repo") ?? "";
+      if (!repo || !await isGitRepo(repo)) {
+        return new Response("not a git repository", { status: 400 });
+      }
+      const untracked = url.searchParams.get("untracked") === "1";
+      const mode = url.searchParams.get("mode") === "base" ? "base" : "working";
+      const { base, ref } = await resolveBaseCached(repo);
+      const files = mode === "base" ? await getDiffFiles(repo, {
+        untracked,
+        mode: "base",
+        ref: ref ?? undefined
+      }) : await getDiffFiles(repo, { untracked });
+      return new Response(JSON.stringify(files), {
+        headers: {
+          "content-type": "application/json; charset=utf-8",
+          "x-diff-base": base ?? ""
+        }
+      });
+    }
+    const rel = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+    const filePath = resolve(viewerRoot, rel);
+    if (filePath !== viewerRoot && !filePath.startsWith(`${viewerRoot}/`)) {
+      return new Response("forbidden", { status: 403 });
+    }
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      return new Response(file, { headers: { "cache-control": "no-store" } });
+    }
+    return new Response("not found", { status: 404 });
+  };
+}
+function startDiffServer(opts) {
+  const env = opts.env ?? process.env;
+  const token = ensureToken(env);
+  let lastActivity = Date.now();
+  const handler = createHandler({ viewerDir: opts.viewerDir, token });
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: opts.port,
+    fetch: (req) => {
+      lastActivity = Date.now();
+      return handler(req);
+    }
+  });
+  let idleTimer;
+  const idleTimeoutMs = opts.idleTimeoutMs;
+  if (idleTimeoutMs && idleTimeoutMs > 0) {
+    idleTimer = setInterval(() => {
+      if (Date.now() - lastActivity > idleTimeoutMs) {
+        stop();
+        process.exit(0);
+      }
+    }, 60000);
+    idleTimer.unref?.();
+  }
+  function stop() {
+    if (idleTimer)
+      clearInterval(idleTimer);
+    server.stop(true);
+  }
+  return { server, token, stop };
+}
+var BASE_TTL_MS = 1e4, baseCache;
+var init_server = __esm(() => {
+  init_diff();
+  init_token();
+  baseCache = new Map;
+});
+
+// src/index.ts
+init_config();
+import { join as join5 } from "path";
+
+// src/diff-server/ensure.ts
+init_config();
+init_token();
+import { mkdirSync as mkdirSync2, rmSync, statSync } from "fs";
+import { join as join3 } from "path";
+var ENSURE_TTL_MS = 5000;
+var LOCK_STALE_MS = 30000;
+var checkedAt = 0;
+async function probeOurServer(port) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}/api/ping`, {
+      signal: AbortSignal.timeout(150)
+    });
+    return res.headers.get("x-cc-statusline") === "1";
+  } catch {
+    return false;
+  }
+}
+function acquireSpawnLock(env) {
+  const lock = join3(getCacheDir(env), "diff-server.lock");
+  mkdirSync2(getCacheDir(env), { recursive: true, mode: 448 });
+  try {
+    mkdirSync2(lock);
+    return true;
+  } catch {
+    try {
+      if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
+        rmSync(lock, { recursive: true, force: true });
+        mkdirSync2(lock);
+        return true;
+      }
+    } catch {}
+    return false;
+  }
+}
+function spawnDaemon(port, env) {
+  const execPath = process.execPath;
+  const selfPath = Bun.main;
+  Bun.spawn([
+    "sh",
+    "-c",
+    'nohup "$0" "$1" --diff-server >/dev/null 2>&1 &',
+    execPath,
+    selfPath
+  ], {
+    env: { ...process.env, ...env, CC_STATUSLINE_DIFF_PORT: String(port) },
+    stdin: "ignore",
+    stdout: "ignore",
+    stderr: "ignore"
+  }).unref();
+}
+async function maybeSpawn(port, env, spawn = spawnDaemon) {
+  try {
+    if (await probeOurServer(port))
+      return;
+    if (!acquireSpawnLock(env))
+      return;
+    spawn(port, env);
+  } catch {}
+}
+async function ensureDiffServer(_repo, env = process.env, spawn = spawnDaemon) {
+  if (isDiffViewerDisabled(env))
+    return null;
+  const port = resolveDiffPort(env);
+  const now = Date.now();
+  if (now - checkedAt >= ENSURE_TTL_MS) {
+    checkedAt = now;
+    maybeSpawn(port, env, spawn);
+  }
+  const token = readTokenSync(env);
+  return token ? { port, token } : null;
+}
+
+// src/diff-server/link.ts
+function buildDiffViewerUrl(params) {
+  const query = new URLSearchParams({
+    repo: params.repo,
+    token: params.token
+  });
+  if (params.mode)
+    query.set("mode", params.mode);
+  return `http://127.0.0.1:${params.port}/?${query.toString()}`;
+}
+
+// src/git/baseChanges.ts
+var {$: $2 } = globalThis.Bun;
 
 // src/cache.ts
 var cache = {
   branch: { value: "", timestamp: 0 },
   gitChanges: { files: 0, insertions: 0, deletions: 0, timestamp: 0 },
   prUrl: { value: null, timestamp: 0 },
-  mainProjectName: { value: null, timestamp: 0 }
+  mainProjectName: { value: null, timestamp: 0 },
+  baseRef: {
+    value: null,
+    timestamp: 0
+  }
 };
 var CACHE_TTL = {
   branch: 5000,
   gitChanges: 0,
   prUrl: 30000,
-  mainProjectName: 300000
+  mainProjectName: 300000,
+  baseRef: 30000
 };
 
+// src/git/baseChanges.ts
+init_diff();
+
+// src/git/shortstat.ts
+function parseShortstat(text) {
+  const [files, insertions, deletions] = [
+    /(\d+) files?/g,
+    /(\d+) insertions?/g,
+    /(\d+) deletions?/g
+  ].map((regex) => (text.match(regex) || []).reduce((sum, m) => sum + Number.parseInt(m, 10), 0));
+  return { files, insertions, deletions };
+}
+
+// src/git/baseChanges.ts
+async function getBaseChangesCached() {
+  try {
+    let resolved = cache.baseRef.value;
+    if (resolved === null || Date.now() - cache.baseRef.timestamp >= CACHE_TTL.baseRef) {
+      resolved = await resolveBaseRef(".");
+      cache.baseRef = { value: resolved, timestamp: Date.now() };
+    }
+    if (!resolved.ref || !resolved.base)
+      return null;
+    const mb = (await $2`git merge-base ${resolved.ref} HEAD 2>/dev/null`.nothrow().text()).trim();
+    if (!mb)
+      return null;
+    const out = await $2`git diff ${mb} --shortstat 2>/dev/null`.nothrow().text();
+    const { files, insertions, deletions } = parseShortstat(out);
+    if (files === 0 && insertions === 0 && deletions === 0)
+      return null;
+    return { base: resolved.base, files, insertions, deletions };
+  } catch {
+    return null;
+  }
+}
 // src/git/branch.ts
+var {$: $3 } = globalThis.Bun;
 async function getBranchCached() {
   if (Date.now() - cache.branch.timestamp < CACHE_TTL.branch) {
     return cache.branch.value;
   }
   try {
-    const result = await $`git branch --show-current 2>/dev/null`.text();
+    const result = await $3`git branch --show-current 2>/dev/null`.text();
     cache.branch = { value: result.trim(), timestamp: Date.now() };
     return cache.branch.value;
   } catch {
@@ -32,23 +427,18 @@ async function getBranchCached() {
   }
 }
 // src/git/changes.ts
-var {$: $2 } = globalThis.Bun;
+var {$: $4 } = globalThis.Bun;
 async function getGitChangesCached() {
   if (Date.now() - cache.gitChanges.timestamp < CACHE_TTL.gitChanges) {
     return cache.gitChanges;
   }
   try {
     const [diff, staged] = await Promise.all([
-      $2`git diff --shortstat 2>/dev/null`.text(),
-      $2`git diff --cached --shortstat 2>/dev/null`.text()
+      $4`git diff --shortstat 2>/dev/null`.text(),
+      $4`git diff --cached --shortstat 2>/dev/null`.text()
     ]);
-    const combined = `${diff}
-${staged}`;
-    const [files, insertions, deletions] = [
-      /(\d+) files?/g,
-      /(\d+) insertions?/g,
-      /(\d+) deletions?/g
-    ].map((regex) => (combined.match(regex) || []).reduce((sum, m) => sum + Number.parseInt(m, 10), 0));
+    const { files, insertions, deletions } = parseShortstat(`${diff}
+${staged}`);
     cache.gitChanges = { files, insertions, deletions, timestamp: Date.now() };
     return cache.gitChanges;
   } catch {
@@ -56,13 +446,13 @@ ${staged}`;
   }
 }
 // src/git/pr.ts
-var {$: $3 } = globalThis.Bun;
+var {$: $5 } = globalThis.Bun;
 async function getPrUrlCached() {
   if (Date.now() - cache.prUrl.timestamp < CACHE_TTL.prUrl) {
     return cache.prUrl.value;
   }
   try {
-    const result = await $3`gh pr view --json url -q .url 2>/dev/null`.text();
+    const result = await $5`gh pr view --json url -q .url 2>/dev/null`.text();
     cache.prUrl = { value: result.trim() || null, timestamp: Date.now() };
     return cache.prUrl.value;
   } catch {
@@ -70,13 +460,13 @@ async function getPrUrlCached() {
   }
 }
 // src/git/worktree.ts
-var {$: $4 } = globalThis.Bun;
+var {$: $6 } = globalThis.Bun;
 async function getMainProjectNameCached() {
   if (Date.now() - cache.mainProjectName.timestamp < CACHE_TTL.mainProjectName) {
     return cache.mainProjectName.value;
   }
   try {
-    const result = await $4`git rev-parse --git-common-dir 2>/dev/null`.text();
+    const result = await $6`git rev-parse --git-common-dir 2>/dev/null`.text();
     const gitCommonDir = result.trim();
     if (gitCommonDir === ".git") {
       cache.mainProjectName = { value: null, timestamp: Date.now() };
@@ -182,10 +572,17 @@ function renderStatusLine(ctx) {
     }
   }
   const hasGitChanges = ctx.gitChanges.files > 0 || ctx.gitChanges.insertions > 0 || ctx.gitChanges.deletions > 0;
-  if (hasGitChanges || ctx.prUrl) {
+  if (hasGitChanges || ctx.baseChanges || ctx.prUrl) {
     let line4 = "";
     if (hasGitChanges) {
-      line4 += `\u270F\uFE0F ${C.WHITE}${ctx.gitChanges.files} files${C.RESET} ${C.GREEN}+${ctx.gitChanges.insertions}${C.RESET} ${C.RED}-${ctx.gitChanges.deletions}${C.RESET}`;
+      const u = ctx.diffViewerUrl ? C.UNDERLINE : "";
+      const changesText = `\u270F\uFE0F ${u}${C.WHITE}${ctx.gitChanges.files} files${C.RESET}` + `${u} ${C.GREEN}+${ctx.gitChanges.insertions}${C.RESET}` + `${u} ${C.RED}-${ctx.gitChanges.deletions}${C.RESET}`;
+      line4 += ctx.diffViewerUrl ? `\x1B]8;;${ctx.diffViewerUrl}\x07${changesText}\x1B]8;;\x07` : changesText;
+    } else if (ctx.baseChanges) {
+      const bc = ctx.baseChanges;
+      const u = ctx.baseDiffViewerUrl ? C.UNDERLINE : "";
+      const baseText = `\u270F\uFE0F ${u}vs ${bc.base} ${C.WHITE}${bc.files} files${C.RESET}` + `${u} ${C.GREEN}+${bc.insertions}${C.RESET}` + `${u} ${C.RED}-${bc.deletions}${C.RESET}`;
+      line4 += ctx.baseDiffViewerUrl ? `\x1B]8;;${ctx.baseDiffViewerUrl}\x07${baseText}\x1B]8;;\x07` : baseText;
     }
     if (ctx.prUrl) {
       const prLabel = ctx.prUrl.replace(/^https?:\/\/[^/]+\//, "").replace("/pull/", "#");
@@ -216,20 +613,59 @@ async function main() {
     getPrUrlCached(),
     getMainProjectNameCached()
   ]);
+  const repo = claudeJson.workspace?.project_dir || claudeJson.workspace?.current_dir || "";
+  const hasChanges = gitChanges.files > 0 || gitChanges.insertions > 0 || gitChanges.deletions > 0;
+  let diffViewerUrl = null;
+  let baseDiffViewerUrl = null;
+  let baseChanges = null;
+  if (!hasChanges && repo) {
+    baseChanges = await getBaseChangesCached();
+  }
+  if (repo && (hasChanges || baseChanges)) {
+    const ensured = await ensureDiffServer(repo);
+    if (ensured) {
+      if (hasChanges) {
+        diffViewerUrl = buildDiffViewerUrl({
+          port: ensured.port,
+          repo,
+          token: ensured.token,
+          mode: "working"
+        });
+      } else if (baseChanges) {
+        baseDiffViewerUrl = buildDiffViewerUrl({
+          port: ensured.port,
+          repo,
+          token: ensured.token,
+          mode: "base"
+        });
+      }
+    }
+  }
   const lines = renderStatusLine({
     claudeJson,
     branch,
     gitChanges,
     prUrl,
     rateLimits: claudeJson.rate_limits ?? null,
-    mainProjectName
+    mainProjectName,
+    diffViewerUrl,
+    baseChanges,
+    baseDiffViewerUrl
   });
   for (const line of lines) {
     console.log(line);
   }
 }
 if (import.meta.main) {
-  main().catch(console.error);
+  if (process.argv.includes("--diff-server")) {
+    const { startDiffServer: startDiffServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
+    startDiffServer2({
+      port: resolveDiffPort(),
+      viewerDir: join5(import.meta.dir, "viewer")
+    });
+  } else {
+    main().catch(console.error);
+  }
 }
 export {
   main