@say8425/cc-statusline 2.0.1 → 2.1.0

package/README.md

@@ -48,6 +48,7 @@ Add the following to `~/.claude/settings.json`:
 - **Context**: Token usage with percentage (color-coded)
 - **Git Diff**: File count, insertions, deletions
 - **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
 - **Limit Reset Time**: Reset time display (HH:MM)
 - **Block Usage**: 5-hour utilization percentage (from server API)
@@ -59,6 +60,7 @@ Add the following to `~/.claude/settings.json`:
 | Emoji | Description              |
 | ----- | ------------------------ |
 | 📁    | Project folder name      |
+| 🌲    | Worktree name (shown in worktree sessions) |
 | 🌿    | Current Git branch       |
 | ⏱️    | Session elapsed time     |
 | 💰    | Session cost in USD      |

package/dist/index.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+function parseCliArgs(args) {
+  const showUsage = args.includes("--show-usage");
+  return { showUsage };
+}
+
+// src/git/branch.ts
+var {$ } = 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 },
+  blockUsage: {
+    value: null,
+    timestamp: 0
+  },
+  accessToken: { value: null, timestamp: 0 },
+  mainProjectName: { value: null, timestamp: 0 }
+};
+var CACHE_TTL = {
+  branch: 5000,
+  gitChanges: 0,
+  prUrl: 30000,
+  blockUsage: 120000,
+  accessToken: 300000,
+  mainProjectName: 300000
+};
+
+// src/git/branch.ts
+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();
+    cache.branch = { value: result.trim(), timestamp: Date.now() };
+    return cache.branch.value;
+  } catch {
+    return cache.branch.value;
+  }
+}
+// src/git/changes.ts
+var {$: $2 } = 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()
+    ]);
+    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));
+    cache.gitChanges = { files, insertions, deletions, timestamp: Date.now() };
+    return cache.gitChanges;
+  } catch {
+    return cache.gitChanges;
+  }
+}
+// src/git/pr.ts
+var {$: $3 } = 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();
+    cache.prUrl = { value: result.trim() || null, timestamp: Date.now() };
+    return cache.prUrl.value;
+  } catch {
+    return cache.prUrl.value;
+  }
+}
+// src/git/worktree.ts
+var {$: $4 } = 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 gitCommonDir = result.trim();
+    if (gitCommonDir === ".git") {
+      cache.mainProjectName = { 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;
+  } catch {
+    return cache.mainProjectName.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"
+};
+function getUsageColor(pct) {
+  if (pct < 50)
+    return C.WHITE;
+  if (pct < 80)
+    return C.YELLOW;
+  return C.RED;
+}
+
+// src/format/formatNumber.ts
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+// src/format/formatResetDate.ts
+function 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
+function formatTime(hours, mins) {
+  return `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
+}
+// src/render.ts
+function renderStatusLine(ctx) {
+  const lines = [];
+  const folder = ctx.claudeJson.workspace?.project_dir?.split("/").pop() || "";
+  const sessionMs = ctx.claudeJson.cost?.total_duration_ms || 0;
+  const sessionSec = Math.floor(sessionMs / 1000);
+  const sessionHrs = Math.floor(sessionSec / 3600);
+  const sessionMins = Math.floor(sessionSec % 3600 / 60);
+  const costUsd = ctx.claudeJson.cost?.total_cost_usd || 0;
+  const usage = ctx.claudeJson.context_window?.current_usage;
+  const contextSize = ctx.claudeJson.context_window?.context_window_size || 200000;
+  const totalTokens = usage ? usage.input_tokens + usage.output_tokens + usage.cache_creation_input_tokens + usage.cache_read_input_tokens : 0;
+  const contextPct = Math.round(totalTokens / contextSize * 100);
+  const ctxColor = getUsageColor(contextPct);
+  let line1;
+  if (ctx.mainProjectName) {
+    line1 = `${C.WHITE}\uD83D\uDCC1 ${ctx.mainProjectName}${C.RESET} | ${C.WHITE}\uD83C\uDF32 ${folder}${C.RESET}`;
+  } else {
+    line1 = `${C.WHITE}\uD83D\uDCC1 ${folder}${C.RESET}`;
+  }
+  if (ctx.branch) {
+    line1 += ` | ${C.WHITE}\uD83C\uDF3F ${ctx.branch}${C.RESET}`;
+  }
+  lines.push(line1);
+  const line2 = `${C.WHITE}\u23F1\uFE0F ${formatTime(sessionHrs, sessionMins)}${C.RESET}` + ` | ${C.WHITE}\uD83D\uDCB0 $${costUsd.toFixed(2)}${C.RESET}` + ` | ${ctxColor}\uD83E\uDDE0 ${formatNumber(totalTokens)} (${contextPct}%)${C.RESET}`;
+  lines.push(line2);
+  if (ctx.showUsage && ctx.blockUsage) {
+    const parts = [];
+    if (ctx.blockUsage.resetTime) {
+      const h = ctx.blockUsage.resetTime.getHours();
+      const m = ctx.blockUsage.resetTime.getMinutes();
+      parts.push(`${C.WHITE}\u23F3 ${formatTime(h, m)}${C.RESET}`);
+    }
+    const usageColor = getUsageColor(ctx.blockUsage.utilization);
+    parts.push(`${usageColor}\uD83D\uDCCA ${Math.round(ctx.blockUsage.utilization)}/100${C.RESET}`);
+    if (ctx.blockUsage.sevenDayResetTime) {
+      parts.push(`${C.WHITE}\u23F0 ${formatResetDate(ctx.blockUsage.sevenDayResetTime)}${C.RESET}`);
+    }
+    if (ctx.blockUsage.sevenDayUtilization !== null) {
+      const weekColor = getUsageColor(ctx.blockUsage.sevenDayUtilization);
+      parts.push(`${weekColor}\uD83D\uDCC5 ${Math.round(ctx.blockUsage.sevenDayUtilization)}/100${C.RESET}`);
+    }
+    if (parts.length > 0) {
+      lines.push(parts.join(" | "));
+    }
+  }
+  const hasGitChanges = ctx.gitChanges.files > 0 || ctx.gitChanges.insertions > 0 || ctx.gitChanges.deletions > 0;
+  if (hasGitChanges || 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}`;
+    }
+    if (ctx.prUrl) {
+      const prLabel = ctx.prUrl.replace(/^https?:\/\/[^/]+\//, "").replace("/pull/", "#");
+      if (line4)
+        line4 += " | ";
+      line4 += `\uD83D\uDCCE ${C.WHITE}${C.UNDERLINE}\x1B]8;;${ctx.prUrl}\x07${prLabel}\x1B]8;;\x07${C.RESET}`;
+    }
+    lines.push(line4);
+  }
+  return lines;
+}
+
+// src/stdin.ts
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/usage/token.ts
+var {$: $5 } = globalThis.Bun;
+async function getAccessToken() {
+  if (process.platform !== "darwin")
+    return null;
+  try {
+    const result = await $5`security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null`.text();
+    const creds = JSON.parse(result);
+    return creds?.claudeAiOauth?.accessToken ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getAccessTokenCached() {
+  if (Date.now() - cache.accessToken.timestamp < CACHE_TTL.accessToken) {
+    return cache.accessToken.value;
+  }
+  const token = await getAccessToken();
+  cache.accessToken = { value: token, timestamp: Date.now() };
+  return token;
+}
+
+// src/usage/api.ts
+async function fetchUsageFromAPI(accessToken) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok)
+      return null;
+    return await response.json();
+  } catch {
+    return null;
+  }
+}
+function usageResponseToBlockUsage(data) {
+  const result = {
+    resetTime: null,
+    utilization: 0,
+    sevenDayUtilization: null,
+    sevenDayResetTime: null
+  };
+  if (data.five_hour) {
+    result.utilization = data.five_hour.utilization;
+    if (data.five_hour.resets_at) {
+      result.resetTime = new Date(data.five_hour.resets_at);
+    }
+  }
+  if (data.seven_day) {
+    result.sevenDayUtilization = data.seven_day.utilization;
+    if (data.seven_day.resets_at) {
+      result.sevenDayResetTime = new Date(data.seven_day.resets_at);
+    }
+  }
+  return result;
+}
+async function getUsageCached() {
+  if (Date.now() - cache.blockUsage.timestamp < CACHE_TTL.blockUsage) {
+    return cache.blockUsage.value;
+  }
+  const token = await getAccessTokenCached();
+  if (!token) {
+    cache.blockUsage = { value: null, timestamp: Date.now() };
+    return null;
+  }
+  const data = await fetchUsageFromAPI(token);
+  if (!data) {
+    cache.blockUsage = { value: null, timestamp: Date.now() };
+    return null;
+  }
+  const blockUsage = usageResponseToBlockUsage(data);
+  cache.blockUsage = { value: blockUsage, timestamp: Date.now() };
+  return blockUsage;
+}
+// src/index.ts
+async function main(cliArgs) {
+  const args = cliArgs ?? process.argv.slice(2);
+  const { showUsage } = parseCliArgs(args);
+  const claudeJson = JSON.parse(await readStdin() || "{}");
+  const [branch, gitChanges, prUrl, blockUsage, mainProjectName] = await Promise.all([
+    getBranchCached(),
+    getGitChangesCached(),
+    getPrUrlCached(),
+    showUsage ? getUsageCached() : Promise.resolve(null),
+    getMainProjectNameCached()
+  ]);
+  const lines = renderStatusLine({
+    claudeJson,
+    branch,
+    gitChanges,
+    prUrl,
+    blockUsage,
+    showUsage,
+    mainProjectName
+  });
+  for (const line of lines) {
+    console.log(line);
+  }
+}
+if (import.meta.main) {
+  main().catch(console.error);
+}
+export {
+  main
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@say8425/cc-statusline",
-	"version": "2.0.1",
+	"version": "2.1.0",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/say8425/cc-statusline.git"