@hasna/statusline 0.0.1 → 0.0.3

package/dist/providers/claude.d.ts

@@ -0,0 +1,7 @@
+import type { StatusContext } from "./types.js";
+/**
+ * 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 declare function parseClaudeInput(input: Record<string, any>): StatusContext;

package/dist/providers/types.d.ts

@@ -0,0 +1,47 @@
+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;
+    /** Thread title the user set with `/rename`; absent until they do. */
+    sessionName?: string;
+    version?: string;
+    outputStyle?: string;
+    /** Reasoning effort level, on models that expose one. */
+    effort?: string;
+    /** Whether extended thinking is on. */
+    thinking?: boolean;
+    /** Rate-limit windows, present only once the host reports limit data. */
+    rateLimits?: {
+        fiveHour?: {
+            usedPercentage?: number;
+        };
+        sevenDay?: {
+            usedPercentage?: number;
+        };
+    };
+}
+/** ANSI hints a segment can ask the renderer for. */
+export type SegmentColor = "cyan" | "magenta" | "blue" | "green" | "yellow" | "red" | "bold" | "dim";
+export interface Segment {
+    id: string;
+    description: string;
+    defaultEnabled: boolean;
+    /**
+     * Colour applied by the renderer when colours are on. A function lets a
+     * segment escalate with its value (e.g. a limit gauge turning red).
+     */
+    color?: SegmentColor | ((ctx: StatusContext) => SegmentColor | null);
+    render(ctx: StatusContext): Promise<string | null> | string | null;
+}

package/dist/render.d.ts

@@ -0,0 +1,4 @@
+import type { StatusContext } from "./providers/types.js";
+import type { StatuslineConfig } from "./config.js";
+/** Render the configured segments; a failing segment is dropped, never fatal. */
+export declare function renderLine(ctx: StatusContext, cfg: StatuslineConfig): Promise<string>;

package/dist/segments/index.d.ts

@@ -0,0 +1,3 @@
+import type { Segment } from "../providers/types.js";
+export declare const segments: Segment[];
+export declare function getSegment(id: string): Segment | undefined;

package/package.json

@@ -1,19 +1,41 @@
 {
   "name": "@hasna/statusline",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
-    "statusline": "./src/index.ts"
+    "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": [
-    "src",
+    "dist",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
-    "test": "bun test"
+    "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",
@@ -36,5 +58,13 @@
   },
   "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"
   }
 }

package/src/config.ts

@@ -1,53 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,55 +0,0 @@
-/** 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

@@ -1,143 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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);
-}