claudeline 1.0.0

package/dist/index.js

@@ -0,0 +1,1193 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/colors.ts
+var COLORS = {
+  // Foreground colors
+  black: "30",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  blue: "34",
+  magenta: "35",
+  cyan: "36",
+  white: "37",
+  gray: "90",
+  grey: "90",
+  // Bright foreground
+  "bright-red": "91",
+  "bright-green": "92",
+  "bright-yellow": "93",
+  "bright-blue": "94",
+  "bright-magenta": "95",
+  "bright-cyan": "96",
+  "bright-white": "97",
+  // Background colors
+  "bg-black": "40",
+  "bg-red": "41",
+  "bg-green": "42",
+  "bg-yellow": "43",
+  "bg-blue": "44",
+  "bg-magenta": "45",
+  "bg-cyan": "46",
+  "bg-white": "47",
+  // Styles
+  bold: "1",
+  dim: "2",
+  italic: "3",
+  underline: "4",
+  blink: "5",
+  inverse: "7",
+  hidden: "8",
+  strikethrough: "9"
+};
+var RESET = "0";
+
+// src/parser.ts
+var STYLE_PREFIXES = new Set(Object.keys(COLORS));
+function parseFormat(format) {
+  const normalized = format.trim();
+  const components = [];
+  let i = 0;
+  while (i < normalized.length) {
+    while (i < normalized.length && /\s/.test(normalized[i])) i++;
+    if (i >= normalized.length) break;
+    if (normalized[i] === "[" || normalized[i] === "(" || normalized[i] === "{" || normalized[i] === "<") {
+      const openBracket = normalized[i];
+      const closeBracket = openBracket === "[" ? "]" : openBracket === "(" ? ")" : openBracket === "{" ? "}" : ">";
+      const bracketType = openBracket === "[" ? "square" : openBracket === "(" ? "paren" : openBracket === "{" ? "curly" : "angle";
+      let depth = 1;
+      let j = i + 1;
+      while (j < normalized.length && depth > 0) {
+        if (normalized[j] === openBracket) depth++;
+        else if (normalized[j] === closeBracket) depth--;
+        j++;
+      }
+      const inner = normalized.slice(i + 1, j - 1);
+      components.push({
+        type: "group",
+        key: bracketType,
+        styles: [],
+        children: parseFormat(inner)
+      });
+      i = j;
+      continue;
+    }
+    if (normalized.slice(i, i + 3) === "if:") {
+      const condStart = i + 3;
+      let condEnd = condStart;
+      while (condEnd < normalized.length && normalized[condEnd] !== "(") condEnd++;
+      const condition = normalized.slice(condStart, condEnd);
+      if (normalized[condEnd] === "(") {
+        let depth = 1;
+        let j = condEnd + 1;
+        while (j < normalized.length && depth > 0) {
+          if (normalized[j] === "(") depth++;
+          else if (normalized[j] === ")") depth--;
+          j++;
+        }
+        const inner = normalized.slice(condEnd + 1, j - 1);
+        components.push({
+          type: "conditional",
+          key: condition,
+          condition,
+          styles: [],
+          children: parseFormat(inner)
+        });
+        i = j;
+      } else {
+        i = condEnd;
+      }
+      continue;
+    }
+    let tokenEnd = i;
+    while (tokenEnd < normalized.length && !/[\s,\[\](){}<>]/.test(normalized[tokenEnd])) {
+      tokenEnd++;
+    }
+    const token = normalized.slice(i, tokenEnd);
+    if (token) {
+      if (token === ",") {
+        i = tokenEnd;
+        continue;
+      }
+      const component = parseComponent(token);
+      if (component) {
+        components.push(component);
+      }
+    }
+    i = tokenEnd;
+    while (i < normalized.length && (normalized[i] === "," || /\s/.test(normalized[i]))) i++;
+  }
+  return components;
+}
+function parseComponent(token) {
+  if (!token || token === ",") return null;
+  const styles = [];
+  let remaining = token;
+  while (true) {
+    const colonIdx = remaining.indexOf(":");
+    if (colonIdx === -1) break;
+    const prefix = remaining.slice(0, colonIdx);
+    if (STYLE_PREFIXES.has(prefix)) {
+      styles.push(prefix);
+      remaining = remaining.slice(colonIdx + 1);
+    } else {
+      break;
+    }
+  }
+  const parts = remaining.split(":");
+  if (parts.length === 0 || !parts[0]) {
+    return null;
+  }
+  if (parts[0] === "text") {
+    const text = parts.slice(1).join(":").replace(/^["']|["']$/g, "");
+    return { type: "text", key: text, styles };
+  }
+  if (parts[0] === "emoji") {
+    return { type: "emoji", key: parts[1] || "", styles };
+  }
+  if (parts[0] === "sep") {
+    return { type: "sep", key: parts[1] || "pipe", styles };
+  }
+  return {
+    type: parts[0],
+    key: parts[1] || "",
+    args: parts[2],
+    styles
+  };
+}
+function listComponents() {
+  const categories = [
+    {
+      name: "Claude/Session",
+      prefix: "claude",
+      items: ["model", "model-id", "version", "session", "session-full", "style"]
+    },
+    {
+      name: "Context Window",
+      prefix: "ctx",
+      items: ["percent", "remaining", "tokens", "in", "out", "size", "bar", "bar:N", "emoji", "used-tokens"]
+    },
+    {
+      name: "Cost/Usage",
+      prefix: "cost",
+      items: ["total", "total-cents", "duration", "api", "lines", "added", "removed", "lines-both"]
+    },
+    {
+      name: "File System",
+      prefix: "fs",
+      items: ["path", "dir", "project", "project-path", "home", "cwd", "relative"]
+    },
+    {
+      name: "Git",
+      prefix: "git",
+      items: [
+        "branch",
+        "status",
+        "status-emoji",
+        "status-word",
+        "ahead",
+        "behind",
+        "ahead-behind",
+        "stash",
+        "staged",
+        "modified",
+        "untracked",
+        "commit",
+        "commit-long",
+        "tag",
+        "remote",
+        "repo",
+        "user",
+        "email",
+        "remote-url"
+      ]
+    },
+    {
+      name: "Environment",
+      prefix: "env",
+      items: [
+        "node",
+        "node-short",
+        "bun",
+        "npm",
+        "pnpm",
+        "yarn",
+        "python",
+        "deno",
+        "rust",
+        "go",
+        "ruby",
+        "java",
+        "user",
+        "hostname",
+        "hostname-short",
+        "shell",
+        "term",
+        "os",
+        "arch",
+        "os-release",
+        "cpus",
+        "memory"
+      ]
+    },
+    {
+      name: "Time",
+      prefix: "time",
+      items: [
+        "now",
+        "seconds",
+        "12h",
+        "date",
+        "full",
+        "iso",
+        "unix",
+        "weekday",
+        "weekday-long",
+        "month",
+        "month-long",
+        "year",
+        "day",
+        "hour",
+        "minute",
+        "elapsed"
+      ]
+    },
+    {
+      name: "Separators",
+      prefix: "sep",
+      items: [
+        "pipe",
+        "arrow",
+        "arrow-left",
+        "chevron",
+        "chevron-left",
+        "dot",
+        "dash",
+        "slash",
+        "space",
+        "none",
+        "colon",
+        "double-colon",
+        "tilde",
+        "double-pipe",
+        "bullet",
+        "diamond",
+        "star",
+        "powerline",
+        "powerline-left"
+      ]
+    },
+    {
+      name: "Emojis",
+      prefix: "emoji",
+      items: [
+        "folder",
+        "file",
+        "home",
+        "branch",
+        "git",
+        "commit",
+        "merge",
+        "tag",
+        "stash",
+        "check",
+        "x",
+        "warn",
+        "error",
+        "success",
+        "info",
+        "star",
+        "fire",
+        "rocket",
+        "sparkle",
+        "lightning",
+        "heart",
+        "diamond",
+        "circle",
+        "square",
+        "triangle",
+        "node",
+        "python",
+        "rust",
+        "go",
+        "ruby",
+        "java",
+        "docker",
+        "green",
+        "yellow",
+        "orange",
+        "red",
+        "up",
+        "down",
+        "clock",
+        "calendar",
+        "money"
+      ]
+    },
+    {
+      name: "Text",
+      prefix: "text",
+      items: ["<custom text>"]
+    },
+    {
+      name: "Colors/Styles",
+      prefix: "",
+      items: [
+        "red:",
+        "green:",
+        "blue:",
+        "yellow:",
+        "magenta:",
+        "cyan:",
+        "white:",
+        "gray:",
+        "bold:",
+        "dim:",
+        "italic:",
+        "underline:",
+        "bg-red:",
+        "bg-green:",
+        "bg-blue:",
+        "bg-yellow:"
+      ]
+    },
+    {
+      name: "Conditionals",
+      prefix: "if",
+      items: ["git(...)", "dirty(...)", "node(...)", "python(...)"]
+    },
+    {
+      name: "Grouping",
+      prefix: "",
+      items: ["[...]", "(...)", "{...}", "<...>"]
+    }
+  ];
+  console.log("\n\x1B[1mAvailable Components:\x1B[0m\n");
+  for (const cat of categories) {
+    console.log(`\x1B[36m${cat.name}\x1B[0m`);
+    const prefix = cat.prefix ? `${cat.prefix}:` : "";
+    console.log(`  ${cat.items.map((i) => `${prefix}${i}`).join(", ")}`);
+    console.log();
+  }
+}
+
+// src/themes.ts
+var THEMES = {
+  minimal: "claude:model fs:dir",
+  default: "[claude:model] emoji:folder fs:dir if:git(sep:pipe emoji:branch git:branch git:status)",
+  powerline: "bold:cyan:claude:model sep:powerline fs:dir if:git(sep:powerline green:git:branch git:status)",
+  full: "[bold:cyan:claude:model] fs:home sep:arrow green:git:branch git:status sep:pipe ctx:bar ctx:percent sep:pipe cost:total",
+  git: "[claude:model] emoji:folder fs:dir sep:pipe emoji:branch git:branch git:status git:ahead-behind if:dirty(sep:pipe git:staged git:modified git:untracked)",
+  tokens: "claude:model sep:pipe ctx:emoji ctx:tokens sep:pipe cost:lines",
+  dev: "[fs:dir] git:branch sep:pipe env:node sep:pipe time:now",
+  dashboard: "[bold:claude:model] fs:dir sep:pipe git:branch git:status sep:pipe ctx:percent sep:pipe cost:total sep:pipe time:now",
+  "context-focus": "claude:model sep:pipe ctx:bar sep:pipe ctx:tokens sep:pipe ctx:emoji",
+  cost: "claude:model sep:pipe cost:total sep:pipe cost:duration sep:pipe cost:lines-both",
+  simple: "claude:model fs:dir git:branch",
+  verbose: "[claude:model] [claude:version] sep:pipe fs:home sep:pipe git:branch git:status git:ahead-behind sep:pipe ctx:bar ctx:percent sep:pipe cost:total cost:duration sep:pipe time:now",
+  nerd: "emoji:node env:node-short sep:dot emoji:folder fs:dir sep:dot emoji:branch git:branch git:status",
+  compact: "claude:model sep:slash fs:dir sep:slash git:branch",
+  colorful: "bold:magenta:claude:model sep:arrow cyan:fs:dir sep:arrow green:git:branch yellow:git:status sep:arrow blue:ctx:percent",
+  luca: "claude:model-letter git:repo git:branch git:dirty cost:total"
+};
+function getTheme(name) {
+  return THEMES[name] || null;
+}
+function listThemes() {
+  console.log("\n\x1B[1mAvailable Themes:\x1B[0m\n");
+  for (const [name, format] of Object.entries(THEMES)) {
+    console.log(`\x1B[36m${name}\x1B[0m`);
+    console.log(`  ${format}`);
+    console.log();
+  }
+}
+
+// src/installer.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+function getClaudeDir(project) {
+  if (project) {
+    return path.join(process.cwd(), ".claude");
+  }
+  return path.join(os.homedir(), ".claude");
+}
+function escapeForShell(str) {
+  return str.replace(/'/g, "'\\''");
+}
+function detectPackageRunner() {
+  if (process.versions.bun || process.env.BUN_INSTALL) {
+    return "bunx";
+  }
+  return "npx";
+}
+function buildCommand(format, options) {
+  const parts = [];
+  if (options.globalInstall) {
+    parts.push("claudeline");
+  } else if (options.useBunx) {
+    parts.push("bunx claudeline");
+  } else if (options.useNpx) {
+    parts.push("npx claudeline");
+  } else {
+    parts.push(`${detectPackageRunner()} claudeline`);
+  }
+  parts.push("run");
+  parts.push(`'${escapeForShell(format)}'`);
+  if (options.noEmoji) {
+    parts.push("--disable-emoji");
+  }
+  if (options.noColor) {
+    parts.push("--disable-color");
+  }
+  return parts.join(" ");
+}
+function install(format, project = false, options = {}) {
+  const claudeDir = getClaudeDir(project);
+  const settingsPath = path.join(claudeDir, "settings.json");
+  try {
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    }
+    const command = buildCommand(format, options);
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      } catch {
+      }
+    }
+    settings.statusLine = {
+      type: "command",
+      command,
+      padding: 0
+    };
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    return {
+      success: true,
+      message: `Updated settings at ${settingsPath}
+Command: ${command}`
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to install: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function uninstall(project = false) {
+  const claudeDir = getClaudeDir(project);
+  const settingsPath = path.join(claudeDir, "settings.json");
+  try {
+    if (fs.existsSync(settingsPath)) {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      delete settings.statusLine;
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    }
+    return {
+      success: true,
+      message: "Statusline configuration removed"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Failed to uninstall: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// src/preview.ts
+var SAMPLE_DATA = {
+  hook_event_name: "Status",
+  session_id: "abc123def456789",
+  transcript_path: "/tmp/transcript.json",
+  cwd: "/Users/demo/projects/myapp",
+  model: {
+    id: "claude-opus-4-1",
+    display_name: "Opus"
+  },
+  workspace: {
+    current_dir: "/Users/demo/projects/myapp",
+    project_dir: "/Users/demo/projects/myapp"
+  },
+  version: "1.0.80",
+  output_style: {
+    name: "default"
+  },
+  cost: {
+    total_cost_usd: 0.0234,
+    total_duration_ms: 125e3,
+    total_api_duration_ms: 4500,
+    total_lines_added: 156,
+    total_lines_removed: 23
+  },
+  context_window: {
+    total_input_tokens: 15234,
+    total_output_tokens: 4521,
+    context_window_size: 2e5,
+    used_percentage: 42.5,
+    remaining_percentage: 57.5,
+    current_usage: {
+      input_tokens: 8500,
+      output_tokens: 1200,
+      cache_creation_input_tokens: 5e3,
+      cache_read_input_tokens: 2e3
+    }
+  }
+};
+function getSampleDataJson() {
+  return JSON.stringify(SAMPLE_DATA, null, 2);
+}
+
+// src/runtime.ts
+import * as path2 from "path";
+import * as os2 from "os";
+import * as fs2 from "fs";
+import { execSync } from "child_process";
+
+// src/separators.ts
+var SEPARATORS = {
+  pipe: " | ",
+  arrow: " \u2192 ",
+  "arrow-left": " \u2190 ",
+  "arrow-right": " \u2192 ",
+  chevron: " \u203A ",
+  "chevron-left": " \u2039 ",
+  dot: " \u2022 ",
+  dash: " - ",
+  slash: " / ",
+  backslash: " \\ ",
+  space: " ",
+  none: "",
+  colon: ": ",
+  "double-colon": " :: ",
+  tilde: " ~ ",
+  "double-pipe": " \u2016 ",
+  bullet: " \u25E6 ",
+  diamond: " \u25C7 ",
+  star: " \u2605 ",
+  // Powerline-style
+  powerline: "",
+  "powerline-left": "",
+  "powerline-thin": "",
+  "powerline-thin-left": ""
+};
+function getSeparator(name) {
+  return SEPARATORS[name] ?? " | ";
+}
+
+// src/emojis.ts
+var EMOJIS = {
+  // Files & Folders
+  folder: "\u{1F4C1}",
+  file: "\u{1F4C4}",
+  home: "\u{1F3E0}",
+  // Git
+  branch: "\u{1F33F}",
+  git: "",
+  commit: "\u{1F4DD}",
+  merge: "\u{1F500}",
+  tag: "\u{1F3F7}\uFE0F",
+  stash: "\u{1F4E6}",
+  // Status
+  check: "\u2713",
+  x: "\u2717",
+  warn: "\u26A0",
+  error: "\u274C",
+  success: "\u2705",
+  info: "\u2139",
+  // Decorative
+  star: "\u2605",
+  fire: "\u{1F525}",
+  rocket: "\u{1F680}",
+  sparkle: "\u2728",
+  lightning: "\u26A1",
+  heart: "\u2764",
+  diamond: "\u25C6",
+  circle: "\u25CF",
+  square: "\u25A0",
+  triangle: "\u25B2",
+  // Tech
+  node: "\u2B22",
+  python: "\u{1F40D}",
+  rust: "\u{1F980}",
+  go: "\u{1F439}",
+  ruby: "\u{1F48E}",
+  java: "\u2615",
+  docker: "\u{1F433}",
+  // Context indicators
+  green: "\u{1F7E2}",
+  yellow: "\u{1F7E1}",
+  orange: "\u{1F7E0}",
+  red: "\u{1F534}",
+  // Arrows
+  up: "\u2191",
+  down: "\u2193",
+  left: "\u2190",
+  right: "\u2192",
+  "up-down": "\u2195",
+  // Time
+  clock: "\u{1F550}",
+  calendar: "\u{1F4C5}",
+  // Money
+  money: "\u{1F4B0}",
+  dollar: "\u{1F4B5}"
+};
+function getEmoji(name) {
+  return EMOJIS[name] || "";
+}
+
+// src/runtime.ts
+function formatTokens(n) {
+  if (n >= 1e6) return Math.round(n / 1e6) + "M";
+  if (n >= 1e3) return Math.round(n / 1e3) + "k";
+  return n.toString();
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return ms + "ms";
+  if (ms < 6e4) return (ms / 1e3).toFixed(1) + "s";
+  if (ms < 36e5) return Math.round(ms / 6e4) + "m";
+  return (ms / 36e5).toFixed(1) + "h";
+}
+function execCommand(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf8" }).trim();
+  } catch {
+    return "";
+  }
+}
+function applyStyles(text, styles, noColor) {
+  if (noColor || styles.length === 0 || !text) return text;
+  const codes = styles.map((s) => COLORS[s]).filter(Boolean);
+  if (codes.length === 0) return text;
+  return `\x1B[${codes.join(";")}m${text}\x1B[${RESET}m`;
+}
+function evaluateClaudeComponent(key, data) {
+  switch (key) {
+    case "model":
+      return data.model?.display_name || "Claude";
+    case "model-id":
+      return data.model?.id || "";
+    case "model-letter":
+      return (data.model?.display_name || "C")[0].toUpperCase();
+    case "version":
+      return data.version || "";
+    case "session":
+      return (data.session_id || "").slice(0, 8);
+    case "session-full":
+      return data.session_id || "";
+    case "style":
+      return data.output_style?.name || "default";
+    default:
+      return "";
+  }
+}
+function evaluateFsComponent(key, data) {
+  switch (key) {
+    case "path":
+      return data.workspace?.current_dir || data.cwd || "";
+    case "dir":
+      return path2.basename(data.workspace?.current_dir || data.cwd || "");
+    case "project":
+      return path2.basename(data.workspace?.project_dir || "");
+    case "project-path":
+      return data.workspace?.project_dir || "";
+    case "home":
+      return (data.workspace?.current_dir || data.cwd || "").replace(os2.homedir(), "~");
+    case "cwd":
+      return data.cwd || "";
+    case "relative": {
+      const curr = data.workspace?.current_dir || "";
+      const proj = data.workspace?.project_dir || "";
+      if (proj && curr.startsWith(proj)) {
+        return curr.slice(proj.length + 1) || ".";
+      }
+      return path2.basename(curr);
+    }
+    default:
+      return "";
+  }
+}
+function evaluateGitComponent(key) {
+  switch (key) {
+    case "branch":
+      return execCommand("git branch --show-current 2>/dev/null");
+    case "status":
+      try {
+        execSync("git diff --quiet 2>/dev/null");
+        return "\u2713";
+      } catch {
+        return "*";
+      }
+    case "status-emoji":
+      try {
+        execSync("git diff --quiet 2>/dev/null");
+        return "\u2728";
+      } catch {
+        return "\u{1F4DD}";
+      }
+    case "status-word":
+      try {
+        execSync("git diff --quiet 2>/dev/null");
+        return "clean";
+      } catch {
+        return "dirty";
+      }
+    case "ahead": {
+      const n = execCommand("git rev-list --count @{u}..HEAD 2>/dev/null");
+      return n && n !== "0" ? "\u2191" + n : "";
+    }
+    case "behind": {
+      const n = execCommand("git rev-list --count HEAD..@{u} 2>/dev/null");
+      return n && n !== "0" ? "\u2193" + n : "";
+    }
+    case "ahead-behind": {
+      const ahead = execCommand("git rev-list --count @{u}..HEAD 2>/dev/null");
+      const behind = execCommand("git rev-list --count HEAD..@{u} 2>/dev/null");
+      let result = "";
+      if (ahead && ahead !== "0") result += "\u2191" + ahead;
+      if (behind && behind !== "0") result += "\u2193" + behind;
+      return result;
+    }
+    case "stash": {
+      const n = execCommand("git stash list 2>/dev/null | wc -l").trim();
+      return n && n !== "0" ? "\u2691" + n : "";
+    }
+    case "staged": {
+      const n = execCommand("git diff --cached --numstat 2>/dev/null | wc -l").trim();
+      return n && n !== "0" ? "\u25CF" + n : "";
+    }
+    case "modified": {
+      const n = execCommand("git diff --numstat 2>/dev/null | wc -l").trim();
+      return n && n !== "0" ? "+" + n : "";
+    }
+    case "untracked": {
+      const n = execCommand("git ls-files --others --exclude-standard 2>/dev/null | wc -l").trim();
+      return n && n !== "0" ? "?" + n : "";
+    }
+    case "dirty": {
+      const staged = parseInt(execCommand("git diff --cached --numstat 2>/dev/null | wc -l")) || 0;
+      const modified = parseInt(execCommand("git diff --numstat 2>/dev/null | wc -l")) || 0;
+      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 (staged > 0) parts.push("+" + staged);
+      if (untracked > 0) parts.push("-" + untracked);
+      if (modified > 0) parts.push("~" + modified);
+      return parts.join(" ");
+    }
+    case "commit":
+      return execCommand("git rev-parse --short HEAD 2>/dev/null");
+    case "commit-long":
+      return execCommand("git rev-parse HEAD 2>/dev/null");
+    case "tag":
+      return execCommand("git describe --tags --abbrev=0 2>/dev/null");
+    case "remote":
+      return execCommand("git remote 2>/dev/null").split("\n")[0] || "";
+    case "repo":
+      return path2.basename(execCommand("git rev-parse --show-toplevel 2>/dev/null"));
+    case "user":
+      return execCommand("git config user.name 2>/dev/null");
+    case "email":
+      return execCommand("git config user.email 2>/dev/null");
+    case "remote-url":
+      return execCommand("git remote get-url origin 2>/dev/null");
+    default:
+      return "";
+  }
+}
+function evaluateContextComponent(key, data, args) {
+  const ctx = data.context_window;
+  switch (key) {
+    case "percent":
+      return Math.round(ctx?.used_percentage || 0) + "%";
+    case "remaining":
+      return Math.round(ctx?.remaining_percentage || 0) + "%";
+    case "tokens": {
+      const used = (ctx?.total_input_tokens || 0) + (ctx?.total_output_tokens || 0);
+      const total = ctx?.context_window_size || 2e5;
+      return formatTokens(used) + "/" + formatTokens(total);
+    }
+    case "in":
+      return formatTokens(ctx?.total_input_tokens || 0);
+    case "out":
+      return formatTokens(ctx?.total_output_tokens || 0);
+    case "size":
+      return formatTokens(ctx?.context_window_size || 2e5);
+    case "bar": {
+      const pct = 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) + "]";
+    }
+    case "emoji": {
+      const pct = ctx?.used_percentage || 0;
+      if (pct < 50) return "\u{1F7E2}";
+      if (pct < 75) return "\u{1F7E1}";
+      if (pct < 90) return "\u{1F7E0}";
+      return "\u{1F534}";
+    }
+    case "used-tokens": {
+      const used = (ctx?.total_input_tokens || 0) + (ctx?.total_output_tokens || 0);
+      return formatTokens(used);
+    }
+    default:
+      return "";
+  }
+}
+function evaluateCostComponent(key, data) {
+  const cost = data.cost;
+  switch (key) {
+    case "total":
+      return "$" + (cost?.total_cost_usd || 0).toFixed(2);
+    case "total-cents":
+      return Math.round((cost?.total_cost_usd || 0) * 100) + "\xA2";
+    case "duration":
+      return formatDuration(cost?.total_duration_ms || 0);
+    case "api":
+    case "api-duration":
+      return formatDuration(cost?.total_api_duration_ms || 0);
+    case "lines": {
+      const added = cost?.total_lines_added || 0;
+      const removed = cost?.total_lines_removed || 0;
+      const net = added - removed;
+      return (net >= 0 ? "+" : "") + net;
+    }
+    case "added":
+    case "lines-added":
+      return "+" + (cost?.total_lines_added || 0);
+    case "removed":
+    case "lines-removed":
+      return "-" + (cost?.total_lines_removed || 0);
+    case "lines-both": {
+      const added = cost?.total_lines_added || 0;
+      const removed = cost?.total_lines_removed || 0;
+      return "+" + added + " -" + removed;
+    }
+    default:
+      return "";
+  }
+}
+function evaluateEnvComponent(key) {
+  switch (key) {
+    case "node":
+      return execCommand("node --version 2>/dev/null");
+    case "node-short":
+      return execCommand("node --version 2>/dev/null").replace("v", "");
+    case "bun":
+      return execCommand("bun --version 2>/dev/null");
+    case "npm":
+      return execCommand("npm --version 2>/dev/null");
+    case "pnpm":
+      return execCommand("pnpm --version 2>/dev/null");
+    case "yarn":
+      return execCommand("yarn --version 2>/dev/null");
+    case "python":
+      return execCommand("python3 --version 2>/dev/null || python --version 2>/dev/null").replace("Python ", "");
+    case "deno":
+      return execCommand("deno --version 2>/dev/null").split("\n")[0].replace("deno ", "");
+    case "rust":
+      return execCommand("rustc --version 2>/dev/null").split(" ")[1] || "";
+    case "go":
+      return execCommand("go version 2>/dev/null").split(" ")[2]?.replace("go", "") || "";
+    case "ruby":
+      return execCommand("ruby --version 2>/dev/null").split(" ")[1] || "";
+    case "java": {
+      const output = execCommand("java -version 2>&1");
+      const match = output.match(/"([^"]+)"/);
+      return match?.[1] || "";
+    }
+    case "user":
+      return os2.userInfo().username;
+    case "hostname":
+      return os2.hostname();
+    case "hostname-short":
+      return os2.hostname().split(".")[0];
+    case "shell":
+      return path2.basename(process.env.SHELL || "");
+    case "term":
+      return process.env.TERM || "";
+    case "os":
+      return process.platform;
+    case "arch":
+      return process.arch;
+    case "os-release":
+      return os2.release();
+    case "cpus":
+      return os2.cpus().length.toString();
+    case "memory":
+      return Math.round(os2.totalmem() / 1024 / 1024 / 1024) + "GB";
+    default:
+      return "";
+  }
+}
+function evaluateTimeComponent(key, data) {
+  const now = /* @__PURE__ */ new Date();
+  switch (key) {
+    case "now":
+      return now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+    case "seconds":
+      return now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+    case "12h":
+      return now.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", hour12: true });
+    case "date":
+      return now.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    case "full":
+      return now.toISOString().split("T")[0];
+    case "iso":
+      return now.toISOString();
+    case "unix":
+      return Math.floor(Date.now() / 1e3).toString();
+    case "weekday":
+      return now.toLocaleDateString("en-US", { weekday: "short" });
+    case "weekday-long":
+      return now.toLocaleDateString("en-US", { weekday: "long" });
+    case "month":
+      return now.toLocaleDateString("en-US", { month: "short" });
+    case "month-long":
+      return now.toLocaleDateString("en-US", { month: "long" });
+    case "year":
+      return now.getFullYear().toString();
+    case "day":
+      return now.getDate().toString();
+    case "hour":
+      return now.getHours().toString().padStart(2, "0");
+    case "minute":
+      return now.getMinutes().toString().padStart(2, "0");
+    case "elapsed": {
+      const ms = data.cost?.total_duration_ms || 0;
+      if (ms < 6e4) return Math.round(ms / 1e3) + "s";
+      if (ms < 36e5) return Math.round(ms / 6e4) + "m";
+      return Math.round(ms / 36e5) + "h";
+    }
+    default:
+      return "";
+  }
+}
+function evaluateCondition(condition) {
+  switch (condition) {
+    case "git":
+      try {
+        execSync("git rev-parse --git-dir 2>/dev/null");
+        return true;
+      } catch {
+        return false;
+      }
+    case "dirty":
+      try {
+        execSync("git diff --quiet 2>/dev/null");
+        return false;
+      } catch {
+        return true;
+      }
+    case "clean":
+      try {
+        execSync("git diff --quiet 2>/dev/null");
+        return true;
+      } catch {
+        return false;
+      }
+    case "node":
+      return fs2.existsSync("package.json");
+    case "python":
+      return fs2.existsSync("pyproject.toml") || fs2.existsSync("setup.py") || fs2.existsSync("requirements.txt");
+    case "rust":
+      return fs2.existsSync("Cargo.toml");
+    case "go":
+      return fs2.existsSync("go.mod");
+    default:
+      return true;
+  }
+}
+function evaluateComponent(comp, data, options) {
+  let result = "";
+  switch (comp.type) {
+    case "claude":
+      result = evaluateClaudeComponent(comp.key, data);
+      break;
+    case "fs":
+      result = evaluateFsComponent(comp.key, data);
+      break;
+    case "git":
+      result = evaluateGitComponent(comp.key);
+      break;
+    case "ctx":
+      result = evaluateContextComponent(comp.key, data, comp.args);
+      break;
+    case "cost":
+      result = evaluateCostComponent(comp.key, data);
+      break;
+    case "env":
+      result = evaluateEnvComponent(comp.key);
+      break;
+    case "time":
+      result = evaluateTimeComponent(comp.key, data);
+      break;
+    case "sep":
+      result = getSeparator(comp.key);
+      break;
+    case "emoji":
+      result = options.noEmoji ? "" : getEmoji(comp.key);
+      break;
+    case "text":
+      result = comp.key;
+      break;
+    case "group": {
+      if (comp.children) {
+        const inner = evaluateComponents(comp.children, data, options);
+        const brackets = {
+          square: ["[", "]"],
+          paren: ["(", ")"],
+          curly: ["{", "}"],
+          angle: ["<", ">"]
+        };
+        const [open, close] = brackets[comp.key] || ["[", "]"];
+        result = open + inner + close;
+      }
+      break;
+    }
+    case "conditional": {
+      if (comp.children && evaluateCondition(comp.key)) {
+        result = evaluateComponents(comp.children, data, options);
+      }
+      break;
+    }
+  }
+  return applyStyles(result, comp.styles, options.noColor);
+}
+function evaluateComponents(components, data, options) {
+  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" && prev?.type !== "sep" && value) {
+      parts.push(" ");
+    }
+    if (value) {
+      parts.push(value);
+    }
+  }
+  return parts.join("");
+}
+function evaluateFormat(format, data, options = {}) {
+  const opts = {
+    noEmoji: options.noEmoji ?? false,
+    noColor: options.noColor ?? false
+  };
+  const components = parseFormat(format);
+  return evaluateComponents(components, data, opts);
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      input += chunk;
+    });
+    process.stdin.on("end", () => {
+      resolve(input);
+    });
+    process.stdin.on("error", reject);
+  });
+}
+program.command("run <format>").description("Evaluate a format string and output the status line").option("--disable-emoji", "Disable emoji output").option("--disable-color", "Disable color output").action(async (format, options) => {
+  try {
+    const input = await readStdin();
+    const data = JSON.parse(input);
+    const output = evaluateFormat(format, data, {
+      noEmoji: options.disableEmoji ?? false,
+      noColor: options.disableColor ?? false
+    });
+    console.log(output);
+  } catch (e) {
+    console.log("[claudeline]");
+  }
+});
+program.name("claudeline").description("Customizable status line generator for Claude Code").version(VERSION).argument("[format]", "Status line format string").option("-i, --install", "Install directly to ~/.claude/").option("-u, --uninstall", "Remove statusline configuration").option("--project", "Install/uninstall to project .claude/ instead of global").option("-t, --theme <name>", "Use a preset theme").option("-l, --list", "List all available components").option("--themes", "List all available themes").option("-p, --preview", "Show sample JSON data for testing").option("--no-emoji", "Disable emoji output").option("--no-color", "Disable color output").option("--use-bunx", "Use bunx in installed command").option("--use-npx", "Use npx in installed command").option("--global-install", "Assume claudeline is globally installed (use claudeline directly)").addHelpText("after", `
+Examples:
+  $ npx claudeline --theme minimal --install
+  $ npx claudeline --theme powerline --install --project
+  $ npx claudeline --list
+  $ npx claudeline --themes
+
+  # Test the run command directly:
+  $ echo '{"model":{"display_name":"Sonnet"}}' | npx claudeline run "claude:model fs:dir"
+
+Format Syntax:
+  component       Single component (e.g., fs:dir, git:branch)
+  prefix:comp     Styled component (e.g., green:git:branch, bold:red:text:ERROR)
+  sep:name        Separator (e.g., sep:pipe, sep:arrow)
+  emoji:name      Emoji (e.g., emoji:folder, emoji:branch)
+  text:value      Custom text (e.g., text:Hello)
+  [...]           Group with square brackets
+  if:cond(...)    Conditional (e.g., if:git(git:branch))
+
+Components can be separated by spaces or commas.
+Multiple style prefixes can be chained: bold:green:git:branch
+`).action((format, options) => {
+  if (options.list) {
+    listComponents();
+    return;
+  }
+  if (options.themes) {
+    listThemes();
+    return;
+  }
+  if (options.uninstall) {
+    const result = uninstall(options.project);
+    console.log(result.message);
+    process.exit(result.success ? 0 : 1);
+  }
+  if (options.preview) {
+    console.log("Sample JSON input for testing:\n");
+    console.log(getSampleDataJson());
+    console.log("\nTest with the run command:");
+    console.log(`  echo '<json>' | npx claudeline run "claude:model fs:dir"`);
+    return;
+  }
+  let formatStr = format;
+  if (options.theme) {
+    const theme = getTheme(options.theme);
+    if (!theme) {
+      console.error(`Unknown theme: ${options.theme}`);
+      console.error(`Available themes: ${Object.keys(THEMES).join(", ")}`);
+      process.exit(1);
+    }
+    formatStr = theme;
+  }
+  if (!formatStr) {
+    formatStr = THEMES.default;
+  }
+  const components = parseFormat(formatStr);
+  if (components.length === 0) {
+    console.error("No valid components found in format string");
+    process.exit(1);
+  }
+  if (options.install) {
+    const result = install(formatStr, options.project, {
+      useBunx: options.useBunx,
+      useNpx: options.useNpx,
+      globalInstall: options.globalInstall,
+      noEmoji: !options.emoji,
+      noColor: !options.color
+    });
+    if (result.success) {
+      console.log("\u2713 " + result.message);
+      console.log("\nRestart Claude Code to see your new status line!");
+    } else {
+      console.error("\u2717 " + result.message);
+      process.exit(1);
+    }
+    return;
+  }
+  console.log("Format string validated. Use --install to install.");
+  console.log(`Command: npx claudeline run '${formatStr}'`);
+});
+program.parse();