@say8425/cc-statusline 3.2.0 → 4.1.0

package/dist/index.js

@@ -1,412 +1,170 @@
 #!/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/diff-server/ensure.ts
+import { mkdirSync, readFileSync as readFileSync2, rmSync, statSync } from "fs";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
 
 // src/diff-server/config.ts
 import { homedir } from "os";
 import { join } from "path";
-var DEFAULT_DIFF_PORT = 49573, resolveDiffPort = (env = process.env) => {
+var DEFAULT_DIFF_PORT = 49573;
+var 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;
-}, isDiffViewerDisabled = (env = process.env) => env.CC_STATUSLINE_DIFF_DISABLE === "1", getCacheDir = (env = process.env) => {
+};
+var isDiffViewerDisabled = (env = process.env) => env.CC_STATUSLINE_DIFF_DISABLE === "1";
+var getCacheDir = (env = process.env) => {
   const base = env.XDG_CACHE_HOME || join(env.HOME || homedir(), ".cache");
   return join(base, "cc-statusline");
 };
-var init_config = () => {};
+var getDiffdeckCacheDir = (env = process.env) => {
+  const base = env.XDG_CACHE_HOME || join(env.HOME || homedir(), ".cache");
+  return join(base, "diffdeck");
+};
 
 // src/diff-server/token.ts
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { readFileSync } from "fs";
 import { join as join2 } from "path";
