@hasna/statusline 0.0.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,96 @@
+# statusline
+
+Tiny, composable statusline CLI for AI coding agents. Pre-built segments you toggle
+on and off — machine name, project + branch, model, context remaining, session cost,
+and more — rendered as a single line for your agent's status bar.
+
+```
+apple03 · statusline (main) · 12h · 1.2k · fable 5 [1m] · 90% left · $0.04
+```
+
+Zero runtime dependencies. Built with [Bun](https://bun.sh) + TypeScript. Apache-2.0.
+
+## Install
+
+```bash
+bun install -g @hasna/statusline
+statusline install claude        # wires it into ~/.claude/settings.json
+```
+
+That's it — Claude Code picks it up on the next status refresh (no restart needed).
+
+## Segments
+
+`statusline list` shows everything available:
+
+```
+  [x] machine            Machine hostname (short)
+  [x] project            Project name with current Git branch
+  [ ] project-name       Project name (omitted when unavailable)
+  [ ] git-branch         Current Git branch (omitted when unavailable)
+  [x] commit-age         Time since last commit (compact)
+  [x] loc                Lines of code tracked by Git (compact)
+  [ ] current-dir        Current working directory (basename)
+  [ ] model              Current model name
+  [x] model-context      Model name with context-size tag (e.g. [1m])
+  [ ] context-used       Percentage of context window used (omitted when unknown)
+  [x] context-remaining  Percentage of context window remaining (omitted when unknown)
+  [ ] used-tokens        Total tokens in the context window (omitted when unknown)
+  [x] cost               Session cost in USD (omitted when zero)
+  [ ] duration           Session wall-clock duration
+  [ ] lines-changed      Lines added/removed this session (omitted when zero)
+  [ ] output-style       Active output style (omitted when default)
+  [ ] agent-version      Host agent version (e.g. Claude Code version)
+  [ ] session-id         Session identifier (short)
+```
+
+## Usage
+
+```bash
+statusline enable used-tokens duration    # turn segments on (appended at the end)
+statusline disable loc                    # turn segments off
+statusline order machine project model-context cost   # exact order = enabled set
+statusline separator " | "                # change the separator
+statusline preview                        # render a sample line from the current dir
+statusline reset                          # back to defaults
+```
+
+Config lives at `~/.config/statusline/config.json` (override with `$STATUSLINE_CONFIG`):
+
+```json
+{
+  "separator": " · ",
+  "segments": ["machine", "project", "commit-age", "loc", "model-context", "context-remaining", "cost"]
+}
+```
+
+## How it works
+
+Claude Code pipes a JSON payload (cwd, model, session cost, transcript path, …) to the
+configured `statusLine` command on every status refresh. `statusline render` parses it,
+renders each enabled segment, drops anything unavailable, and prints one line. Segments
+that need more than the payload offers (e.g. `context-remaining`) read the session
+transcript to compute it. A segment failure is never fatal — it's simply omitted.
+
+## Providers
+
+| Agent | Status |
+|-------|--------|
+| Claude Code | ✅ `statusline install claude` |
+| OpenCode | ⏳ no statusline/footer hook in its config as of v1.3.x — the renderer is provider-agnostic (`src/providers/`), so an adapter slots in the moment one exists |
+| Codex CLI | Codex ships its own built-in segment picker; no external command hook |
+
+Adding a provider means one small parser: agent payload → `StatusContext`
+(`src/providers/types.ts`). PRs welcome.
+
+## Development
+
+```bash
+bun install
+bun test
+echo '{"cwd":"'$PWD'","model":{"id":"claude-fable-5[1m]"}}' | bun src/index.ts render
+```
+
+## License
+
+[Apache-2.0](LICENSE)

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@hasna/statusline",
+  "version": "0.0.1",
+  "description": "Tiny composable statusline CLI for AI coding agents — pre-built toggleable segments for Claude Code, with a provider model for others",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "statusline": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "bun test"
+  },
+  "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"
+  }
+}

package/src/config.ts

@@ -0,0 +1,53 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export interface StatuslineConfig {
+  separator: string;
+  /** Ordered list of enabled segment ids. */
+  segments: string[];
+}
+
+export function defaultConfig(): StatuslineConfig {
+  return {
+    separator: " · ",
+    segments: [
+      "machine",
+      "project",
+      "commit-age",
+      "loc",
+      "model-context",
+      "context-remaining",
+      "cost",
+    ],
+  };
+}
+
+export function configPath(): string {
+  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");
+}
+
+export function loadConfig(): StatuslineConfig {
+  const 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: unknown) => typeof s === "string")
+        : fallback.segments,
+    };
+  } catch {
+    return defaultConfig();
+  }
+}
+
+export function saveConfig(cfg: StatuslineConfig): void {
+  const path = configPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(cfg, null, 2) + "\n");
+}

