claudeline 1.8.0 → 1.10.0

package/dist/index.js

@@ -166,7 +166,7 @@ function listComponents() {
     {
       name: "Claude/Session",
       prefix: "claude",
-      items: ["model", "model-id", "model-letter", "effort", "effort-icon", "version", "session", "session-full", "style"]
+      items: ["model", "model-id", "model-letter", "model-family", "model-short", "effort", "effort-icon", "version", "session", "session-full", "style"]
     },
     {
       name: "Context Window",
@@ -262,7 +262,7 @@ function listComponents() {
     {
       name: "Account",
       prefix: "account",
-      items: ["email", "name", "display-name", "org", "plan", "tier"]
+      items: ["email"]
     },
     {
       name: "Usage/Limits",
@@ -439,7 +439,7 @@ var THEMES = {
   nerd: "nerd:nf-dev-nodejs_small env:node-short sep:dot nerd:nf-cod-folder fs:dir sep:dot nerd:nf-dev-git_branch git:branch git:status",
   compact: "claude:model sep:slash fs:dir sep:slash git:branch",
   colorful: "bold:magenta:claude:model sep:arrow cyan:nerd:nf-cod-folder cyan:fs:dir sep:arrow green:nerd:nf-dev-git_branch green:git:branch yellow:git:status sep:arrow blue:nerd:nf-fa-gauge blue:ctx:percent",
-  luca: "bold:magenta:claude:model if:effort(dim:sep:middot claude:effort-icon claude:effort) dim:sep:middot cyan:nerd:nf-md-source_branch cyan:git:repo sep:none text:: sep:none green:git:branch if:subdir(sep:none white:text:/ sep:none white:fs:relative) if:dirty(dim:sep:middot git:dirty) dim:sep:middot white:account:email sep:newline bold:white:usage:5h-bar:8 usage:5h (usage:5h-pace) dim:usage:5h-reset dim:sep:middot bold:white:usage:week-bar:8 usage:week (usage:week-pace) dim:usage:week-reset dim:sep:middot usage:intensity usage:velocity dim:sep:middot white:cost:total"
+  luca: "claude:model-family claude:effort-icon dim:sep:middot nerd:nf-md-source_branch git:repo sep:none text:: sep:none git:branch if:subdir(sep:none text:/ sep:none fs:relative) if:dirty(dim:sep:middot git:dirty) dim:sep:middot dim:account:email sep:newline dim:nerd:nf-md-clock_fast usage:5h-bar:10 usage:5h usage:5h-pace dim:usage:5h-reset dim:sep:middot dim:nerd:nf-md-calendar_week usage:week-bar:10 usage:week usage:week-pace dim:usage:week-reset "
 };
 function getTheme(name) {
   return THEMES[name] || null;
@@ -636,193 +636,9 @@ function getSeparator(name) {
 }
 
 // src/usage.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-import * as crypto from "crypto";
-import { execSync } from "child_process";
-var CLUSAGE_API_FILE = path2.join(os2.homedir(), ".claude", "clusage-api.json");
-var CLUSAGE_STALE_MS = 10 * 60 * 1e3;
-var _clusageCache = null;
-function readClusageAPI() {
-  try {
-    const raw = fs2.readFileSync(CLUSAGE_API_FILE, "utf8");
-    const payload = JSON.parse(raw);
-    if (!payload.updatedAt || !payload.accounts?.length) return null;
-    const age = Date.now() - new Date(payload.updatedAt).getTime();
-    if (age > CLUSAGE_STALE_MS) return null;
-    _clusageCache = payload;
-    return payload;
-  } catch {
-    return null;
-  }
-}
-function getClusageAccount() {
-  const payload = _clusageCache ?? readClusageAPI();
-  if (!payload || payload.accounts.length === 0) return null;
-  return payload.accounts[0];
-}
-var CACHE_TTL_MS = 5 * 60 * 1e3;
-var PROFILE_CACHE_TTL_MS = 60 * 60 * 1e3;
-var ANTHROPIC_BETA_HEADER = "oauth-2025-04-20";
-function tokenHash(token) {
-  return crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
-}
-function getCacheFile(token, type) {
-  const dir = path2.join(getClaudeConfigDir(), "cache");
-  try {
-    fs2.mkdirSync(dir, { recursive: true });
-  } catch {
-  }
-  return path2.join(dir, `claudeline-${type}-${tokenHash(token)}.json`);
-}
-function readCache(cacheFile, ttlMs) {
-  try {
-    const raw = fs2.readFileSync(cacheFile, "utf8");
-    const cached = JSON.parse(raw);
-    if (Date.now() - cached.fetched_at < ttlMs) {
-      return cached.data;
-    }
-  } catch {
-  }
-  return null;
-}
-function writeCache(cacheFile, data) {
-  try {
-    fs2.writeFileSync(cacheFile, JSON.stringify({ data, fetched_at: Date.now() }));
-  } catch {
-  }
-}
-function extractToken(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed === "string") return parsed;
-    if (parsed.claudeAiOauth?.accessToken) return parsed.claudeAiOauth.accessToken;
-    if (parsed.accessToken) return parsed.accessToken;
-    if (parsed.access_token) return parsed.access_token;
-  } catch {
-  }
-  return null;
-}
-function getKeychainService() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR;
-  if (configDir) {
-    const suffix = crypto.createHash("sha256").update(configDir).digest("hex").slice(0, 8);
-    return `Claude Code-credentials-${suffix}`;
-  }
-  return "Claude Code-credentials";
-}
-function getOAuthTokenMacOS() {
-  try {
-    const service = getKeychainService();
-    const raw = execSync(
-      `security find-generic-password -s "${service}" -w 2>/dev/null`,
-      { encoding: "utf8" }
-    ).trim();
-    return extractToken(raw);
-  } catch {
-    return null;
-  }
-}
-function getOAuthTokenLinux() {
-  try {
-    const configDir = process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude");
-    const credPath = path2.join(configDir, ".credentials.json");
-    const raw = fs2.readFileSync(credPath, "utf8").trim();
-    return extractToken(raw);
-  } catch {
-    return null;
-  }
-}
-function getOAuthToken() {
-  switch (process.platform) {
-    case "darwin":
-      return getOAuthTokenMacOS();
-    case "linux":
-      return getOAuthTokenLinux();
-    default:
-      return null;
-  }
-}
-function apiGet(token, urlPath) {
-  try {
-    return execSync(
-      `curl -s --max-time 5 -H "Content-Type: application/json" -H "User-Agent: claude-code/2.1.69" -H "Authorization: Bearer $__CLAUDE_TOKEN" -H "anthropic-beta: ${ANTHROPIC_BETA_HEADER}" "https://api.anthropic.com${urlPath}"`,
-      { encoding: "utf8", env: { ...process.env, __CLAUDE_TOKEN: token } }
-    ).trim();
-  } catch {
-    return null;
-  }
-}
-function fetchUsageDirect(token) {
-  try {
-    const result = apiGet(token, "/api/oauth/usage");
-    if (!result) return null;
-    const data = JSON.parse(result);
-    if (data.five_hour && data.seven_day) return data;
-    return null;
-  } catch {
-    return null;
-  }
-}
-function fetchProfileDirect(token) {
-  try {
-    const result = apiGet(token, "/api/oauth/profile");
-    if (!result) return null;
-    const data = JSON.parse(result);
-    if (data.account?.email) return { email: data.account.email };
-    return null;
-  } catch {
-    return null;
-  }
-}
-function getUsageDataDirect() {
-  const token = getOAuthToken();
-  if (!token) return null;
-  const cacheFile = getCacheFile(token, "usage");
-  const cached = readCache(cacheFile, CACHE_TTL_MS);
-  if (cached) return cached;
-  const data = fetchUsageDirect(token);
-  if (data) writeCache(cacheFile, data);
-  return data;
-}
-function getProfileDataDirect() {
-  const token = getOAuthToken();
-  if (!token) return null;
-  const cacheFile = getCacheFile(token, "profile");
-  const cached = readCache(cacheFile, PROFILE_CACHE_TTL_MS);
-  if (cached) return cached;
-  const data = fetchProfileDirect(token);
-  if (data) writeCache(cacheFile, data);
-  return data;
-}
-function getUsageData() {
-  const account = getClusageAccount();
-  if (account) {
-    return {
-      five_hour: {
-        utilization: account.fiveHour.utilization,
-        resets_at: account.fiveHour.resetsAt
-      },
-      seven_day: {
-        utilization: account.sevenDay.utilization,
-        resets_at: account.sevenDay.resetsAt
-      }
-    };
-  }
-  return getUsageDataDirect();
-}
-function getProfileData() {
-  const account = getClusageAccount();
-  if (account?.profile) {
-    return { email: account.profile.email };
-  }
-  return getProfileDataDirect();
-}
-function formatTimeUntil(isoDate) {
-  const reset = new Date(isoDate).getTime();
+function formatTimeUntil(resetUnix) {
   const now = Date.now();
-  let diff = Math.max(0, reset - now);
+  let diff = Math.max(0, resetUnix * 1e3 - now);
   if (diff === 0) return "now";
   const days = Math.floor(diff / 864e5);
   diff %= 864e5;
@@ -835,150 +651,220 @@ function formatTimeUntil(isoDate) {
 }
 var FIVE_HOUR_MS = 5 * 60 * 60 * 1e3;
 var SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1e3;
-function calculatePace(window, windowDurationMs) {
-  const resetMs = new Date(window.resets_at).getTime();
+function calculatePace(usedPct, resetUnix, windowDurationMs) {
+  const resetMs = resetUnix * 1e3;
   const remainingMs = Math.max(0, resetMs - Date.now());
   const elapsedFraction = 1 - remainingMs / windowDurationMs;
   const target = elapsedFraction * 100;
-  const delta = window.utilization - target;
+  const delta = usedPct - target;
   return { target, delta };
 }
-function paceColor(delta) {
-  if (delta > 10) return "\x1B[0;33m";
-  if (delta < -10) return "\x1B[0;36m";
-  return "\x1B[0;32m";
-}
-function formatPaceIcon(delta, noColor) {
+function formatPaceIcon(delta, noColor2) {
   const icon = delta > 10 ? "\uF0E7" : delta < -10 ? "\uF017" : "\uF00C";
-  if (noColor) return icon;
-  return `${paceColor(delta)}${icon}\x1B[0m`;
+  if (noColor2) return icon;
+  const { fg, bold } = barColorFromDelta(delta);
+  if (fg === null) return icon;
+  return `\x1B[0;${bold ? "1;" : ""}${fg}m${icon}\x1B[0m`;
 }
-function formatPaceDelta(delta, noColor) {
+function formatPaceDelta(delta, noColor2) {
   const rounded = Math.round(delta);
   let text;
   if (rounded > 0) text = "+" + rounded + "%";
   else if (rounded < 0) text = rounded + "%";
   else text = "\xB10%";
-  if (noColor) return text;
-  return `${paceColor(delta)}${text}\x1B[0m`;
+  if (noColor2) return text;
+  const { fg, bold } = barColorFromDelta(delta);
+  if (fg === null) return text;
+  return `\x1B[0;${bold ? "1;" : ""}${fg}m${text}\x1B[0m`;
 }
-function makeBar(pct, width, label) {
-  const filled = Math.round(pct / 100 * width);
-  const bar = "\u25B0".repeat(filled) + "\u25B1".repeat(width - filled);
-  return label ? label + bar : bar;
+function barColorFromDelta(delta) {
+  if (delta > 15) return { fg: 31, bold: true };
+  if (delta > 5) return { fg: 31, bold: false };
+  return { fg: null, bold: false };
 }
-function evaluateAccountComponent(key) {
-  const data = getProfileData();
-  if (!data) return "";
-  switch (key) {
-    case "email":
-      return data.email;
-    default:
-      return "";
+function makeBar(pct, width, noColor2, delta = 0, label) {
+  const clamped = Math.max(0, Math.min(100, pct));
+  const filled = Math.round(clamped / 100 * width);
+  const empty = width - filled;
+  const filledStr = "\u2588".repeat(filled);
+  const emptyStr = "\u2591".repeat(empty);
+  if (noColor2) return (label || "") + filledStr + emptyStr;
+  const { fg, bold } = barColorFromDelta(delta);
+  if (fg === null) {
+    const bar2 = `${filledStr}\x1B[2m${emptyStr}\x1B[0m`;
+    return label ? label + bar2 : bar2;
   }
+  const boldStr = bold ? "1;" : "";
+  const fillColor = `\x1B[0;${boldStr}${fg}m`;
+  const dimColor = `\x1B[0;2;${fg}m`;
+  const bar = `${fillColor}${filledStr}\x1B[0m${dimColor}${emptyStr}\x1B[0m`;
+  return label ? label + bar : bar;
 }
-function evaluateUsageComponent(key, args, noColor = false) {
-  const data = getUsageData();
-  if (!data) return "";
+function evaluateUsageComponent(key, data, args, noColor2 = false) {
+  const limits = data.rate_limits;
+  if (!limits) return "";
+  const fiveHour = limits.five_hour;
+  const sevenDay = limits.seven_day;
   switch (key) {
     case "5h":
-      return Math.round(data.five_hour.utilization) + "%";
+      return Math.round(fiveHour.used_percentage) + "%";
     case "week":
     case "7d":
-      return Math.round(data.seven_day.utilization) + "%";
+      return Math.round(sevenDay.used_percentage) + "%";
     case "5h-reset":
-      return formatTimeUntil(data.five_hour.resets_at);
+      return formatTimeUntil(fiveHour.resets_at);
     case "week-reset":
     case "7d-reset":
-      return formatTimeUntil(data.seven_day.resets_at);
+      return formatTimeUntil(sevenDay.resets_at);
     case "5h-bar": {
       const width = args ? parseInt(args, 10) || 10 : 10;
-      return makeBar(data.five_hour.utilization, width, "H");
+      const { delta } = calculatePace(fiveHour.used_percentage, fiveHour.resets_at, FIVE_HOUR_MS);
+      return makeBar(fiveHour.used_percentage, width, noColor2, delta);
     }
     case "week-bar":
     case "7d-bar": {
       const width = args ? parseInt(args, 10) || 10 : 10;
-      return makeBar(data.seven_day.utilization, width, "W");
+      const { delta } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
+      return makeBar(sevenDay.used_percentage, width, noColor2, delta);
     }
     case "5h-icon": {
-      const pct = data.five_hour.utilization;
+      const { delta } = calculatePace(fiveHour.used_percentage, fiveHour.resets_at, FIVE_HOUR_MS);
+      const { fg, bold } = barColorFromDelta(delta);
       const icon = "\uF111";
-      if (pct < 50) return `\x1B[0;32m${icon}\x1B[0m`;
-      if (pct < 75) return `\x1B[0;33m${icon}\x1B[0m`;
-      if (pct < 90) return `\x1B[0;31m${icon}\x1B[0m`;
-      return `\x1B[0;1;31m${icon}\x1B[0m`;
+      if (noColor2 || fg === null) return icon;
+      return `\x1B[0;${bold ? "1;" : ""}${fg}m${icon}\x1B[0m`;
     }
     case "week-icon":
     case "7d-icon": {
-      const pct = data.seven_day.utilization;
+      const { delta } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
+      const { fg, bold } = barColorFromDelta(delta);
       const icon = "\uF111";
-      if (pct < 50) return `\x1B[0;32m${icon}\x1B[0m`;
-      if (pct < 75) return `\x1B[0;33m${icon}\x1B[0m`;
-      if (pct < 90) return `\x1B[0;31m${icon}\x1B[0m`;
-      return `\x1B[0;1;31m${icon}\x1B[0m`;
+      if (noColor2 || fg === null) return icon;
+      return `\x1B[0;${bold ? "1;" : ""}${fg}m${icon}\x1B[0m`;
     }
     case "5h-target": {
-      const { target } = calculatePace(data.five_hour, FIVE_HOUR_MS);
+      const { target } = calculatePace(fiveHour.used_percentage, fiveHour.resets_at, FIVE_HOUR_MS);
       return Math.round(target) + "%";
     }
     case "week-target":
     case "7d-target": {
-      const { target } = calculatePace(data.seven_day, SEVEN_DAY_MS);
+      const { target } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
       return Math.round(target) + "%";
     }
     case "5h-pace": {
-      const { delta } = calculatePace(data.five_hour, FIVE_HOUR_MS);
-      return formatPaceDelta(delta, noColor);
+      const { delta } = calculatePace(fiveHour.used_percentage, fiveHour.resets_at, FIVE_HOUR_MS);
+      return formatPaceDelta(delta, noColor2);
     }
     case "week-pace":
     case "7d-pace": {
-      const { delta } = calculatePace(data.seven_day, SEVEN_DAY_MS);
-      return formatPaceDelta(delta, noColor);
+      const { delta } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
+      return formatPaceDelta(delta, noColor2);
     }
     case "5h-pace-icon": {
-      const { delta } = calculatePace(data.five_hour, FIVE_HOUR_MS);
-      return formatPaceIcon(delta, noColor);
+      const { delta } = calculatePace(fiveHour.used_percentage, fiveHour.resets_at, FIVE_HOUR_MS);
+      return formatPaceIcon(delta, noColor2);
     }
     case "week-pace-icon":
     case "7d-pace-icon": {
-      const { delta } = calculatePace(data.seven_day, SEVEN_DAY_MS);
-      return formatPaceIcon(delta, noColor);
+      const { delta } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
+      return formatPaceIcon(delta, noColor2);
     }
-    // Clusage-only momentum/projection data (no direct API fallback)
-    case "velocity": {
-      const m = getClusageAccount()?.momentum;
-      return m ? m.velocity.toFixed(1) + " pp/hr" : "";
-    }
-    case "intensity": {
-      const m = getClusageAccount()?.momentum;
-      return m?.intensity ?? "";
-    }
-    case "eta": {
-      const m = getClusageAccount()?.momentum;
-      if (!m?.etaToCeiling) return "";
-      const h = Math.floor(m.etaToCeiling / 3600);
-      const min = Math.floor(m.etaToCeiling % 3600 / 60);
-      return h > 0 ? `${h}h ${min}m` : `${min}m`;
-    }
-    case "7d-granular": {
-      const p = getClusageAccount()?.projection;
-      return p?.granularSevenDayUtilization != null ? p.granularSevenDayUtilization.toFixed(1) + "%" : "";
+    default:
+      return "";
+  }
+}
+
+// src/account.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import * as crypto from "crypto";
+import { execSync } from "child_process";
+var PROFILE_CACHE_TTL_MS = 60 * 60 * 1e3;
+function extractToken(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "string") return parsed;
+    if (parsed.claudeAiOauth?.accessToken) return parsed.claudeAiOauth.accessToken;
+    if (parsed.accessToken) return parsed.accessToken;
+    if (parsed.access_token) return parsed.access_token;
+  } catch {
+  }
+  return null;
+}
+function getKeychainService() {
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  if (configDir) {
+    const suffix = crypto.createHash("sha256").update(configDir).digest("hex").slice(0, 8);
+    return `Claude Code-credentials-${suffix}`;
+  }
+  return "Claude Code-credentials";
+}
+function getOAuthToken() {
+  try {
+    if (process.platform === "darwin") {
+      const service = getKeychainService();
+      const raw = execSync(
+        `security find-generic-password -s "${service}" -w 2>/dev/null`,
+        { encoding: "utf8" }
+      ).trim();
+      return extractToken(raw);
     }
-    case "7d-projected": {
-      const p = getClusageAccount()?.projection;
-      return p ? Math.round(p.projectedAtReset) + "%" : "";
+    if (process.platform === "linux") {
+      const configDir = process.env.CLAUDE_CONFIG_DIR || path2.join(os2.homedir(), ".claude");
+      const raw = fs2.readFileSync(path2.join(configDir, ".credentials.json"), "utf8").trim();
+      return extractToken(raw);
     }
-    case "budget": {
-      const p = getClusageAccount()?.projection;
-      return p ? p.dailyBudget.toFixed(1) + " pp/day" : "";
+  } catch {
+  }
+  return null;
+}
+function getCacheFile(token) {
+  const hash = crypto.createHash("sha256").update(token).digest("hex").slice(0, 12);
+  const dir = path2.join(getClaudeConfigDir(), "cache");
+  try {
+    fs2.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return path2.join(dir, `claudeline-profile-${hash}.json`);
+}
+function readCachedProfile(cacheFile) {
+  try {
+    const cached = JSON.parse(fs2.readFileSync(cacheFile, "utf8"));
+    if (Date.now() - cached.fetched_at < PROFILE_CACHE_TTL_MS) {
+      return cached.email;
     }
-    case "budget-status": {
-      const p = getClusageAccount()?.projection;
-      return p?.status ?? "";
+  } catch {
+  }
+  return null;
+}
+function fetchEmail(token) {
+  try {
+    const result = execSync(
+      `curl -s --max-time 5 -H "Content-Type: application/json" -H "User-Agent: claude-code/2.1.80" -H "Authorization: Bearer $__CLAUDE_TOKEN" -H "anthropic-beta: oauth-2025-04-20" "https://api.anthropic.com/api/oauth/profile"`,
+      { encoding: "utf8", env: { ...process.env, __CLAUDE_TOKEN: token } }
+    ).trim();
+    const data = JSON.parse(result);
+    return data.account?.email ?? null;
+  } catch {
+    return null;
+  }
+}
+function evaluateAccountComponent(key) {
+  if (key !== "email") return "";
+  const token = getOAuthToken();
+  if (!token) return "";
+  const cacheFile = getCacheFile(token);
+  const cached = readCachedProfile(cacheFile);
+  if (cached) return cached;
+  const email = fetchEmail(token);
+  if (email) {
+    try {
+      fs2.writeFileSync(cacheFile, JSON.stringify({ email, fetched_at: Date.now() }));
+    } catch {
     }
-    default:
-      return "";
   }
+  return email ?? "";
 }
 
 // src/nerdfonts.ts
@@ -1131,57 +1017,55 @@ function execCommand(cmd) {
     return "";
   }
 }
-function applyStyles(text, styles, noColor) {
-  if (noColor || styles.length === 0 || !text) return text;
+function applyStyles(text, styles, noColor2) {
+  if (noColor2 || styles.length === 0 || !text) return text;
   const codes = styles.map((s) => COLORS[s]).filter(Boolean);
   if (codes.length === 0) return text;
   return `\x1B[0;${codes.join(";")}m${text}\x1B[${RESET}m`;
 }
-var settingsCache = /* @__PURE__ */ new Map();
-var SETTINGS_CACHE_TTL = 1e4;
-function readSettingsFile(filePath) {
-  const cached = settingsCache.get(filePath);
-  if (cached && Date.now() - cached.ts < SETTINGS_CACHE_TTL) {
-    return cached.data;
-  }
+var VALID_EFFORTS = ["low", "medium", "high"];
+function isValidEffort(value) {
+  return typeof value === "string" && VALID_EFFORTS.includes(value);
+}
+function readEffortFromSettings(filePath) {
   try {
     const data = JSON.parse(fs3.readFileSync(filePath, "utf8"));
-    settingsCache.set(filePath, { data, ts: Date.now() });
-    return data;
+    return isValidEffort(data.effortLevel) ? data.effortLevel : null;
   } catch {
-    return {};
+    return null;
   }
 }
-var VALID_EFFORTS = ["low", "medium", "high"];
 function resolveEffort(data) {
-  const stdinEffort = data.model?.reasoning_effort;
-  if (stdinEffort && VALID_EFFORTS.includes(stdinEffort)) {
-    return stdinEffort;
-  }
-  let effort = "high";
-  const globalPath = path3.join(os3.homedir(), ".claude", "settings.json");
-  const globalSettings = readSettingsFile(globalPath);
-  if (typeof globalSettings.effortLevel === "string" && VALID_EFFORTS.includes(globalSettings.effortLevel)) {
-    effort = globalSettings.effortLevel;
+  if (isValidEffort(data.model?.reasoning_effort)) {
+    return data.model.reasoning_effort;
   }
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path3.join(os3.homedir(), ".claude");
+  let effort = readEffortFromSettings(path3.join(configDir, "settings.json"));
   const projectDir = data.workspace?.project_dir;
   if (projectDir) {
-    const projectPath = path3.join(projectDir, ".claude", "settings.json");
-    const projectSettings = readSettingsFile(projectPath);
-    if (typeof projectSettings.effortLevel === "string" && VALID_EFFORTS.includes(projectSettings.effortLevel)) {
-      effort = projectSettings.effortLevel;
-    }
+    effort = readEffortFromSettings(path3.join(projectDir, ".claude", "settings.json")) ?? effort;
   }
   return effort;
 }
-function evaluateClaudeComponent(key, data, noColor = false, noIcons = false) {
+function evaluateClaudeComponent(key, data, noColor2 = false, noIcons = false) {
   switch (key) {
     case "model":
       return data.model?.display_name || "Claude";
+    case "model-short": {
+      const name = data.model?.display_name || "Claude";
+      return name.replace(/\s*\(.*\)$/, "");
+    }
     case "model-id":
       return data.model?.id || "";
     case "model-letter":
       return (data.model?.display_name || "C")[0].toUpperCase();
+    case "model-family": {
+      const name = (data.model?.display_name || "").toLowerCase();
+      if (name.includes("opus")) return "Opus";
+      if (name.includes("sonnet")) return "Sonnet";
+      if (name.includes("haiku")) return "Haiku";
+      return data.model?.display_name || "Claude";
+    }
     case "version":
       return data.version || "";
     case "session":
@@ -1191,17 +1075,18 @@ function evaluateClaudeComponent(key, data, noColor = false, noIcons = false) {
     case "effort":
     case "effort-icon": {
       const effort = resolveEffort(data);
+      if (!effort) return "";
       if (key === "effort-icon" && noIcons) return "";
-      const text = key === "effort-icon" ? "\u{F09D1}" : effort;
-      if (noColor) return text;
-      const r = `\x1B[${RESET}m`;
-      const effortColors = {
-        low: COLORS.green,
-        medium: COLORS.yellow,
-        high: COLORS.red
-      };
-      const code = effortColors[effort] || "";
-      return code ? `\x1B[0;${code}m${text}${r}` : text;
+      if (key === "effort-icon") {
+        const icons = {
+          low: "\u25CB",
+          medium: "\u25D1",
+          high: "\u25CF",
+          max: "\u25C9"
+        };
+        return icons[effort] || "\u25CF";
+      }
+      return effort;
     }
     case "style":
       return data.output_style?.name || "default";
@@ -1235,7 +1120,7 @@ function evaluateFsComponent(key, data) {
       return "";
   }
 }
-function evaluateGitComponent(key, noColor = false, noIcons = false) {
+function evaluateGitComponent(key, noColor2 = false, noIcons = false) {
   switch (key) {
     case "branch":
       return execCommand("git branch --show-current 2>/dev/null");
@@ -1299,7 +1184,7 @@ function evaluateGitComponent(key, noColor = false, noIcons = false) {
       const untracked = parseInt(execCommand("git ls-files --others --exclude-standard 2>/dev/null | wc -l")) || 0;
       if (staged === 0 && modified === 0 && untracked === 0) return "";
       const parts = [];
-      if (noColor) {
+      if (noColor2) {
         if (staged > 0) parts.push("+" + staged);
         if (untracked > 0) parts.push("-" + untracked);
         if (modified > 0) parts.push("~" + modified);
@@ -1355,10 +1240,18 @@ function evaluateContextComponent(key, data, args, noIcons = false) {
     case "size":
       return formatTokens(ctx?.context_window_size || 2e5);
     case "bar": {
-      const pct = ctx?.used_percentage || 0;
+      const pct = Math.max(0, Math.min(100, ctx?.used_percentage || 0));
       const width = args ? parseInt(args, 10) || 10 : 10;
       const filled = Math.round(pct / 100 * width);
-      return "[" + "\u2588".repeat(filled) + "\u2591".repeat(width - filled) + "]";
+      const empty = width - filled;
+      const filledStr = "\u2588".repeat(filled);
+      const emptyStr = "\u2591".repeat(empty);
+      if (noColor) return filledStr + emptyStr;
+      const color = pct < 50 ? COLORS.green : pct < 75 ? COLORS.yellow : COLORS.red;
+      const bold = pct >= 90 ? `;${COLORS.bold}` : "";
+      const fillColor = `\x1B[0;${color}${bold}m`;
+      const dimColor = `\x1B[0;2;${color}m`;
+      return `${fillColor}${filledStr}\x1B[${RESET}m${dimColor}${emptyStr}\x1B[${RESET}m`;
     }
     case "icon": {
       if (noIcons) return "";
@@ -1582,7 +1475,7 @@ function evaluateComponent(comp, data, options) {
       result = evaluateEnvComponent(comp.key);
       break;
     case "usage":
-      result = evaluateUsageComponent(comp.key, comp.args, options.noColor);
+      result = evaluateUsageComponent(comp.key, data, comp.args, options.noColor);
       break;
     case "account":
       result = evaluateAccountComponent(comp.key);
@@ -1616,14 +1509,14 @@ function evaluateComponent(comp, data, options) {
     }
     case "conditional": {
       if (comp.children && evaluateCondition(comp.key, data)) {
-        result = evaluateComponents(comp.children, data, options);
+        result = evaluateComponents(comp.children, data, options, true);
       }
       break;
     }
   }
   return applyStyles(result, comp.styles, options.noColor);
 }
-function evaluateComponents(components, data, options) {
+function evaluateComponents(components, data, options, preserveEdgeSeparators = false) {
   const evaluated = components.map((comp) => ({
     type: comp.type,
     value: evaluateComponent(comp, data, options)
@@ -1648,7 +1541,11 @@ function evaluateComponents(components, data, options) {
         }
         break;
       }
-      if (!hasBefore || !hasAfter) continue;
+      if (preserveEdgeSeparators) {
+        if (!hasBefore && !hasAfter) continue;
+      } else {
+        if (!hasBefore || !hasAfter) continue;
+      }
     }
     filtered.push(entry);
   }
@@ -1656,8 +1553,13 @@ function evaluateComponents(components, data, options) {
   for (let i = 0; i < filtered.length; i++) {
     const entry = filtered[i];
     const prev = filtered[i - 1];
-    if (i > 0 && entry.type !== "sep" && entry.type !== "conditional" && prev?.type !== "sep" && entry.value) {
-      parts.push(" ");
+    if (i > 0 && entry.type !== "sep" && prev?.type !== "sep" && entry.value) {
+      if (entry.type === "conditional") {
+        const stripped = entry.value.replace(/\x1b\[[0-9;]*m/g, "");
+        if (!stripped.startsWith(" ")) parts.push(" ");
+      } else {
+        parts.push(" ");
+      }
     }
     if (entry.value) {
       parts.push(entry.value);
@@ -1676,7 +1578,7 @@ function evaluateFormat(format, data, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "1.8.0";
+var VERSION = true ? "1.10.0" : "dev";
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let input = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeline",
-  "version": "1.8.0",
+  "version": "1.10.0",
   "description": "Customizable status line generator for Claude Code",
   "type": "module",
   "bin": {