-var getTokenPath = (env = process.env) => join2(getCacheDir(env), "diff-server.token"), generateToken = () => crypto.randomUUID().replaceAll("-", ""), readTokenSync = (env = process.env) => {
+var getTokenPath = (env = process.env) => join2(getDiffdeckCacheDir(env), "diff-server.token");
+var readTokenSync = (env = process.env) => {
   try {
     const value = readFileSync(getTokenPath(env), "utf8").trim();
     return value || null;
   } catch {
     return null;
   }
-}, 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/mapLimit.ts
-var mapWithLimit = async (items, limit, fn) => {
-  const results = [];
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const index = next;
-      next += 1;
-      results[index] = await fn(items[index], index);
-    }
-  };
-  const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, () => worker());
-  await Promise.all(workers);
-  return results;
-};
-
-// src/diff-server/diff.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { isAbsolute, join as join4, resolve } from "path";
-var {$ } = globalThis.Bun;
-var BUILD_CONCURRENCY = 8, isGitRepo = async (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;
-  }
-}, refExists = async (repo, ref) => {
-  const r = await $`git -C ${repo} rev-parse --verify --quiet ${ref}`.nothrow().quiet();
-  return r.exitCode === 0;
-}, prBaseName = async (repo) => {
-  try {
-    const out = await $`gh pr view --json baseRefName -q .baseRefName`.cwd(repo).nothrow().quiet().text();
-    return out.trim() || null;
-  } catch {
-    return null;
-  }
-}, defaultBranchName = async (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;
-}, resolveBaseRef = async (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 };
-}, showBytes = async (repo, rev, path) => {
-  const buf = await $`git -C ${repo} show ${`${rev}:${path}`} 2>/dev/null`.nothrow().arrayBuffer();
-  return new Uint8Array(buf);
-}, readWorkingBytes = (repo, path) => {
-  try {
-    return new Uint8Array(readFileSync2(join4(repo, path)));
-  } catch {
-    return new Uint8Array;
-  }
-}, buildFile = async (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),
-    ...binary ? {
-      blobVersion: `${Bun.hash(oldBytes).toString(36)}.${Bun.hash(newBytes).toString(36)}`
-    } : {}
-  };
-}, resolveDiffBaseRev = async (repo, opts) => opts.mode === "base" && opts.ref ? (await $`git -C ${repo} merge-base ${opts.ref} HEAD 2>/dev/null`.nothrow().text()).trim() : "HEAD", getFileBytes = async (repo, path, side, opts = {}) => {
-  const root = resolve(repo);
-  const target = resolve(root, path);
-  if (!path || isAbsolute(path) || target !== root && !target.startsWith(`${root}/`)) {
-    return null;
-  }
-  if (side === "new") {
-    const bytes2 = readWorkingBytes(repo, path);
-    return bytes2.length > 0 ? bytes2 : null;
-  }
-  const base = await resolveDiffBaseRev(repo, opts);
-  if (!base)
-    return null;
-  const bytes = await showBytes(repo, base, path);
-  return bytes.length > 0 ? bytes : null;
-}, getDiffFiles = async (repo, opts = {}) => {
-  const base = await resolveDiffBaseRev(repo, opts);
-  const files = [];
-  if (base) {
-    const nameStatus = await $`git -C ${repo} diff --name-status ${base} 2>/dev/null`.nothrow().text();
-    const specs = [];
-    for (const line of nameStatus.split(`
-`)) {
-      if (!line.trim())
-        continue;
-      const parts = line.split("\t");
-      const code = parts[0] ?? "";
-      if (code.startsWith("R")) {
-        specs.push({
-          status: "renamed",
-          name: parts[2] ?? "",
-          oldName: parts[1]
-        });
-      } else if (code.startsWith("A")) {
-        specs.push({ status: "added", name: parts[1] ?? "" });
-      } else if (code.startsWith("D")) {
-        specs.push({ status: "deleted", name: parts[1] ?? "" });
-      } else {
-        specs.push({ status: "modified", name: parts[1] ?? "" });
-      }
-    }
-    files.push(...await mapWithLimit(specs, BUILD_CONCURRENCY, (spec) => buildFile(repo, base, spec.status, spec.name, spec.oldName)));
-  }
-  if (opts.untracked) {
-    const listed = await $`git -C ${repo} ls-files --others --exclude-standard 2>/dev/null`.nothrow().text();
-    const paths = listed.split(`
-`).map((s) => s.trim()).filter(Boolean);
-    files.push(...await mapWithLimit(paths, BUILD_CONCURRENCY, (path) => buildFile(repo, base, "untracked", path)));
-  }
-  return files;
-};
-var init_diff = () => {};
-
-// src/diff-server/imageTypes.ts
-var IMAGE_MIME, extensionOf = (name) => {
-  const dot = name.lastIndexOf(".");
-  if (dot <= 0 || dot === name.length - 1)
-    return null;
-  return name.slice(dot + 1).toLowerCase();
-}, isImagePath = (name) => {
-  const ext = extensionOf(name);
-  return ext !== null && ext in IMAGE_MIME;
-}, imageContentType = (name) => {
-  const ext = extensionOf(name);
-  return ext && IMAGE_MIME[ext] || "application/octet-stream";
-};
-var init_imageTypes = __esm(() => {
-  IMAGE_MIME = {
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    webp: "image/webp",
-    avif: "image/avif",
-    bmp: "image/bmp",
-    ico: "image/x-icon"
-  };
-});
-
-// src/diff-server/server.ts
-var exports_server = {};
-__export(exports_server, {
-  startDiffServer: () => startDiffServer
-});
-import { resolve as resolve2 } from "path";
-var BASE_TTL_MS = 1e4, baseCache, resolveBaseCached = async (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;
-}, createHandler = (cfg) => {
-  const viewerRoot = resolve2(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 ?? ""
-        }
-      });
-    }
-    if (url.pathname === "/api/blob") {
-      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 path = url.searchParams.get("path") ?? "";
-      if (!isImagePath(path)) {
-        return new Response("not found", { status: 404 });
-      }
-      const side = url.searchParams.get("side") === "old" ? "old" : "new";
-      const mode = url.searchParams.get("mode") === "base" ? "base" : "working";
-      const ref = mode === "base" ? (await resolveBaseCached(repo)).ref : null;
-      const bytes = await getFileBytes(repo, path, side, mode === "base" && ref ? { mode, ref } : {});
-      if (!bytes)
-        return new Response("not found", { status: 404 });
-      return new Response(bytes, {
-        headers: {
-          "content-type": imageContentType(path),
-          "cache-control": "no-store"
-        }
-      });
-    }
-    const rel = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
-    const filePath = resolve2(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 });
-  };
-}, 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?.();
-  }
-  const stop = () => {
-    if (idleTimer)
-      clearInterval(idleTimer);
-    server.stop(true);
-  };
-  return { server, token, stop };
-};
-var init_server = __esm(() => {
-  init_diff();
-  init_imageTypes();
-  init_token();
-  baseCache = new Map;
-});
-
-// src/index.ts
-init_config();
-import { join as join6 } 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 PORT_FREE_TRIES = 20;
+var PORT_FREE_INTERVAL_MS = 100;
 var checkedAt = 0;