package/src/context-window.ts

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from "node:fs";
+import type { StatusContext } from "./providers/types";
+
+export interface ContextUsage {
+  /** Tokens currently occupying the context window (input side). */
+  used: number;
+  /** Output tokens of the latest assistant turn. */
+  output: number;
+  /** Context window size in tokens. */
+  window: number;
+}
+
+/**
+ * Derive context usage from the session transcript (JSONL). The last
+ * assistant entry's usage block reflects what the context window holds.
+ */
+export function contextUsage(ctx: StatusContext): ContextUsage | null {
+  const path = ctx.transcriptPath;
+  if (!path || !existsSync(path)) return null;
+  let lines: string[];
+  try {
+    lines = readFileSync(path, "utf8").split("\n");
+  } 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: StatusContext): number {
+  return ctx.model?.id?.includes("[1m]") ? 1_000_000 : 200_000;
+}

package/src/format.ts

@@ -0,0 +1,36 @@
+export function compactAge(seconds: number): string {
+  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: number): string {
+  const fixed = value.toFixed(1);
+  return fixed.endsWith(".0") ? fixed.slice(0, -2) : fixed;
+}
+
+export function compactNum(n: number): string {
+  if (n >= 1_000_000) return `${trimmed(n / 1_000_000)}m`;
+  if (n >= 10_000) return `${Math.floor(n / 1000)}k`;
+  if (n >= 1000) return `${trimmed(n / 1000)}k`;
+  return `${n}`;
+}
+
+export function money(n: number): string {
+  return `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+
+export function compactDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  if (s < 3600) {
+    const rem = s % 60;
+    return rem ? `${Math.floor(s / 60)}m${rem}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`;
+}

package/src/git.ts

@@ -0,0 +1,55 @@
+/** Minimal git helpers — every call degrades to null outside a repo. */
+
+function run(cwd: string, args: string[]): string | null {
+  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;
+  }
+}
+
+export function gitRoot(cwd: string): string | null {
+  return run(cwd, ["rev-parse", "--show-toplevel"]);
+}
+
+export function gitBranch(cwd: string): string | null {
+  return run(cwd, ["branch", "--show-current"]);
+}
+
+export function gitProjectName(cwd: string): string | null {
+  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;
+}
+
+export function lastCommitEpoch(cwd: string): number | null {
+  const out = run(cwd, ["log", "-1", "--format=%ct"]);
+  if (!out) return null;
+  const ts = Number(out);
+  return Number.isFinite(ts) ? ts : null;
+}
+
+export function trackedLineCount(cwd: string): number | null {
+  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;
+  }
+}

package/src/index.ts

@@ -0,0 +1,143 @@
+#!/usr/bin/env bun
+import { defaultConfig, loadConfig, saveConfig, configPath } from "./config";
+import { parseClaudeInput } from "./providers/claude";
+import { renderLine } from "./render";
+import { segments, getSegment } from "./segments";
+import { installClaude } from "./install";
+import pkg from "../package.json";
+
+const [, , command = "render", ...args] = process.argv;
+
+async function readStdinJson(): Promise<Record<string, any>> {
+  try {
+    const text = await Bun.stdin.text();
+    return text.trim() ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+
+function requireKnown(ids: string[]): string[] {
+  const unknown = ids.filter((id) => !getSegment(id));
+  if (unknown.length) {
+    console.error(`unknown segment(s): ${unknown.join(", ")}\nrun \`statusline list\` to see available segments`);
+    process.exit(1);
+  }
+  return ids;
+}
+
+switch (command) {
+  case "render": {
+    const input = await readStdinJson();
+    console.log(await renderLine(parseClaudeInput(input), loadConfig()));
+    break;
+  }
+
+  case "list": {
+    const enabled = new Set(loadConfig().segments);
+    const width = Math.max(...segments.map((s) => s.id.length));
+    for (const s of segments) {
+      const mark = enabled.has(s.id) ? "[x]" : "[ ]";
+      console.log(`  ${mark} ${s.id.padEnd(width)}  ${s.description}`);
+    }
+    break;
+  }
+
+  case "enable": {
+    const ids = requireKnown(args);
+    const cfg = loadConfig();
+    for (const id of ids) if (!cfg.segments.includes(id)) cfg.segments.push(id);
+    saveConfig(cfg);
+    console.log(`enabled: ${ids.join(", ")}\norder: ${cfg.segments.join(", ")}`);
+    break;
+  }
+
+  case "disable": {
+    const ids = requireKnown(args);
+    const cfg = loadConfig();
+    cfg.segments = cfg.segments.filter((id) => !ids.includes(id));
+    saveConfig(cfg);
+    console.log(`disabled: ${ids.join(", ")}\norder: ${cfg.segments.join(", ") || "(none)"}`);
+    break;
+  }
+
+  case "order": {
+    const ids = requireKnown(args);
+    if (!ids.length) {
+      console.error("usage: statusline order <segment> [segment...]");
+      process.exit(1);
+    }
+    const cfg = loadConfig();
+    cfg.segments = ids;
+    saveConfig(cfg);
+    console.log(`order: ${cfg.segments.join(", ")}`);
+    break;
+  }
+
+  case "separator": {
+    if (!args.length) {
+      console.error('usage: statusline separator " · "');
+      process.exit(1);
+    }
+    const cfg = loadConfig();
+    cfg.separator = args.join(" ");
+    saveConfig(cfg);
+    console.log(`separator: "${cfg.separator}"`);
+    break;
+  }
+
+  case "reset": {
+    saveConfig(defaultConfig());
+    console.log(`reset to defaults (${configPath()})`);
+    break;
+  }
+
+  case "preview": {
+    const sample = {
+      cwd: process.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: pkg.version,
+      session_id: "preview0-0000-0000-0000-000000000000",
+    };
+    console.log(await renderLine(parseClaudeInput(sample), loadConfig()));
+    break;
+  }
+
+  case "install": {
+    const target = args[0] || "claude";
+    if (target !== "claude") {
+      console.error(`unsupported target "${target}" — only "claude" is supported today (OpenCode has no statusline hook yet)`);
+      process.exit(1);
+    }
+    const path = installClaude();
+    console.log(`installed into ${path} — Claude Code picks it up on the next status refresh`);
+    break;
+  }
+
+  case "--version":
+  case "-v":
+  case "version": {
+    console.log(pkg.version);
+    break;
+  }
+
+  default: {
+    console.log(`statusline ${pkg.version} — composable statusline for AI coding agents
+
+usage:
+  statusline render              read agent JSON on stdin, print the statusline (default)
+  statusline list                show all segments and which are enabled
+  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 " · ")
+  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()}`);
+    if (command !== "help" && command !== "--help" && command !== "-h") process.exit(1);
+  }
+}

