@hasna/statusline 0.0.1 → 0.0.3

package/dist/cli.js

@@ -0,0 +1,1303 @@
+#!/usr/bin/env bun
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function defaultConfig() {
+  return {
+    separator: " \xB7 ",
+    colors: true,
+    segments: [
+      "machine",
+      "project",
+      "commit-age",
+      "loc",
+      "model-context",
+      "context-remaining",
+      "cost"
+    ]
+  };
+}
+function configPath(path) {
+  if (path)
+    return path;
+  if (process.env.STATUSLINE_CONFIG)
+    return process.env.STATUSLINE_CONFIG;
+  const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(base, "statusline", "config.json");
+}
+function loadConfig(path = configPath()) {
+  if (!existsSync(path))
+    return defaultConfig();
+  try {
+    const raw = JSON.parse(readFileSync(path, "utf8"));
+    const fallback = defaultConfig();
+    return {
+      separator: typeof raw.separator === "string" ? raw.separator : fallback.separator,
+      segments: Array.isArray(raw.segments) ? raw.segments.filter((s) => typeof s === "string") : fallback.segments,
+      colors: typeof raw.colors === "boolean" ? raw.colors : fallback.colors
+    };
+  } catch {
+    return defaultConfig();
+  }
+}
+function saveConfig(cfg, path = configPath()) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cfg, null, 2) + `
+`);
+}
+
+// src/providers/claude.ts
+function parseClaudeInput(input) {
+  const cwd = input?.cwd || input?.workspace?.current_dir || process.cwd();
+  return {
+    provider: "claude",
+    cwd,
+    projectDir: input?.workspace?.project_dir || undefined,
+    model: input?.model ? { id: input.model.id || undefined, displayName: input.model.display_name || undefined } : undefined,
+    cost: input?.cost ? {
+      totalCostUsd: numberOr(input.cost.total_cost_usd),
+      totalDurationMs: numberOr(input.cost.total_duration_ms),
+      totalLinesAdded: numberOr(input.cost.total_lines_added),
+      totalLinesRemoved: numberOr(input.cost.total_lines_removed)
+    } : undefined,
+    transcriptPath: input?.transcript_path || undefined,
+    sessionId: input?.session_id || undefined,
+    sessionName: input?.session_name || undefined,
+    version: input?.version || undefined,
+    outputStyle: input?.output_style?.name || undefined,
+    effort: input?.effort?.level || undefined,
+    thinking: typeof input?.thinking?.enabled === "boolean" ? input.thinking.enabled : undefined,
+    rateLimits: input?.rate_limits ? {
+      fiveHour: { usedPercentage: numberOr(input.rate_limits.five_hour?.used_percentage) },
+      sevenDay: { usedPercentage: numberOr(input.rate_limits.seven_day?.used_percentage) }
+    } : undefined
+  };
+}
+function numberOr(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}
+
+// src/segments/index.ts
+import { hostname } from "os";
+
+// src/format.ts
+function compactAge(seconds) {
+  if (seconds < 60)
+    return `${Math.floor(seconds)}s`;
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400)
+    return `${Math.floor(seconds / 3600)}h`;
+  if (seconds < 604800)
+    return `${Math.floor(seconds / 86400)}d`;
+  if (seconds < 2592000)
+    return `${Math.floor(seconds / 604800)}w`;
+  if (seconds < 31536000)
+    return `${Math.floor(seconds / 2592000)}mo`;
+  return `${Math.floor(seconds / 31536000)}y`;
+}
+function trimmed(value) {
+  const fixed = value.toFixed(1);
+  return fixed.endsWith(".0") ? fixed.slice(0, -2) : fixed;
+}
+function compactNum(n) {
+  if (n >= 1e6)
+    return `${trimmed(n / 1e6)}m`;
+  if (n >= 1e4)
+    return `${Math.floor(n / 1000)}k`;
+  if (n >= 1000)
+    return `${trimmed(n / 1000)}k`;
+  return `${n}`;
+}
+function money(n) {
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function compactDuration(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 60)
+    return `${s}s`;
+  if (s < 3600) {
+    const rem2 = s % 60;
+    return rem2 ? `${Math.floor(s / 60)}m${rem2}s` : `${Math.floor(s / 60)}m`;
+  }
+  const rem = Math.floor(s % 3600 / 60);
+  return rem ? `${Math.floor(s / 3600)}h${rem}m` : `${Math.floor(s / 3600)}h`;
+}
+
+// src/git.ts
+function run(cwd, args) {
+  try {
+    const proc = Bun.spawnSync(["git", "-c", "gc.auto=0", ...args], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    if (proc.exitCode !== 0)
+      return null;
+    const out = proc.stdout.toString().trim();
+    return out.length ? out : null;
+  } catch {
+    return null;
+  }
+}
+function gitRoot(cwd) {
+  return run(cwd, ["rev-parse", "--show-toplevel"]);
+}
+function gitBranch(cwd) {
+  return run(cwd, ["branch", "--show-current"]);
+}
+function gitProjectName(cwd) {
+  const root = gitRoot(cwd);
+  if (!root)
+    return null;
+  const remote = run(root, ["config", "--get", "remote.origin.url"]);
+  if (remote)
+    return remote.replace(/\.git$/, "").split("/").pop() || null;
+  return root.split("/").pop() || null;
+}
+function lastCommitEpoch(cwd) {
+  const out = run(cwd, ["log", "-1", "--format=%ct"]);
+  if (!out)
+    return null;
+  const ts = Number(out);
+  return Number.isFinite(ts) ? ts : null;
+}
+function trackedLineCount(cwd) {
+  const root = gitRoot(cwd);
+  if (!root)
+    return null;
+  try {
+    const proc = Bun.spawnSync(["bash", "-c", "git -c gc.auto=0 ls-files -z | xargs -0 wc -l 2>/dev/null | awk 'END {print $1+0}'"], { cwd: root, stdout: "pipe", stderr: "ignore" });
+    if (proc.exitCode !== 0)
+      return null;
+    const n = Number(proc.stdout.toString().trim());
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/context-window.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+function contextUsage(ctx) {
+  const path = ctx.transcriptPath;
+  if (!path || !existsSync2(path))
+    return null;
+  let lines;
+  try {
+    lines = readFileSync2(path, "utf8").split(`
+`);
+  } catch {
+    return null;
+  }
+  for (let i = lines.length - 1;i >= 0; i--) {
+    const line = lines[i];
+    if (!line || !line.includes('"usage"'))
+      continue;
+    try {
+      const entry = JSON.parse(line);
+      const usage = entry?.message?.usage;
+      if (!usage || typeof usage.input_tokens !== "number")
+        continue;
+      const used = usage.input_tokens + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
+      return {
+        used,
+        output: usage.output_tokens || 0,
+        window: windowSize(ctx)
+      };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function windowSize(ctx) {
+  return ctx.model?.id?.includes("[1m]") ? 1e6 : 200000;
+}
+
+// src/accounts.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2, resolve, sep } from "path";
+var CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+var DEFAULT_CONFIG_SUBDIR = ".claude";
+var STORE_PATH_ENV = "ACCOUNTS_STORE_PATH";
+var ACCOUNTS_HOME_ENV = "ACCOUNTS_HOME";
+var DEFAULT_ACCOUNTS_HOME = [".hasna", "accounts"];
+var STORE_FILE = "accounts.json";
+var PROFILES_SUBDIR = "profiles";
+var STATE_FILE_PREFERRED = ".config.json";
+var STATE_FILE_PREFIX = ".claude";
+var STATE_FILE_SUFFIX = ".json";
+var CUSTOM_OAUTH_ENV = "CLAUDE_CODE_CUSTOM_OAUTH_URL";
+var OAUTH_VARIANTS = ["", "-custom-oauth", "-local-oauth", "-staging-oauth"];
+function str(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function home(env) {
+  return str(env.HOME) ?? homedir2();
+}
+function expandHome(path, env) {
+  return path === "~" || path.startsWith(`~${sep}`) ? join2(home(env), path.slice(1)) : path;
+}
+function canonical(path, env) {
+  const abs = resolve(expandHome(path, env));
+  try {
+    return realpathSync(abs);
+  } catch {
+    return abs;
+  }
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var ACCOUNTS_STORAGE_MODULE = "@hasna/accounts/storage";
+var storagePromise;
+function accountsStorage() {
+  storagePromise ??= import(ACCOUNTS_STORAGE_MODULE).then((mod) => typeof mod?.storePath === "function" && typeof mod?.profilesDir === "function" ? mod : null, () => null);
+  return storagePromise;
+}
+async function accountsPaths(env) {
+  const homeOverride = str(env[ACCOUNTS_HOME_ENV]);
+  const storeOverride = str(env[STORE_PATH_ENV]);
+  if (!homeOverride && !storeOverride) {
+    const storage = await accountsStorage();
+    try {
+      if (storage)
+        return { store: storage.storePath(), profiles: storage.profilesDir() };
+    } catch {}
+  }
+  const base = homeOverride ?? join2(home(env), ...DEFAULT_ACCOUNTS_HOME);
+  return {
+    store: storeOverride ?? join2(base, STORE_FILE),
+    profiles: join2(base, PROFILES_SUBDIR)
+  };
+}
+function registryEntry(store, configDir, env, tool) {
+  if (!existsSync3(store))
+    return null;
+  const entries = readJson(store)?.profiles;
+  if (!Array.isArray(entries))
+    return null;
+  let untyped = null;
+  let first = null;
+  for (const entry of entries) {
+    const dir = str(entry?.dir);
+    if (!dir || canonical(dir, env) !== configDir)
+      continue;
+    const entryTool = str(entry?.tool);
+    if (tool && entryTool === tool)
+      return entry;
+    if (!entryTool)
+      untyped ??= entry;
+    first ??= entry;
+  }
+  return tool ? untyped : first;
+}
+function layoutProfile(profilesRoot, configDir, env) {
+  if (!existsSync3(configDir))
+    return null;
+  const prefix = canonical(profilesRoot, env) + sep;
+  if (!configDir.startsWith(prefix))
+    return null;
+  const parts = configDir.slice(prefix.length).split(sep);
+  if (parts.length !== 2)
+    return null;
+  const [tool, profile] = parts;
+  if (!tool || !profile)
+    return null;
+  return { configDir, profile, tool, source: "layout" };
+}
+function sessionConfigDir(env = process.env) {
+  return canonical(str(env[CONFIG_DIR_ENV]) ?? join2(home(env), DEFAULT_CONFIG_SUBDIR), env);
+}
+function sessionStateFile(env = process.env) {
+  const base = canonical(str(env[CONFIG_DIR_ENV]) ?? home(env), env);
+  const preferred = join2(base, STATE_FILE_PREFERRED);
+  if (existsSync3(preferred))
+    return preferred;
+  const variants = str(env[CUSTOM_OAUTH_ENV]) ? ["-custom-oauth", ...OAUTH_VARIANTS] : OAUTH_VARIANTS;
+  for (const variant of variants) {
+    const candidate = join2(base, `${STATE_FILE_PREFIX}${variant}${STATE_FILE_SUFFIX}`);
+    if (existsSync3(candidate))
+      return candidate;
+  }
+  return null;
+}
+async function sessionAccount(env = process.env, tool) {
+  const configDir = sessionConfigDir(env);
+  const unresolved = { configDir, profile: null, tool: null, source: null };
+  try {
+    const paths = await accountsPaths(env);
+    const entry = registryEntry(paths.store, configDir, env, tool);
+    const name = str(entry?.name);
+    if (name)
+      return { configDir, profile: name, tool: str(entry?.tool), source: "registry" };
+    return layoutProfile(paths.profiles, configDir, env) ?? unresolved;
+  } catch {
+    return unresolved;
+  }
+}
+async function sessionAccountEmail(env = process.env, tool) {
+  try {
+    const stateFile = sessionStateFile(env);
+    const live = stateFile ? str(readJson(stateFile)?.oauthAccount?.emailAddress) : null;
+    if (live)
+      return live;
+    const paths = await accountsPaths(env);
+    return str(registryEntry(paths.store, sessionConfigDir(env), env, tool)?.email);
+  } catch {
+    return null;
+  }
+}
+
+// src/segments/index.ts
+function friendlyModel(id) {
+  let tag = null;
+  let mid = id;
+  const tagMatch = mid.match(/\[([^\]]+)\]$/);
+  if (tagMatch) {
+    tag = `[${tagMatch[1]}]`;
+    mid = mid.slice(0, mid.length - tagMatch[0].length);
+  }
+  mid = mid.replace(/^claude-/, "").replace(/-\d{8}$/, "");
+  const tokens = mid.split("-").filter(Boolean);
+  const words = tokens.filter((t) => !/^\d+$/.test(t));
+  const nums = tokens.filter((t) => /^\d+$/.test(t));
+  const name = [words.join(" "), nums.join(".")].filter(Boolean).join(" ");
+  return { name: name || mid, tag };
+}
+var dir = (ctx) => ctx.cwd || process.cwd();
+function modelName(ctx) {
+  if (ctx.model?.displayName)
+    return ctx.model.displayName;
+  return ctx.model?.id ? friendlyModel(ctx.model.id).name : null;
+}
+function limitPercent(pct) {
+  return typeof pct === "number" ? pct : 0;
+}
+var segments = [
+  {
+    id: "machine",
+    description: "Machine hostname (short)",
+    defaultEnabled: true,
+    render: () => hostname().split(".")[0] || null
+  },
+  {
+    id: "project",
+    description: "Project name with current Git branch",
+    defaultEnabled: true,
+    render(ctx) {
+      const name = gitProjectName(dir(ctx)) || dir(ctx).split("/").pop() || null;
+      if (!name)
+        return null;
+      const branch = gitBranch(dir(ctx));
+      return branch ? `${name} (${branch})` : name;
+    }
+  },
+  {
+    id: "project-name",
+    description: "Project name (omitted when unavailable)",
+    defaultEnabled: false,
+    render: (ctx) => gitProjectName(dir(ctx)) || dir(ctx).split("/").pop() || null
+  },
+  {
+    id: "git-branch",
+    description: "Current Git branch (omitted when unavailable)",
+    defaultEnabled: false,
+    render: (ctx) => gitBranch(dir(ctx))
+  },
+  {
+    id: "commit-age",
+    description: "Time since last commit (compact)",
+    defaultEnabled: true,
+    render(ctx) {
+      const ts = lastCommitEpoch(dir(ctx));
+      if (!ts)
+        return null;
+      return compactAge(Date.now() / 1000 - ts);
+    }
+  },
+  {
+    id: "loc",
+    description: "Lines of code tracked by Git (compact)",
+    defaultEnabled: true,
+    render(ctx) {
+      const n = trackedLineCount(dir(ctx));
+      return n ? compactNum(n) : null;
+    }
+  },
+  {
+    id: "current-dir",
+    description: "Current working directory (basename)",
+    defaultEnabled: false,
+    render: (ctx) => dir(ctx).split("/").pop() || null
+  },
+  {
+    id: "model",
+    description: "Current model name",
+    defaultEnabled: false,
+    render(ctx) {
+      if (!ctx.model?.id)
+        return null;
+      return friendlyModel(ctx.model.id).name;
+    }
+  },
+  {
+    id: "model-context",
+    description: "Model name with context-size tag (e.g. [1m])",
+    defaultEnabled: true,
+    render(ctx) {
+      if (!ctx.model?.id)
+        return null;
+      const { name, tag } = friendlyModel(ctx.model.id);
+      return tag ? `${name} ${tag}` : name;
+    }
+  },
+  {
+    id: "model-with-reasoning",
+    description: "Model name with its reasoning effort (or thinking, when on)",
+    defaultEnabled: false,
+    color: "cyan",
+    render(ctx) {
+      const name = modelName(ctx);
+      if (!name)
+        return null;
+      if (ctx.effort)
+        return `${name} (${ctx.effort})`;
+      if (ctx.thinking)
+        return `${name} (thinking)`;
+      return name;
+    }
+  },
+  {
+    id: "auth-profile",
+    description: "Account profile this session runs as (omitted when unmanaged)",
+    defaultEnabled: false,
+    color: "magenta",
+    async render(ctx) {
+      const account = await sessionAccount(process.env, ctx.provider);
+      return account.profile ?? await sessionAccountEmail(process.env, ctx.provider);
+    }
+  },
+  {
+    id: "auth-email",
+    description: "Account email this session is logged in as (omitted when unknown)",
+    defaultEnabled: false,
+    color: "magenta",
+    render: (ctx) => sessionAccountEmail(process.env, ctx.provider)
+  },
+  {
+    id: "five-hour-limit",
+    description: "Percentage of the 5-hour rate limit used (omitted when unreported)",
+    defaultEnabled: false,
+    color: (ctx) => limitPercent(ctx.rateLimits?.fiveHour?.usedPercentage) >= 80 ? "red" : "yellow",
+    render(ctx) {
+      const pct = ctx.rateLimits?.fiveHour?.usedPercentage;
+      return typeof pct === "number" ? `5h:${Math.round(pct)}%` : null;
+    }
+  },
+  {
+    id: "seven-day-limit",
+    description: "Percentage of the 7-day rate limit used (omitted when unreported)",
+    defaultEnabled: false,
+    color: (ctx) => limitPercent(ctx.rateLimits?.sevenDay?.usedPercentage) >= 80 ? "red" : "yellow",
+    render(ctx) {
+      const pct = ctx.rateLimits?.sevenDay?.usedPercentage;
+      return typeof pct === "number" ? `7d:${Math.round(pct)}%` : null;
+    }
+  },
+  {
+    id: "thread-title",
+    description: "Thread title set with /rename (omitted until named)",
+    defaultEnabled: false,
+    color: "blue",
+    render: (ctx) => ctx.sessionName || null
+  },
+  {
+    id: "context-used",
+    description: "Percentage of context window used (omitted when unknown)",
+    defaultEnabled: false,
+    render(ctx) {
+      const u = contextUsage(ctx);
+      if (!u)
+        return null;
+      return `${Math.min(100, Math.round(u.used / u.window * 100))}%`;
+    }
+  },
+  {
+    id: "context-remaining",
+    description: "Percentage of context window remaining (omitted when unknown)",
+    defaultEnabled: true,
+    render(ctx) {
+      const u = contextUsage(ctx);
+      if (!u)
+        return null;
+      return `${Math.max(0, 100 - Math.round(u.used / u.window * 100))}% left`;
+    }
+  },
+  {
+    id: "used-tokens",
+    description: "Total tokens in the context window (omitted when unknown)",
+    defaultEnabled: false,
+    render(ctx) {
+      const u = contextUsage(ctx);
+      if (!u)
+        return null;
+      return `${compactNum(u.used + u.output)} tok`;
+    }
+  },
+  {
+    id: "cost",
+    description: "Session cost in USD (omitted when zero)",
+    defaultEnabled: true,
+    render(ctx) {
+      const c = ctx.cost?.totalCostUsd;
+      return c ? money(c) : null;
+    }
+  },
+  {
+    id: "duration",
+    description: "Session wall-clock duration",
+    defaultEnabled: false,
+    render(ctx) {
+      const ms = ctx.cost?.totalDurationMs;
+      return ms ? compactDuration(ms) : null;
+    }
+  },
+  {
+    id: "lines-changed",
+    description: "Lines added/removed this session (omitted when zero)",
+    defaultEnabled: false,
+    render(ctx) {
+      const a = ctx.cost?.totalLinesAdded || 0;
+      const r = ctx.cost?.totalLinesRemoved || 0;
+      if (!a && !r)
+        return null;
+      return `+${a}/-${r}`;
+    }
+  },
+  {
+    id: "output-style",
+    description: "Active output style (omitted when default)",
+    defaultEnabled: false,
+    render(ctx) {
+      const s = ctx.outputStyle;
+      return s && s !== "default" ? s : null;
+    }
+  },
+  {
+    id: "agent-version",
+    description: "Host agent version (e.g. Claude Code version)",
+    defaultEnabled: false,
+    render: (ctx) => ctx.version ? `v${ctx.version}` : null
+  },
+  {
+    id: "session-id",
+    description: "Session identifier (short)",
+    defaultEnabled: false,
+    render: (ctx) => ctx.sessionId ? ctx.sessionId.split("-")[0] : null
+  }
+];
+function getSegment(id) {
+  return segments.find((s) => s.id === id);
+}
+
+// src/render.ts
+var ANSI = {
+  cyan: "\x1B[36m",
+  magenta: "\x1B[35m",
+  blue: "\x1B[34m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m"
+};
+var RESET = "\x1B[0m";
+function colorsEnabled(cfg, env = process.env) {
+  if (env.NO_COLOR)
+    return false;
+  return cfg.colors !== false;
+}
+function paint(segment, text, ctx) {
+  const color = typeof segment.color === "function" ? segment.color(ctx) : segment.color;
+  const code = color ? ANSI[color] : undefined;
+  return code ? `${code}${text}${RESET}` : text;
+}
+async function renderLine(ctx, cfg) {
+  const colorize = colorsEnabled(cfg);
+  const parts = [];
+  for (const id of cfg.segments) {
+    const segment = getSegment(id);
+    if (!segment)
+      continue;
+    try {
+      const out = await segment.render(ctx);
+      if (out)
+        parts.push(colorize ? paint(segment, out, ctx) : out);
+    } catch {}
+  }
+  return parts.join(cfg.separator);
+}
+// package.json
+var package_default = {
+  name: "@hasna/statusline",
+  version: "0.0.3",
+  description: "Tiny composable statusline CLI for AI coding agents \u2014 pre-built toggleable segments for Claude Code, with a provider model for others",
+  license: "Apache-2.0",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    statusline: "./dist/cli.js",
+    "statusline-mcp": "./dist/mcp/index.js"
+  },
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./cli": {
+      types: "./dist/cli.d.ts",
+      import: "./dist/cli.js"
+    },
+    "./mcp": {
+      types: "./dist/mcp/index.d.ts",
+      import: "./dist/mcp/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  scripts: {
+    build: "rm -rf dist && bun build src/index.ts src/cli.ts src/mcp/index.ts --outdir dist --target bun && tsc -p tsconfig.build.json && chmod +x dist/cli.js dist/mcp/index.js",
+    typecheck: "tsc --noEmit",
+    test: "bun test",
+    check: "bun run typecheck && bun test && bun run build",
+    prepack: "bun run build",
+    prepublishOnly: "bun run typecheck && bun test && bun run build"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/hasna/statusline.git"
+  },
+  homepage: "https://github.com/hasna/statusline#readme",
+  bugs: {
+    url: "https://github.com/hasna/statusline/issues"
+  },
+  keywords: [
+    "statusline",
+    "status-bar",
+    "claude-code",
+    "cli",
+    "bun"
+  ],
+  publishConfig: {
+    registry: "https://registry.npmjs.org",
+    access: "public"
+  },
+  engines: {
+    bun: ">=1.0.0"
+  },
+  dependencies: {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    zod: "^3.25.76"
+  },
+  devDependencies: {
+    "@types/bun": "^1.2.4",
+    typescript: "^5.7.3"
+  }
+};
+// src/install.ts
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+function defaultSettingsPath(env) {
+  return join3(env.HOME || homedir3(), ".claude", "settings.json");
+}
+function claudeSettingsPath(env = process.env) {
+  const home2 = env.HOME || homedir3();
+  const raw = env.CLAUDE_CONFIG_DIR?.trim();
+  if (!raw)
+    return defaultSettingsPath(env);
+  const configDir = raw === "~" || raw.startsWith("~/") ? join3(home2, raw.slice(1)) : raw;
+  return join3(configDir, "settings.json");
+}
+function installClaude(settingsPath, env = process.env) {
+  const target = settingsPath ?? claudeSettingsPath(env);
+  const binary = Bun.which("statusline") || "statusline";
+  let settings = {};
+  if (existsSync4(target)) {
+    try {
+      settings = JSON.parse(readFileSync4(target, "utf8"));
+    } catch (error) {
+      throw new Error(`${target} is not valid JSON \u2014 fix or move it first`);
+    }
+    copyFileSync(target, `${target}.bak-statusline`);
+  }
+  settings.statusLine = { ...settings.statusLine, type: "command", command: `${binary} render` };
+  const configDir = dirname2(target);
+  if (!existsSync4(configDir)) {
+    if (resolve2(target) !== resolve2(defaultSettingsPath(env))) {
+      throw new Error(`config dir ${configDir} does not exist \u2014 create the profile first`);
+    }
+    mkdirSync2(configDir, { recursive: true });
+  }
+  writeFileSync2(target, JSON.stringify(settings, null, 2) + `
+`);
+  return target;
+}
+
+// src/index.ts
+var statuslineVersion = package_default.version;
+function listSegments(config = loadConfig()) {
+  const enabled = new Set(config.segments);
+  return segments.map((segment) => ({
+    id: segment.id,
+    description: segment.description,
+    defaultEnabled: segment.defaultEnabled,
+    enabled: enabled.has(segment.id)
+  }));
+}
+function requireKnownSegments(ids) {
+  const unknown = ids.filter((id) => !getSegment(id));
+  if (unknown.length) {
+    throw new Error(`unknown segment(s): ${unknown.join(", ")}`);
+  }
+  return ids;
+}
+function enableSegments(ids, config = loadConfig()) {
+  requireKnownSegments(ids);
+  const next = { ...config, segments: [...config.segments] };
+  const changed = [];
+  for (const id of ids) {
+    if (!next.segments.includes(id)) {
+      next.segments.push(id);
+      changed.push(id);
+    }
+  }
+  return { config: next, changed };
+}
+function disableSegments(ids, config = loadConfig()) {
+  requireKnownSegments(ids);
+  const nextSegments = config.segments.filter((id) => !ids.includes(id));
+  return {
+    config: { ...config, segments: nextSegments },
+    changed: config.segments.filter((id) => ids.includes(id))
+  };
+}
+function orderSegments(ids, config = loadConfig()) {
+  requireKnownSegments(ids);
+  if (ids.length === 0)
+    throw new Error("at least one segment id is required");
+  return { config: { ...config, segments: [...ids] }, changed: [...ids] };
+}
+function setSeparator(separator, config = loadConfig()) {
+  if (!separator)
+    throw new Error("separator must be a non-empty string");
+  return { config: { ...config, separator }, changed: ["separator"] };
+}
+function setColors(colors, config = loadConfig()) {
+  return { config: { ...config, colors }, changed: ["colors"] };
+}
+function resetStatuslineConfig() {
+  return defaultConfig();
+}
+async function renderStatusline(input = {}, config = loadConfig()) {
+  return renderLine(parseClaudeInput(input), config);
+}
+function sampleClaudeInput(cwd = process.cwd()) {
+  return {
+    cwd,
+    model: { id: "claude-fable-5[1m]", display_name: "Fable" },
+    cost: { total_cost_usd: 12.34, total_duration_ms: 5400000, total_lines_added: 42, total_lines_removed: 7 },
+    version: statuslineVersion,
+    session_id: "preview0-0000-0000-0000-000000000000",
+    session_name: "preview thread",
+    effort: { level: "high" },
+    thinking: { enabled: true },
+    rate_limits: { five_hour: { used_percentage: 42 } }
+  };
+}
+async function previewStatusline(config = loadConfig(), cwd = process.cwd()) {
+  return renderStatusline(sampleClaudeInput(cwd), config);
+}
+function saveUpdatedConfig(result, path = configPath()) {
+  saveConfig(result.config, path);
+  return result.config;
+}
+
+// src/cli.ts
+var DEFAULT_LIST_LIMIT = 12;
+async function readStdinJson() {
+  try {
+    const text = await Bun.stdin.text();
+    return text.trim() ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+function printError(error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}
+function printSegmentError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.startsWith("unknown segment")) {
+    console.error(`${message}
+run \`statusline list\` to see available segments`);
+  } else {
+    console.error(message);
+  }
+  process.exitCode = 1;
+}
+function help() {
+  return `statusline ${statuslineVersion} \u2014 composable statusline for AI coding agents
+
+usage:
+  statusline render              read agent JSON on stdin, print the statusline (default)
+  statusline list                compact segment list (default limit: ${DEFAULT_LIST_LIMIT})
+  statusline list --verbose      include descriptions
+  statusline list --all          show all rows
+  statusline list --json         machine-readable segment list
+  statusline list --limit N      cap rows explicitly
+  statusline list --enabled      show only enabled segments
+  statusline list --disabled     show only disabled segments
+  statusline list --search text  filter by id or description
+  statusline search <text>       alias for list --search
+  statusline show <id>           show one segment in detail
+  statusline show <id> --json    machine-readable segment detail
+  statusline inspect <id>        alias for show
+  statusline enable <id...>      enable segments (appended to the end)
+  statusline disable <id...>     disable segments
+  statusline order <id...>       set the exact segment order (also defines enabled set)
+  statusline separator <str>     set the separator (default " \xB7 ")
+  statusline colors <on|off>     toggle segment colours (default on)
+  statusline preview             render with a sample payload from the current directory
+  statusline reset               restore default config
+  statusline install [claude]    wire into Claude Code (~/.claude/settings.json)
+  statusline version             print version
+
+config: ${configPath()}`;
+}
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+function printListHelp() {
+  console.log(`usage: statusline list [options] [search text]
+
+options:
+  --all              show all matching rows
+  --enabled          show only enabled segments
+  --disabled         show only disabled segments
+  --json, -j         output structured JSON
+  --limit <n>        cap rows
+  --search, -s <q>   filter by id or description
+  --verbose          include descriptions
+  --help, -h         show this help`);
+  process.exit(0);
+}
+function printSearchHelp() {
+  console.log(`usage: statusline search <text> [options]
+
+options:
+  --all              show all matching rows
+  --enabled          show only enabled segments
+  --disabled         show only disabled segments
+  --json, -j         output structured JSON
+  --limit <n>        cap rows
+  --verbose          include descriptions
+  --help, -h         show this help`);
+  process.exit(0);
+}
+function printShowHelp() {
+  console.log(`usage: statusline show <segment> [options]
+
+options:
+  --json, -j         output structured JSON
+  --help, -h         show this help`);
+  process.exit(0);
+}
+function readFlagValue(raw, index, flag) {
+  const value = raw[index + 1];
+  if (!value || value.startsWith("-"))
+    fail(`missing value for ${flag}`);
+  return value;
+}
+function parsePositiveInt(value, flag) {
+  if (!value)
+    fail(`missing value for ${flag}`);
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1)
+    fail(`${flag} must be a positive integer`);
+  return n;
+}
+function parseListArgs(raw) {
+  const opts = {
+    all: false,
+    disabledOnly: false,
+    enabledOnly: false,
+    json: false,
+    limit: null,
+    query: null,
+    verbose: false
+  };
+  const queryParts = [];
+  for (let i = 0;i < raw.length; i++) {
+    const arg = raw[i];
+    switch (arg) {
+      case "--all":
+        opts.all = true;
+        break;
+      case "--disabled":
+        opts.disabledOnly = true;
+        break;
+      case "--enabled":
+        opts.enabledOnly = true;
+        break;
+      case "--json":
+      case "-j":
+        opts.json = true;
+        break;
+      case "--limit":
+        opts.limit = parsePositiveInt(readFlagValue(raw, i, "--limit"), "--limit");
+        i++;
+        break;
+      case "--search":
+      case "-s":
+        queryParts.push(readFlagValue(raw, i, arg));
+        i++;
+        break;
+      case "--verbose":
+        opts.verbose = true;
+        break;
+      case "--help":
+      case "-h":
+        printListHelp();
+      default:
+        if (arg.startsWith("-"))
+          fail(`unknown option for list: ${arg}`);
+        queryParts.push(arg);
+    }
+  }
+  if (opts.enabledOnly && opts.disabledOnly)
+    fail("use only one of --enabled or --disabled");
+  if (opts.all && opts.limit !== null)
+    fail("use only one of --all or --limit");
+  opts.query = queryParts.length ? queryParts.join(" ").toLowerCase() : null;
+  return opts;
+}
+function parseShowArgs(raw) {
+  let id = null;
+  let json = false;
+  for (const arg of raw) {
+    if (arg === "--json" || arg === "-j") {
+      json = true;
+    } else if (arg === "--help" || arg === "-h") {
+      printShowHelp();
+    } else if (arg.startsWith("-")) {
+      fail(`unknown option for show: ${arg}`);
+    } else if (!id) {
+      id = arg;
+    } else {
+      fail("usage: statusline show <segment> [--json]");
+    }
+  }
+  return { id, json };
+}
+function searchArgsForList(raw) {
+  const queryParts = [];
+  const forwarded = [];
+  for (let i = 0;i < raw.length; i++) {
+    const arg = raw[i];
+    switch (arg) {
+      case "--all":
+      case "--disabled":
+      case "--enabled":
+      case "--json":
+      case "-j":
+      case "--verbose":
+        forwarded.push(arg);
+        break;
+      case "--help":
+      case "-h":
+        printSearchHelp();
+      case "--limit":
+        forwarded.push(arg, readFlagValue(raw, i, "--limit"));
+        i++;
+        break;
+      default:
+        if (arg.startsWith("-"))
+          fail(`unknown option for search: ${arg}`);
+        queryParts.push(arg);
+    }
+  }
+  if (!queryParts.length)
+    fail("usage: statusline search <text> [--json] [--verbose] [--limit N]");
+  return ["--search", queryParts.join(" "), ...forwarded];
+}
+function filteredSegments(all, opts) {
+  return all.filter((s) => {
+    if (opts.enabledOnly && !s.enabled)
+      return false;
+    if (opts.disabledOnly && s.enabled)
+      return false;
+    if (!opts.query)
+      return true;
+    return `${s.id} ${s.description}`.toLowerCase().includes(opts.query);
+  });
+}
+function prioritizeEnabled(rows) {
+  return rows.map((segment, index) => ({ segment, index })).sort((a, b) => Number(b.segment.enabled) - Number(a.segment.enabled) || a.index - b.index).map((entry) => entry.segment);
+}
+function truncate(value, width) {
+  return value.length > width ? `${value.slice(0, width - 1)}...` : value;
+}
+function printList(raw) {
+  const opts = parseListArgs(raw);
+  const all = listSegments(loadConfig());
+  const allRows = filteredSegments(all, opts);
+  const displayRows = opts.json ? allRows : prioritizeEnabled(allRows);
+  const showAll = opts.all || opts.limit === null && opts.json;
+  const limit = opts.limit ?? (showAll ? allRows.length : DEFAULT_LIST_LIMIT);
+  const rows = displayRows.slice(0, limit);
+  const enabledCount = all.filter((s) => s.enabled).length;
+  const total = all.length;
+  const limited = rows.length < allRows.length;
+  if (opts.json) {
+    console.log(JSON.stringify({
+      total,
+      matching: allRows.length,
+      showing: rows.length,
+      limited,
+      segments: rows,
+      next: limited ? { all: true, limit: allRows.length } : null
+    }, null, 2));
+    return;
+  }
+  const filterLabel = opts.query ? `, query "${opts.query}"` : "";
+  console.log(`Segments: ${enabledCount} enabled / ${total} total (showing ${rows.length} of ${allRows.length}${filterLabel})`);
+  if (!rows.length) {
+    console.log("No matching segments.");
+    console.log("Try `statusline list --all` or `statusline list --search <text>`.");
+    return;
+  }
+  const idWidth = Math.max(2, ...rows.map((s) => s.id.length));
+  if (opts.verbose) {
+    console.log(`state  default  ${"id".padEnd(idWidth)}  description`);
+    for (const s of rows) {
+      const state = s.enabled ? "on " : "off";
+      const def = s.defaultEnabled ? "yes" : "no ";
+      console.log(`${state.padEnd(5)}  ${def.padEnd(7)}  ${s.id.padEnd(idWidth)}  ${truncate(s.description, 72)}`);
+    }
+  } else {
+    console.log(`state  default  ${"id".padEnd(idWidth)}`);
+    for (const s of rows) {
+      const state = s.enabled ? "on " : "off";
+      const def = s.defaultEnabled ? "yes" : "no ";
+      console.log(`${state.padEnd(5)}  ${def.padEnd(7)}  ${s.id.padEnd(idWidth)}`);
+    }
+  }
+  const hints = ["`statusline show <id>` for details", "`--verbose` for descriptions", "`--json` for machines"];
+  if (limited)
+    hints.unshift("`--all` for all matching rows");
+  console.log(`Hint: use ${hints.join(", ")}.`);
+}
+function printShow(raw) {
+  const { id, json } = parseShowArgs(raw);
+  if (!id)
+    fail("usage: statusline show <segment> [--json]");
+  const info = listSegments(loadConfig()).find((s) => s.id === id);
+  if (!info) {
+    console.error(`unknown segment: ${id}`);
+    console.error("run `statusline list --all` to see available segments");
+    process.exit(1);
+  }
+  if (json) {
+    console.log(JSON.stringify(info, null, 2));
+    return;
+  }
+  console.log(`Segment: ${info.id}`);
+  console.log(`State: ${info.enabled ? "enabled" : "disabled"}`);
+  console.log(`Default: ${info.defaultEnabled ? "enabled" : "disabled"}`);
+  console.log(`Description: ${info.description}`);
+  console.log(`Commands: statusline ${info.enabled ? "disable" : "enable"} ${info.id} | statusline list --search ${info.id}`);
+}
+async function runCli(argv = process.argv.slice(2)) {
+  const [command = "render", ...args] = argv;
+  try {
+    switch (command) {
+      case "render": {
+        console.log(await renderStatusline(await readStdinJson(), loadConfig()));
+        return;
+      }
+      case "list": {
+        printList(args);
+        return;
+      }
+      case "search": {
+        printList(searchArgsForList(args));
+        return;
+      }
+      case "show":
+      case "inspect": {
+        printShow(args);
+        return;
+      }
+      case "enable": {
+        let result;
+        try {
+          result = enableSegments(args, loadConfig());
+        } catch (error) {
+          printSegmentError(error);
+          return;
+        }
+        saveConfig(result.config);
+        console.log(`enabled: ${args.join(", ")}
+order: ${result.config.segments.join(", ")}`);
+        return;
+      }
+      case "disable": {
+        let result;
+        try {
+          result = disableSegments(args, loadConfig());
+        } catch (error) {
+          printSegmentError(error);
+          return;
+        }
+        saveConfig(result.config);
+        console.log(`disabled: ${args.join(", ")}
+order: ${result.config.segments.join(", ") || "(none)"}`);
+        return;
+      }
+      case "order": {
+        if (!args.length)
+          throw new Error("usage: statusline order <segment> [segment...]");
+        let result;
+        try {
+          result = orderSegments(args, loadConfig());
+        } catch (error) {
+          printSegmentError(error);
+          return;
+        }
+        saveConfig(result.config);
+        console.log(`order: ${result.config.segments.join(", ")}`);
+        return;
+      }
+      case "separator": {
+        if (!args.length)
+          throw new Error('usage: statusline separator " \xB7 "');
+        const result = setSeparator(args.join(" "), loadConfig());
+        saveConfig(result.config);
+        console.log(`separator: "${result.config.separator}"`);
+        return;
+      }
+      case "colors": {
+        const value = args[0];
+        if (value !== "on" && value !== "off")
+          throw new Error("usage: statusline colors <on|off>");
+        const result = setColors(value === "on", loadConfig());
+        saveConfig(result.config);
+        console.log(`colors: ${value}`);
+        return;
+      }
+      case "reset": {
+        saveConfig(defaultConfig());
+        console.log(`reset to defaults (${configPath()})`);
+        return;
+      }
+      case "preview": {
+        console.log(await previewStatusline(loadConfig(), process.cwd()));
+        return;
+      }
+      case "install": {
+        const target = args[0] || "claude";
+        if (target !== "claude") {
+          throw new Error(`unsupported target "${target}" \u2014 only "claude" is supported today (OpenCode has no statusline hook yet)`);
+        }
+        const path = installClaude();
+        console.log(`installed into ${path} \u2014 Claude Code picks it up on the next status refresh`);
+        return;
+      }
+      case "--version":
+      case "-v":
+      case "version": {
+        console.log(statuslineVersion);
+        return;
+      }
+      case "help":
+      case "--help":
+      case "-h": {
+        console.log(help());
+        return;
+      }
+      default: {
+        console.log(help());
+        process.exitCode = 1;
+      }
+    }
+  } catch (error) {
+    printError(error);
+  }
+}
+if (import.meta.main) {
+  await runCli();
+}
+export {
+  runCli
+};