-var probeOurServer = async (port) => {
+var probeServer = async (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";
+    const ours = res.headers.get("x-diffdeck") === "1" || res.headers.get("x-cc-statusline") === "1";
+    if (!ours)
+      return null;
+    const version = res.headers.get("x-diffdeck-version");
+    const pidRaw = res.headers.get("x-diffdeck-pid");
+    const pid = pidRaw == null ? null : Number.parseInt(pidRaw, 10);
+    return { version, pid: Number.isInteger(pid) ? pid : null };
   } catch {
-    return false;
+    return null;
+  }
+};
+var lsofPortOwner = (port) => {
+  try {
+    const out = Bun.spawnSync(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
+    if (out.exitCode !== 0)
+      return null;
+    const first = out.stdout.toString().trim().split(`
+`)[0] ?? "";
+    const pid = Number.parseInt(first, 10);
+    return Number.isInteger(pid) ? pid : null;
+  } catch {
+    return null;
   }
 };
 var acquireSpawnLock = (env) => {
   const lock = join3(getCacheDir(env), "diff-server.lock");
-  mkdirSync2(getCacheDir(env), { recursive: true, mode: 448 });
+  mkdirSync(getCacheDir(env), { recursive: true, mode: 448 });
   try {
-    mkdirSync2(lock);
+    mkdirSync(lock);
     return true;
   } catch {
     try {
       if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
         rmSync(lock, { recursive: true, force: true });
-        mkdirSync2(lock);
+        mkdirSync(lock);
         return true;
       }
     } catch {}
     return false;
   }
 };
+var resolveDiffdeck = () => {
+  const pkgDir = dirname(fileURLToPath(import.meta.resolve("@say8425/diffdeck/package.json")));
+  const pkg = JSON.parse(readFileSync2(join3(pkgDir, "package.json"), "utf8"));
+  return { cli: join3(pkgDir, pkg.bin.diffdeck), version: pkg.version };
+};
 var spawnDaemon = (port, env) => {
-  const execPath = process.execPath;
-  const selfPath = Bun.main;
+  const { cli } = resolveDiffdeck();
   Bun.spawn([
     "sh",
     "-c",
-    'nohup "$0" "$1" --diff-server >/dev/null 2>&1 &',
-    execPath,
-    selfPath
+    'nohup "$0" "$1" --no-open --port "$2" >/dev/null 2>&1 &',
+    process.execPath,
+    cli,
+    String(port)
   ], {
-    env: { ...process.env, ...env, CC_STATUSLINE_DIFF_PORT: String(port) },
+    env: { ...process.env, ...env, DIFFDECK_PORT: String(port) },
     stdin: "ignore",
     stdout: "ignore",
     stderr: "ignore"
   }).unref();
 };