package/src/install.ts

@@ -0,0 +1,20 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+/**
+ * Wire the statusline into Claude Code's user settings. Existing settings
+ * are preserved; the previous file is backed up alongside it.
+ */
+export function installClaude(settingsPath = join(homedir(), ".claude", "settings.json")): string {
+  const binary = Bun.which("statusline") || "statusline";
+  let settings: Record<string, any> = {};
+  if (existsSync(settingsPath)) {
+    settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+    copyFileSync(settingsPath, `${settingsPath}.bak-statusline`);
+  }
+  settings.statusLine = { type: "command", command: `${binary} render` };
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  return settingsPath;
+}

package/src/providers/claude.ts

@@ -0,0 +1,35 @@
+import type { StatusContext } from "./types";
+
+/**
+ * Parse the JSON payload Claude Code pipes to a `statusLine` command.
+ * Every field is optional — a partial or empty payload must still
+ * produce a usable context.
+ */
+export function parseClaudeInput(input: Record<string, any>): StatusContext {
+  const cwd: string =
+    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,
+    version: input?.version || undefined,
+    outputStyle: input?.output_style?.name || undefined,
+  };
+}
+
+function numberOr(v: unknown): number | undefined {
+  return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+}

package/src/providers/types.ts

@@ -0,0 +1,23 @@
+export interface StatusContext {
+  provider: "claude";
+  cwd: string;
+  projectDir?: string;
+  model?: { id?: string; displayName?: string };
+  cost?: {
+    totalCostUsd?: number;
+    totalDurationMs?: number;
+    totalLinesAdded?: number;
+    totalLinesRemoved?: number;
+  };
+  transcriptPath?: string;
+  sessionId?: string;
+  version?: string;
+  outputStyle?: string;
+}
+
+export interface Segment {
+  id: string;
+  description: string;
+  defaultEnabled: boolean;
+  render(ctx: StatusContext): Promise<string | null> | string | null;
+}

package/src/render.ts

@@ -0,0 +1,19 @@
+import type { StatusContext } from "./providers/types";
+import type { StatuslineConfig } from "./config";
+import { getSegment } from "./segments";
+
+/** Render the configured segments; a failing segment is dropped, never fatal. */
+export async function renderLine(ctx: StatusContext, cfg: StatuslineConfig): Promise<string> {
+  const parts: string[] = [];
+  for (const id of cfg.segments) {
+    const segment = getSegment(id);
+    if (!segment) continue;
+    try {
+      const out = await segment.render(ctx);
+      if (out) parts.push(out);
+    } catch {
+      // statuslines must never break the host UI
+    }
+  }
+  return parts.join(cfg.separator);
+}

package/src/segments/index.ts

@@ -0,0 +1,187 @@
+import { hostname } from "node:os";
+import type { Segment, StatusContext } from "../providers/types";
+import { compactAge, compactDuration, compactNum, money } from "../format";
+import { gitBranch, gitProjectName, lastCommitEpoch, trackedLineCount } from "../git";
+import { contextUsage } from "../context-window";
+
+/**
+ * Format a model id like "claude-fable-5[1m]" or "claude-3-5-sonnet-20241022"
+ * into a friendly name ("fable 5", "sonnet 3.5") plus an optional context tag.
+ */
+function friendlyModel(id: string): { name: string; tag: string | null } {
+  let tag: string | null = 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 };
+}
+
+const dir = (ctx: StatusContext) => ctx.cwd || process.cwd();
+
+export const segments: Segment[] = [
+  {
+    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: "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),
+  },
+];
+
+export function getSegment(id: string): Segment | undefined {
+  return segments.find((s) => s.id === id);
+}