claudeline 1.7.0 → 1.9.0

package/dist/index.js

@@ -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: "bold:magenta:claude:model-letter if:effort(dim:sep:dot 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 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 dim:sep:middot white:cost:total"
 };
 function getTheme(name) {
   return THEMES[name] || null;
@@ -598,7 +598,7 @@ function getSampleDataJson() {
 import * as path3 from "path";
 import * as os3 from "os";
 import * as fs3 from "fs";
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 
 // src/separators.ts
 var SEPARATORS = {
@@ -636,53 +636,9 @@ function getSeparator(name) {
 }
 
 // src/usage.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
-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];
-}
-function getUsageData() {
-  const account = getClusageAccount();
-  if (!account) return null;
-  return {
-    five_hour: {
-      utilization: account.fiveHour.utilization,
-      resets_at: account.fiveHour.resetsAt
-    },
-    seven_day: {
-      utilization: account.sevenDay.utilization,
-      resets_at: account.sevenDay.resetsAt
-    }
-  };
-}
-function getProfileData() {
-  const account = getClusageAccount();
-  if (!account?.profile) return null;
-  return { email: account.profile.email };
-}
-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;
@@ -695,12 +651,12 @@ 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) {
@@ -708,60 +664,67 @@ function paceColor(delta) {
   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;
+  if (noColor2) return icon;
   return `${paceColor(delta)}${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;
+  if (noColor2) return text;
   return `${paceColor(delta)}${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 barColor(pct) {
+  if (pct < 50) return "\x1B[0;32m";
+  if (pct < 75) return "\x1B[0;33m";
+  if (pct < 90) return "\x1B[0;31m";
+  return "\x1B[0;1;31m";
 }
-function evaluateAccountComponent(key) {
-  const data = getProfileData();
-  if (!data) return "";
-  switch (key) {
-    case "email":
-      return data.email;
-    default:
-      return "";
-  }
+var BLOCKS = ["\u2591", "\u258E", "\u258C", "\u258A", "\u2588"];
+function makeBar(pct, width, noColor2, label) {
+  const clamped = Math.max(0, Math.min(100, pct));
+  const fillExact = clamped / 100 * width;
+  const fullCells = Math.floor(fillExact);
+  const fractional = fillExact - fullCells;
+  const partialIdx = Math.round(fractional * 4);
+  const partialChar = BLOCKS[partialIdx];
+  const emptyCells = width - fullCells - 1;
+  const filled = "\u2588".repeat(fullCells) + partialChar + "\u2591".repeat(Math.max(0, emptyCells));
+  const color = barColor(clamped);
+  const bar = noColor2 ? filled : `${color}${filled}\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");
+      return makeBar(fiveHour.used_percentage, width, noColor2);
     }
     case "week-bar":
     case "7d-bar": {
       const width = args ? parseInt(args, 10) || 10 : 10;
-      return makeBar(data.seven_day.utilization, width, "W");
+      return makeBar(sevenDay.used_percentage, width, noColor2);
     }
     case "5h-icon": {
-      const pct = data.five_hour.utilization;
+      const pct = fiveHour.used_percentage;
       const icon = "\uF111";
       if (pct < 50) return `\x1B[0;32m${icon}\x1B[0m`;
       if (pct < 75) return `\x1B[0;33m${icon}\x1B[0m`;
@@ -770,7 +733,7 @@ function evaluateUsageComponent(key, args, noColor = false) {
     }
     case "week-icon":
     case "7d-icon": {
-      const pct = data.seven_day.utilization;
+      const pct = sevenDay.used_percentage;
       const icon = "\uF111";
       if (pct < 50) return `\x1B[0;32m${icon}\x1B[0m`;
       if (pct < 75) return `\x1B[0;33m${icon}\x1B[0m`;
@@ -778,67 +741,128 @@ function evaluateUsageComponent(key, args, noColor = false) {
       return `\x1B[0;1;31m${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);
-    }
-    // Clusage momentum/projection data
-    case "velocity": {
-      const m = getClusageAccount()?.momentum;
-      return m ? m.velocity.toFixed(1) + " pp/hr" : "";
-    }
-    case "intensity": {
-      const m = getClusageAccount()?.momentum;
-      return m?.intensity ?? "";
+      const { delta } = calculatePace(sevenDay.used_percentage, sevenDay.resets_at, SEVEN_DAY_MS);
+      return formatPaceIcon(delta, noColor2);
     }
-    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
@@ -986,58 +1010,49 @@ function formatDuration(ms) {
 }
 function execCommand(cmd) {
   try {
-    return execSync(cmd, { encoding: "utf8" }).trim();
+    return execSync2(cmd, { encoding: "utf8" }).trim();
   } catch {
     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":
@@ -1051,9 +1066,10 @@ 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;
+      if (noColor2) return text;
       const r = `\x1B[${RESET}m`;
       const effortColors = {
         low: COLORS.green,
@@ -1095,13 +1111,13 @@ 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");
     case "status":
       try {
-        execSync("git diff --quiet 2>/dev/null");
+        execSync2("git diff --quiet 2>/dev/null");
         return "\u2713";
       } catch {
         return "*";
@@ -1109,14 +1125,14 @@ function evaluateGitComponent(key, noColor = false, noIcons = false) {
     case "status-icon":
       if (noIcons) return "";
       try {
-        execSync("git diff --quiet 2>/dev/null");
+        execSync2("git diff --quiet 2>/dev/null");
         return getNerdIcon("sparkle");
       } catch {
         return getNerdIcon("commit");
       }
     case "status-word":
       try {
-        execSync("git diff --quiet 2>/dev/null");
+        execSync2("git diff --quiet 2>/dev/null");
         return "clean";
       } catch {
         return "dirty";
@@ -1159,7 +1175,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);
@@ -1215,10 +1231,20 @@ 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 BLOCKS2 = ["\u2591", "\u258E", "\u258C", "\u258A", "\u2588"];
+      const fillExact = pct / 100 * width;
+      const fullCells = Math.floor(fillExact);
+      const fractional = fillExact - fullCells;
+      const partialIdx = Math.round(fractional * 4);
+      const partialChar = BLOCKS2[partialIdx];
+      const emptyCells = width - fullCells - 1;
+      const barStr = "\u2588".repeat(fullCells) + partialChar + "\u2591".repeat(Math.max(0, emptyCells));
+      if (noColor) return barStr;
+      const color = pct < 50 ? COLORS.green : pct < 75 ? COLORS.yellow : COLORS.red;
+      const bold = pct >= 90 ? `;${COLORS.bold}` : "";
+      return `\x1B[0;${color}${bold}m${barStr}\x1B[${RESET}m`;
     }
     case "icon": {
       if (noIcons) return "";
@@ -1370,21 +1396,21 @@ function evaluateCondition(condition, data) {
   switch (condition) {
     case "git":
       try {
-        execSync("git rev-parse --git-dir 2>/dev/null");
+        execSync2("git rev-parse --git-dir 2>/dev/null");
         return true;
       } catch {
         return false;
       }
     case "dirty":
       try {
-        execSync("git diff --quiet 2>/dev/null");
+        execSync2("git diff --quiet 2>/dev/null");
         return false;
       } catch {
         return true;
       }
     case "clean":
       try {
-        execSync("git diff --quiet 2>/dev/null");
+        execSync2("git diff --quiet 2>/dev/null");
         return true;
       } catch {
         return false;
@@ -1442,7 +1468,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);
@@ -1476,24 +1502,60 @@ 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)
+  }));
+  const filtered = [];
+  for (let i = 0; i < evaluated.length; i++) {
+    const entry = evaluated[i];
+    if (entry.type === "sep") {
+      let hasBefore = false;
+      for (let j = i - 1; j >= 0; j--) {
+        if (evaluated[j].type === "sep") continue;
+        if (evaluated[j].value) {
+          hasBefore = true;
+        }
+        break;
+      }
+      let hasAfter = false;
+      for (let j = i + 1; j < evaluated.length; j++) {
+        if (evaluated[j].type === "sep") continue;
+        if (evaluated[j].value) {
+          hasAfter = true;
+        }
+        break;
+      }
+      if (preserveEdgeSeparators) {
+        if (!hasBefore && !hasAfter) continue;
+      } else {
+        if (!hasBefore || !hasAfter) continue;
+      }
+    }
+    filtered.push(entry);
+  }
   const parts = [];
-  for (let i = 0; i < components.length; i++) {
-    const comp = components[i];
-    const prev = components[i - 1];
-    const value = evaluateComponent(comp, data, options);
-    if (i > 0 && comp.type !== "sep" && comp.type !== "conditional" && prev?.type !== "sep" && value) {
-      parts.push(" ");
+  for (let i = 0; i < filtered.length; i++) {
+    const entry = filtered[i];
+    const prev = filtered[i - 1];
+    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 (value) {
-      parts.push(value);
+    if (entry.value) {
+      parts.push(entry.value);
     }
   }
   return parts.join("");
@@ -1509,7 +1571,7 @@ function evaluateFormat(format, data, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "1.7.0";
+var VERSION = true ? "1.9.0" : "dev";
 async function readStdin() {
   return new Promise((resolve, reject) => {
     let input = "";

package/package.json

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