-var maybeSpawn = async (port, env, spawn = spawnDaemon) => {
+var realDeps = {
+  spawn: spawnDaemon,
+  probe: probeServer,
+  portOwner: lsofPortOwner,
+  kill: (pid) => process.kill(pid, "SIGTERM"),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  currentVersion: () => {
+    try {
+      return resolveDiffdeck().version;
+    } catch {
+      return null;
+    }
+  }
+};
+var waitPortFree = async (port, d) => {
+  for (let i = 0;i < PORT_FREE_TRIES; i++) {
+    await d.sleep(PORT_FREE_INTERVAL_MS);
+    if (await d.probe(port) == null)
+      return true;
+  }
+  return false;
+};
+var maybeSpawn = async (port, env, deps = {}) => {
+  const d = { ...realDeps, ...deps };
   try {
-    if (await probeOurServer(port))
+    const found = await d.probe(port);
+    const current = d.currentVersion();
+    if (found && (current == null || found.version === current))
       return;
     if (!acquireSpawnLock(env))
       return;
-    spawn(port, env);
+    if (found) {
+      const owner = d.portOwner(port);
+      if (owner == null)
+        return;
+      if (found.pid != null && found.pid !== owner)
+        return;
+      d.kill(owner);
+      if (!await waitPortFree(port, d))
+        return;
+    }
+    d.spawn(port, env);
   } catch {}
 };
-var ensureDiffServer = (_repo, env = process.env, spawn = spawnDaemon) => {
+var ensureDiffServer = (_repo, env = process.env, deps = {}) => {
   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);
+    maybeSpawn(port, env, deps);
   }
   const token = readTokenSync(env);
   return token ? { port, token } : null;
@@ -423,6 +181,96 @@ var buildDiffViewerUrl = (params) => {
   return `http://127.0.0.1:${params.port}/?${query.toString()}`;
 };
 
+// src/format/formatNumber.ts
+var formatNumber = (n) => n.toLocaleString("en-US");
+// src/format/formatResetDate.ts
+var formatResetDate = (date) => {
+  const month = (date.getMonth() + 1).toString().padStart(2, "0");
+  const day = date.getDate().toString().padStart(2, "0");
+  const hours = date.getHours().toString().padStart(2, "0");
+  const minutes = date.getMinutes().toString().padStart(2, "0");
+  return `${month}/${day} ${hours}:${minutes}`;
+};
+// src/format/formatTime.ts
+var formatTime = (hours, mins) => `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
+// src/colors.ts
+var C = {
+  RESET: "\x1B[0m",
+  CYAN: "\x1B[38;2;0;255;255m",
+  MAGENTA: "\x1B[38;2;255;100;200m",
+  GREEN: "\x1B[38;2;100;255;100m",
+  YELLOW: "\x1B[38;2;255;220;100m",
+  RED: "\x1B[38;2;255;100;100m",
+  BLUE: "\x1B[38;2;100;150;255m",
+  WHITE: "\x1B[38;2;200;200;200m",
+  GREEN_MUTED: "\x1B[38;2;140;195;140m",
+  YELLOW_MUTED: "\x1B[38;2;210;185;130m",
+  RED_MUTED: "\x1B[38;2;210;130;130m",
+  MAGENTA_MUTED: "\x1B[38;2;195;140;175m",
+  UNDERLINE: "\x1B[4m"
+};
+var getUsageColor = (pct) => {
+  if (pct < 50)
+    return C.WHITE;
+  if (pct < 80)
+    return C.YELLOW;
+  return C.RED;
+};
+
+// src/format/prStatus.ts
+var prStateText = (state, isDraft) => {
+  if (isDraft)
+    return "Draft";
+  if (state === "OPEN")
+    return "Open";
+  if (state === "MERGED")
+    return "Merged";
+  return "Closed";
+};
+var prStateColor = (state, isDraft) => {
+  if (isDraft)
+    return C.WHITE;
+  if (state === "OPEN")
+    return C.GREEN_MUTED;
+  if (state === "MERGED")
+    return C.MAGENTA_MUTED;
+  return C.RED_MUTED;
+};
+var ciSummaryText = (ci) => {
+  if (ci === null)
+    return "";
+  if (ci.conclusion === "failure")
+    return `${ci.count} failed`;
+  if (ci.conclusion === "pending")
+    return `${ci.count} running`;
+  return `${ci.count} passed`;
+};
+var ciSummaryColor = (ci) => {
+  if (ci === null)
+    return "";
+  if (ci.conclusion === "failure")
+    return C.RED_MUTED;
+  if (ci.conclusion === "pending")
+    return C.YELLOW_MUTED;
+  return C.GREEN_MUTED;
+};
+// src/format/toFileUrl.ts
+var toFileUrl = (absolutePath) => {
+  const normalized = absolutePath.replace(/\\/g, "/");
+  const withLeadingSlash = normalized.startsWith("/") ? normalized : `/${normalized}`;
+  try {
+    return `file://${encodeURI(withLeadingSlash)}`;
+  } catch {
+    const safe = Array.from(withLeadingSlash).map((ch) => {
+      try {
+        return encodeURI(ch);
+      } catch {
+        return "%EF%BF%BD";
+      }
+    }).join("");
+    return `file://${safe}`;
+  }
+};
 // src/git/baseChanges.ts
 var {$: $2 } = globalThis.Bun;
 
@@ -430,8 +278,11 @@ var {$: $2 } = globalThis.Bun;
 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 },
+  prInfo: { value: null, timestamp: 0 },
+  mainProject: {
+    value: null,
+    timestamp: 0
+  },
   baseRef: {
     value: null,
     timestamp: 0
@@ -441,14 +292,47 @@ var cache = {
 var CACHE_TTL = {
   branch: 5000,
   gitChanges: 0,
-  prUrl: 30000,
-  mainProjectName: 300000,
+  prInfo: 30000,
+  mainProject: 300000,
   baseRef: 30000,
   ultracode: 5000
 };
 
-// src/git/baseChanges.ts
-init_diff();
+// src/git/baseRef.ts
+var {$ } = globalThis.Bun;
+var refExists = async (repo, ref) => {
+  const r = await $`git -C ${repo} rev-parse --verify --quiet ${ref}`.nothrow().quiet();
+  return r.exitCode === 0;
+};
+var prBaseName = async (repo) => {
+  try {
+    const out = await $`gh pr view --json baseRefName -q .baseRefName`.cwd(repo).nothrow().quiet().text();
+    return out.trim() || null;
+  } catch {
+    return null;
+  }
+};
+var defaultBranchName = async (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;
+};
+var resolveBaseRef = async (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 };
+};
 
 // src/git/shortstat.ts
 var parseShortstat = (text) => {
@@ -517,71 +401,91 @@ ${staged}`);
 };
 // src/git/pr.ts
 var {$: $5 } = globalThis.Bun;
-var getPrUrlCached = async () => {
-  if (Date.now() - cache.prUrl.timestamp < CACHE_TTL.prUrl) {
-    return cache.prUrl.value;
+
+// src/git/ciStatus.ts
+var FAILURE_CONCLUSIONS = new Set([
+  "FAILURE",
+  "TIMED_OUT",
+  "CANCELLED",
+  "ACTION_REQUIRED",
+  "STALE"
+]);
+var PASS_CONCLUSIONS = new Set(["SUCCESS", "NEUTRAL", "SKIPPED"]);
+var FAILURE_STATES = new Set(["FAILURE", "ERROR"]);
+var aggregateCiStatus = (checks) => {
+  if (checks.length === 0)
+    return null;
+  let failedCount = 0;
+  let pendingCount = 0;
+  let passedCount = 0;
+  for (const check of checks) {
+    if (check.conclusion != null) {
+      if (FAILURE_CONCLUSIONS.has(check.conclusion))
+        failedCount++;
+      else if (PASS_CONCLUSIONS.has(check.conclusion))
+        passedCount++;
+      else
+        pendingCount++;
+    } else if (check.status != null && check.status !== "COMPLETED") {
+      pendingCount++;
+    } else if (check.state != null) {
+      if (FAILURE_STATES.has(check.state))
+        failedCount++;
+      else if (check.state === "SUCCESS")
+        passedCount++;
+      else
+        pendingCount++;
+    }
+  }
+  if (failedCount > 0)
+    return { conclusion: "failure", count: failedCount };
+  if (pendingCount > 0)
+    return { conclusion: "pending", count: pendingCount };
+  return { conclusion: "success", count: passedCount };
+};
+
+// src/git/pr.ts
+var getPrInfoCached = async () => {
+  if (Date.now() - cache.prInfo.timestamp < CACHE_TTL.prInfo) {
+    return cache.prInfo.value;
   }
   try {
-    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;
+    const result = await $5`gh pr view --json url,state,isDraft,statusCheckRollup 2>/dev/null`.text();
+    const parsed = JSON.parse(result);
+    const value = {
+      url: parsed.url,
+      state: parsed.state,
+      isDraft: parsed.isDraft,
+      ciStatus: aggregateCiStatus(parsed.statusCheckRollup ?? [])
+    };
+    cache.prInfo = { value, timestamp: Date.now() };
+    return value;
   } catch {
-    return cache.prUrl.value;
+    return cache.prInfo.value;
   }
 };
 // src/git/worktree.ts
 var {$: $6 } = globalThis.Bun;
-var getMainProjectNameCached = async () => {
-  if (Date.now() - cache.mainProjectName.timestamp < CACHE_TTL.mainProjectName) {
-    return cache.mainProjectName.value;
+var getMainProjectCached = async () => {
+  if (Date.now() - cache.mainProject.timestamp < CACHE_TTL.mainProject) {
+    return cache.mainProject.value;
   }
   try {
     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() };
+      cache.mainProject = { value: null, timestamp: Date.now() };
       return null;
     }
     const projectRoot = gitCommonDir.replace(/\/.git$/, "");
-    const projectName = projectRoot.split("/").pop() || null;
-    cache.mainProjectName = { value: projectName, timestamp: Date.now() };
-    return projectName;
+    const projectName = projectRoot.split("/").pop();
+    const value = projectName ? { name: projectName, path: projectRoot } : null;
+    cache.mainProject = { value, timestamp: Date.now() };
+    return value;
   } catch {
-    return cache.mainProjectName.value;
+    return cache.mainProject.value;
   }
 };
-// src/colors.ts
-var C = {
-  RESET: "\x1B[0m",
-  CYAN: "\x1B[38;2;0;255;255m",
-  MAGENTA: "\x1B[38;2;255;100;200m",
-  GREEN: "\x1B[38;2;100;255;100m",
-  YELLOW: "\x1B[38;2;255;220;100m",
-  RED: "\x1B[38;2;255;100;100m",
-  BLUE: "\x1B[38;2;100;150;255m",
-  WHITE: "\x1B[38;2;200;200;200m",
-  UNDERLINE: "\x1B[4m"
-};
-var getUsageColor = (pct) => {
-  if (pct < 50)
-    return C.WHITE;
-  if (pct < 80)
-    return C.YELLOW;
-  return C.RED;
-};
-
-// src/format/formatNumber.ts
-var formatNumber = (n) => n.toLocaleString("en-US");
-// src/format/formatResetDate.ts
-var formatResetDate = (date) => {
-  const month = (date.getMonth() + 1).toString().padStart(2, "0");
-  const day = date.getDate().toString().padStart(2, "0");
-  const hours = date.getHours().toString().padStart(2, "0");
-  const minutes = date.getMinutes().toString().padStart(2, "0");
-  return `${month}/${day} ${hours}:${minutes}`;
-};
-// src/format/formatTime.ts
-var formatTime = (hours, mins) => `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
 // src/render.ts
 var renderStatusLine = (ctx) => {
   const lines = [];
@@ -593,9 +497,17 @@ var renderStatusLine = (ctx) => {
   const costUsd = ctx.claudeJson.cost?.total_cost_usd || 0;
   let line1;
   if (ctx.mainProjectName) {
-    line1 = `${C.WHITE}\uD83D\uDCC1 ${ctx.mainProjectName}${C.RESET} | ${C.WHITE}\uD83C\uDF32 ${folder}${C.RESET}`;
+    const mainU = ctx.mainProjectUrl ? C.UNDERLINE : "";
+    const mainText = `${C.WHITE}\uD83D\uDCC1 ${mainU}${ctx.mainProjectName}${C.RESET}`;
+    const mainSeg = ctx.mainProjectUrl ? `\x1B]8;;${ctx.mainProjectUrl}\x07${mainText}\x1B]8;;\x07` : mainText;
+    const folderU = ctx.projectDirUrl ? C.UNDERLINE : "";
+    const folderText = `${C.WHITE}\uD83C\uDF32 ${folderU}${folder}${C.RESET}`;
+    const folderSeg = ctx.projectDirUrl ? `\x1B]8;;${ctx.projectDirUrl}\x07${folderText}\x1B]8;;\x07` : folderText;
+    line1 = `${mainSeg} | ${folderSeg}`;
   } else {
-    line1 = `${C.WHITE}\uD83D\uDCC1 ${folder}${C.RESET}`;
+    const folderU = ctx.projectDirUrl ? C.UNDERLINE : "";
+    const folderText = `${C.WHITE}\uD83D\uDCC1 ${folderU}${folder}${C.RESET}`;
+    line1 = ctx.projectDirUrl ? `\x1B]8;;${ctx.projectDirUrl}\x07${folderText}\x1B]8;;\x07` : folderText;
   }
   if (ctx.branch) {
     line1 += ` | ${C.WHITE}\uD83C\uDF3F ${ctx.branch}${C.RESET}`;
@@ -646,7 +558,7 @@ var renderStatusLine = (ctx) => {
     }
   }
   const hasGitChanges = ctx.gitChanges.files > 0 || ctx.gitChanges.insertions > 0 || ctx.gitChanges.deletions > 0;
-  if (hasGitChanges || ctx.baseChanges || ctx.prUrl) {
+  if (hasGitChanges || ctx.baseChanges || ctx.prInfo) {
     let line4 = "";
     if (hasGitChanges) {
       const u = ctx.diffViewerUrl ? C.UNDERLINE : "";
@@ -658,11 +570,17 @@ var renderStatusLine = (ctx) => {
       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/", "#");
+    if (ctx.prInfo) {
+      const { url, state, isDraft, ciStatus } = ctx.prInfo;
+      const prLabel = url.replace(/^https?:\/\/[^/]+\//, "").replace("/pull/", "#");
+      const stateText = prStateText(state, isDraft);
+      const stateColor = prStateColor(state, isDraft);
+      const ciText = ciSummaryText(ciStatus);
+      const ciColor = ciSummaryColor(ciStatus);
+      const ciSuffix = ciText ? `${ciColor}${C.UNDERLINE}(${ciText})` : "";
       if (line4)
         line4 += " | ";
-      line4 += `\uD83D\uDCCE ${C.WHITE}${C.UNDERLINE}\x1B]8;;${ctx.prUrl}\x07${prLabel}\x1B]8;;\x07${C.RESET}`;
+      line4 += `\uD83D\uDCCE ${C.WHITE}${C.UNDERLINE}\x1B]8;;${url}\x07${prLabel} ` + `${stateColor}${C.UNDERLINE}[${stateText}]${ciSuffix}${C.RESET}\x1B]8;;\x07`;
     }
     lines.push(line4);
   }
@@ -681,14 +599,14 @@ var readStdin = async () => {
 // src/ultracode.ts
 import { readFile } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
-var MANAGED_SETTINGS_PATH = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? join5(process.env.ProgramData || "C:\\ProgramData", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
+import { join as join4 } from "path";
+var MANAGED_SETTINGS_PATH = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? join4(process.env.ProgramData || "C:\\ProgramData", "ClaudeCode", "managed-settings.json") : "/etc/claude-code/managed-settings.json";
 var ultracodeSettingsPaths = (projectDir, homeDir) => {
   const paths = [MANAGED_SETTINGS_PATH];
   if (projectDir) {
-    paths.push(join5(projectDir, ".claude", "settings.local.json"), join5(projectDir, ".claude", "settings.json"));
+    paths.push(join4(projectDir, ".claude", "settings.local.json"), join4(projectDir, ".claude", "settings.json"));
   }
-  paths.push(join5(homeDir, ".claude", "settings.json"));
+  paths.push(join4(homeDir, ".claude", "settings.json"));
   return paths;
 };
 var resolveUltracodeFromFiles = async (paths) => {
@@ -718,13 +636,16 @@ var getUltracodeCached = async (projectDir, homeDir = homedir2()) => {
 var main = async () => {
   const claudeJson = JSON.parse(await readStdin() || "{}");
   const repo = claudeJson.workspace?.project_dir || claudeJson.workspace?.current_dir || "";
-  const [branch, gitChanges, prUrl, mainProjectName, ultracode] = await Promise.all([
+  const [branch, gitChanges, prInfo, mainProject, ultracode] = await Promise.all([
     getBranchCached(),
     getGitChangesCached(),
-    getPrUrlCached(),
-    getMainProjectNameCached(),
+    getPrInfoCached(),
+    getMainProjectCached(),
     getUltracodeCached(repo)
   ]);
+  const mainProjectName = mainProject?.name ?? null;
+  const projectDirUrl = repo ? toFileUrl(repo) : null;
+  const mainProjectUrl = mainProject ? toFileUrl(mainProject.path) : null;
   const hasChanges = gitChanges.files > 0 || gitChanges.insertions > 0 || gitChanges.deletions > 0;
   let diffViewerUrl = null;
   let baseDiffViewerUrl = null;
@@ -756,28 +677,22 @@ var main = async () => {
     claudeJson,
     branch,
     gitChanges,
-    prUrl,
+    prInfo,
     ultracode,
     rateLimits: claudeJson.rate_limits ?? null,
     mainProjectName,
     diffViewerUrl,
     baseChanges,
-    baseDiffViewerUrl
+    baseDiffViewerUrl,
+    projectDirUrl,
+    mainProjectUrl
   });
   for (const line of lines) {
     console.log(line);
   }
 };
 if (import.meta.main) {
-  if (process.argv.includes("--diff-server")) {
-    const { startDiffServer: startDiffServer2 } = await Promise.resolve().then(() => (init_server(), exports_server));
-    startDiffServer2({
-      port: resolveDiffPort(),
-      viewerDir: join6(import.meta.dir, "viewer")
-    });
-  } else {
-    main().catch(console.error);
-  }
+  main().catch(console.error);
 }
 export {
   main