@nutthead/cc-statusline 0.2.2 → 0.4.0

package/README.md

@@ -1,17 +1,24 @@
 # statusline
 
-Custom status line for Claude Code.
+Themeable status line provider for Claude Code.
+
+Requires [Bun](https://bun.com).
 
 ## Preview
 
-The default theme renders a two-row status line:
+### Default Theme
 
-```
-🗂️ ~/C/b/statusline ⋮ 🌿 master
-⏣ opus-4-6 ⋮ 📝 fc9bbbee-...
-```
+Two-row layout with model, session, project directory, git status, and context usage:
+
+![Default theme preview](assets/default-preview.png)
+
+### Powerline Theme
+
+Single-row powerline-style segments with muted dark backgrounds and arrow separators:
 
-Row 1 shows the abbreviated working directory and git branch. Row 2 shows the model and session ID.
+![Powerline theme preview](assets/powerline-preview.png)
+
+Wraps to multiple lines when segments exceed terminal width. Select with `--theme powerline`.
 
 ## Install
 
@@ -32,20 +39,21 @@ Then add to `~/.claude/settings.json`:
 
 Use `--overwrite` to replace an existing installation.
 
+## Themes
+
+Built-in themes: `default` (two-row), `powerline` (single-row with powerline arrows).
+
+Use `--theme powerline` to select a built-in theme.
+
 ## Custom Themes
 
-Create a JS file that default-exports a theme function (e.g. `~/.config/cc-statusline/theme.js`):
+Create a JS file that default-exports an async theme function (e.g. `~/.config/cc-statusline/theme.js`):
 
 ```js
-export default function theme(input) {
+export default async function theme(input) {
   if (!input) return "";
-
   const status = JSON.parse(input);
-  const dir = status.workspace.current_dir;
-  const model = status.model.display_name;
-  const ctx = status.context_window.used_percentage ?? 0;
-
-  return `${model} | ${dir} | ctx: ${Math.round(ctx)}%`;
+  return `${status.model.display_name} | ${status.workspace.current_dir}`;
 }
 ```
 
@@ -55,7 +63,7 @@ Then point to it in `~/.claude/settings.json`:
 {
   "statusLine": {
     "type": "command",
-    "command": "~/.claude/statusline --theme ~/.config/cc-statusline/theme.js"
+    "command": "~/.claude/statusline --theme-file ~/.config/cc-statusline/theme.js"
   }
 }
 ```
@@ -64,19 +72,32 @@ Then point to it in `~/.claude/settings.json`:
 
 The JSON object passed to your theme function contains these fields:
 
-| Field                            | Example                  |
-| -------------------------------- | ------------------------ |
-| `session_id`                     | `"f9abcdef-1a2b-..."`    |
-| `version`                        | `"2.1.39"`               |
-| `model.id`                       | `"claude-opus-4-6"`      |
-| `model.display_name`             | `"Claude Opus 4.6"`      |
-| `workspace.current_dir`          | `"/home/user/project"`   |
-| `workspace.project_dir`          | `"/home/user/project"`   |
-| `context_window.used_percentage` | `42.5`                   |
-| `context_window.vim.mode`        | `"INSERT"` or `"NORMAL"` |
-| `context_window.agent.name`      | `"claude-code"`          |
-
-See [`src/statusLineSchema.ts`](src/statusLineSchema.ts) for the full schema.
+| Field                                                      | Example                           |
+| ---------------------------------------------------------- | --------------------------------- |
+| `session_id`                                               | `"f9abcdef-1a2b-..."`             |
+| `transcript_path`                                          | `"/home/user/.claude/transcript"` |
+| `cwd`                                                      | `"/home/user/project"`            |
+| `model.id`                                                 | `"claude-opus-4-6"`               |
+| `model.display_name`                                       | `"Claude Opus 4.6"`               |
+| `workspace.current_dir`                                    | `"/home/user/project"`            |
+| `workspace.project_dir`                                    | `"/home/user/project"`            |
+| `version`                                                  | `"2.1.39"`                        |
+| `output_style.name`                                        | `"Explanatory"`                   |
+| `context_window.total_input_tokens`                        | `12345`                           |
+| `context_window.total_output_tokens`                       | `6789`                            |
+| `context_window.context_window_size`                       | `200000`                          |
+| `context_window.current_usage`                             | `{ ... }` or `null`               |
+| `context_window.current_usage.input_tokens`                | `1024`                            |
+| `context_window.current_usage.output_tokens`               | `512`                             |
+| `context_window.current_usage.cache_creation_input_tokens` | `256`                             |
+| `context_window.current_usage.cache_read_input_tokens`     | `128`                             |
+| `context_window.used_percentage`                           | `42.5` or `null`                  |
+| `context_window.remaining_percentage`                      | `57.5` or `null`                  |
+| `context_window.vim.mode`                                  | `"INSERT"` or `"NORMAL"`          |
+| `context_window.agent.name`                                | `"claude-code"`                   |
+| `context_window.agent.type`                                | `"main"`                          |
+
+See [`src/schema/statusLine.ts`](src/schema/statusLine.ts) for the full schema.
 
 ## Troubleshooting
 

package/bin/cc-statusline.js

@@ -2,6 +2,12 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// src/cli.ts
+import { spawnSync } from "node:child_process";
+import { access, copyFile, mkdir, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
 // node_modules/meow/build/index.js
 import process4 from "node:process";
 
@@ -9408,16 +9414,12 @@ var meow = (helpText, options = {}) => {
 };
 
 // src/cli.ts
-import { spawnSync } from "node:child_process";
-import { access, mkdir, copyFile, unlink } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
 var BINARY_NAME = "statusline";
 var CLAUDE_DIR = join(homedir(), ".claude");
 var TARGET_PATH = join(CLAUDE_DIR, BINARY_NAME);
 var cli = meow(`
   Usage
-    $ cc-statusline <command>
+    $ bunx cc-statusline <command>
 
   Commands
     install    Build and install statusline to ~/.claude/
@@ -9426,8 +9428,8 @@ var cli = meow(`
     --overwrite  Overwrite existing file if it exists
 
   Examples
-    $ cc-statusline install
-    $ cc-statusline install --overwrite
+    $ bunx @nutthead/cc-statusline install
+    $ bunx @nutthead/cc-statusline install --overwrite
 `, {
   importMeta: import.meta,
   flags: {

package/biome.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.3.15/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "ignoreUnknown": false
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space"
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double"
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  }
+}

package/index.ts

@@ -1,36 +1,66 @@
-import meow from "meow";
 import { configure } from "@logtape/logtape";
+import chalk from "chalk";
+import meow from "meow";
 import { log, logtapeConfig } from "./src/logging";
-import { defaultTheme } from "./src/themes/defaultTheme";
 import { loadTheme } from "./src/theme/loadTheme";
+import { defaultTheme } from "./src/themes/defaultTheme";
+import { powerlineTheme } from "./src/themes/powerlineTheme";
+
+// Force truecolor output — chalk auto-detection fails when invoked via piped stdin
+chalk.level = 3;
 
 await configure(logtapeConfig);
 
+const BUILTIN_THEMES: Record<string, (input?: string) => Promise<string>> = {
+  default: defaultTheme,
+  powerline: powerlineTheme,
+};
+
 const cli = meow(
   `
   Usage
     $ cc-statusline
 
   Options
-   --theme, -t  Use a custom theme
+    --theme, -t             Use a built-in theme (powerline)
+    --theme-file, -f        Use a custom theme file
 
   Examples
     $ cc-statusline --theme ~/.config/cc-statusline/basic.js
 `,
   {
-    importMeta: import.meta, // This is required
+    importMeta: import.meta,
     flags: {
       theme: {
         type: "string",
         shortFlag: "t",
         isRequired: false,
       },
+      themeFile: {
+        type: "string",
+        shortFlag: "f",
+        isRequired: false,
+      },
     },
   },
 );
 
-const resolvedTheme = (cli.flags.theme && await loadTheme(cli.flags.theme)) || defaultTheme;
+if (cli.flags.theme && cli.flags.themeFile) {
+  console.error("Error: --theme and --theme-file are mutually exclusive");
+  process.exit(1);
+}
+
+let resolvedTheme: (input?: string) => Promise<string>;
+if (cli.flags.theme) {
+  const selectedTheme = cli.flags.theme;
+  resolvedTheme = BUILTIN_THEMES[selectedTheme] ?? defaultTheme;
+} else if (cli.flags.themeFile) {
+  const selectedTheme = cli.flags.themeFile;
+  resolvedTheme = (await loadTheme(selectedTheme)) || defaultTheme;
+} else {
+  resolvedTheme = defaultTheme;
+}
 
-const input = await Bun.stdin.stream().json();
-log.debug("input: {input}", input);
+const input = await Bun.stdin.stream().text();
+log.debug("input: {input}", { input });
 console.log(await resolvedTheme(input));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nutthead/cc-statusline",
   "description": "Status Line for Claude Code",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "type": "module",
   "bin": {
     "cc-statusline": "bin/cc-statusline.js"
@@ -30,9 +30,12 @@
     "build:binary": "mkdir -p target && bun build --compile ./index.ts --outfile target/statusline",
     "build:cli": "bun build ./src/cli.ts --outfile ./bin/cc-statusline.js --target node",
     "prepublishOnly": "bun run build:cli",
-    "install:binary": "cp target/statusline ~/.claude/"
+    "install:binary": "cp target/statusline ~/.claude/",
+    "biome:format": "bunx biome format --write",
+    "biome:lint": "bunx biome lint --fix"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.3.15",
     "@types/bun": "latest"
   },
   "peerDependencies": {
@@ -41,9 +44,11 @@
   "dependencies": {
     "@logtape/file": "^1.3.6",
     "@logtape/logtape": "^1.3.6",
-    "ansi-colors": "^4.1.3",
+    "chalk": "^5.6.2",
     "meow": "^14.0.0",
+    "neverthrow": "^8.2.0",
     "simple-git": "^3.30.0",
+    "terminal-size": "^4.0.1",
     "ts-pattern": "^5.9.0",
     "type-fest": "^5.3.1",
     "zod": "^4.3.5"

package/src/cli.ts

@@ -1,19 +1,38 @@
 #!/usr/bin/env node
 
-import meow from "meow";
 import { spawnSync } from "node:child_process";
-import { access, mkdir, copyFile, unlink } from "node:fs/promises";
+import { access, copyFile, mkdir, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import meow from "meow";
 
 const BINARY_NAME = "statusline";
 const CLAUDE_DIR = join(homedir(), ".claude");
 const TARGET_PATH = join(CLAUDE_DIR, BINARY_NAME);
 
+interface FileSystem {
+  exists(path: string): Promise<boolean>;
+  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
+  copy(src: string, dest: string): Promise<void>;
+  remove(path: string): Promise<void>;
+}
+
+interface InstallOptions {
+  overwrite: boolean;
+  claudeDir: string;
+  targetPath: string;
+  sourcePath: string;
+}
+
+interface InstallDeps {
+  fs: FileSystem;
+  build: () => Promise<void>;
+}
+
 const cli = meow(
   `
   Usage
-    $ cc-statusline <command>
+    $ bunx cc-statusline <command>
 
   Commands
     install    Build and install statusline to ~/.claude/
@@ -22,8 +41,8 @@ const cli = meow(
     --overwrite  Overwrite existing file if it exists
 
   Examples
-    $ cc-statusline install
-    $ cc-statusline install --overwrite
+    $ bunx @nutthead/cc-statusline install
+    $ bunx @nutthead/cc-statusline install --overwrite
 `,
   {
     importMeta: import.meta,
@@ -36,25 +55,6 @@ const cli = meow(
   },
 );
 
-interface FileSystem {
-  exists(path: string): Promise<boolean>;
-  mkdir(path: string, options?: { recursive?: boolean }): Promise<void>;
-  copy(src: string, dest: string): Promise<void>;
-  remove(path: string): Promise<void>;
-}
-
-interface InstallOptions {
-  overwrite: boolean;
-  claudeDir: string;
-  targetPath: string;
-  sourcePath: string;
-}
-
-interface InstallDeps {
-  fs: FileSystem;
-  build: () => Promise<void>;
-}
-
 async function fileExists(path: string): Promise<boolean> {
   try {
     await access(path);

package/src/logging.ts

@@ -1,6 +1,6 @@
-import { getFileSink } from "@logtape/file";
-import { getLogger, type Config } from "@logtape/logtape";
 import { homedir } from "node:os";
+import { getFileSink } from "@logtape/file";
+import { type Config, getLogger } from "@logtape/logtape";
 
 const logtapeConfig: Config<"file", string> = {
   sinks: {

package/src/{statusLineSchema.ts → schema/statusLine.ts}

@@ -30,13 +30,17 @@ const statusSchema = z.object({
       .nullable(),
     used_percentage: z.number().nullable(),
     remaining_percentage: z.number().nullable(),
-    vim: z.object({
-      mode: z.enum(["INSERT", "NORMAL"]),
-    }),
-    agent: z.object({
-      name: z.string(),
-      type: z.string(),
-    }),
+    vim: z
+      .object({
+        mode: z.enum(["INSERT", "NORMAL"]),
+      })
+      .optional(),
+    agent: z
+      .object({
+        name: z.string(),
+        type: z.string(),
+      })
+      .optional(),
   }),
 });
 

package/src/theme/loadTheme.ts

@@ -1,5 +1,5 @@
-import { join, resolve } from "node:path";
 import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 
 type ThemeFunction = (input?: string) => Promise<string>;
 

package/src/themes/defaultTheme.ts

@@ -1,46 +1,115 @@
-import { z } from "zod";
+import chalk from "chalk";
+import terminalSize from "terminal-size";
+import { match } from "ts-pattern";
+import { ZodError } from "zod";
 import { log } from "../logging";
-import { statusSchema } from "../statusLineSchema";
-import {
-  currentDirStatus,
-  currentGitStatus,
-  currentModelStatus,
-  currentSessionId,
-} from "../utils";
+import { type Status, statusSchema } from "../schema/statusLine";
+import { currentBranchName } from "../utils/git";
+import { abbreviateModelId } from "../utils/model";
+import { compress, telescope } from "../utils/path";
+import { getDisplayWidth } from "../utils/term";
 
-import c from "ansi-colors";
+const HORIZONTAL_PADDING = 4;
 
-async function defaultTheme(input?: string): Promise<string> {
-  let statusLine = null;
+function colorizeUsageStatus(usedPercentage: number) {
+  if (usedPercentage === 0) {
+    return "";
+  } else if (usedPercentage <= 50) {
+    return chalk.green(`${usedPercentage}%`);
+  } else if (usedPercentage <= 75) {
+    return chalk.blue(`${usedPercentage}%`);
+  } else if (usedPercentage <= 87.5) {
+    return chalk.yellow(`${usedPercentage}%`);
+  } else {
+    return chalk.red(`${usedPercentage}%`);
+  }
+}
+
+async function renderLine1(status: Status): Promise<string> {
+  const modelId = abbreviateModelId(status.model.id);
+  const modelStatus = `🤖 ${modelId} (${status.version})`;
+
+  const sessionStatus = `📃 ${status.session_id}`;
+
+  const projectDir = telescope(compress(status.workspace.project_dir));
+  const projectStatus = `🗂️ ${projectDir}`;
+
+  const statusWidth = terminalSize().columns - HORIZONTAL_PADDING;
+  const modelWidth = getDisplayWidth(modelStatus);
+  const sessionWidth = getDisplayWidth(sessionStatus);
+  const projectWidth = getDisplayWidth(projectStatus);
+
+  const remainingSpace = statusWidth - modelWidth - sessionWidth - projectWidth;
+  const leftGap = Math.floor(remainingSpace / 2);
+  const rightGap = Math.ceil(remainingSpace / 2);
+
+  return (
+    modelStatus +
+    " ".repeat(leftGap) +
+    sessionStatus +
+    " ".repeat(rightGap) +
+    projectStatus
+  );
+}
 
+async function renderLine2(status: Status): Promise<string> {
+  const branch = await currentBranchName();
+  const branchStatus = match(branch)
+    .with({ status: "none" }, () => {
+      return `💾`;
+    })
+    .with({ status: "branch" }, ({ name }) => {
+      return `🌿 ${name}`;
+    })
+    .with({ status: "detached" }, ({ commit }) => {
+      return `🪾 ${commit}`;
+    })
+    .with({ status: "error" }, () => {
+      return `💥`;
+    })
+    .exhaustive();
+
+  const usedPercentage = status.context_window.used_percentage ?? 0;
+  const usageStatus = usedPercentage === 0 ? "" : `${usedPercentage}%`;
+
+  const statusWidth = terminalSize().columns - HORIZONTAL_PADDING;
+  const branchWidth = getDisplayWidth(branchStatus);
+  const usageWidth = getDisplayWidth(usageStatus);
+
+  const gap = statusWidth - branchWidth - usageWidth;
+
+  return (
+    branchStatus + " ".repeat(gap - 1) + colorizeUsageStatus(usedPercentage)
+  );
+}
+
+async function renderTheme(status: Status): Promise<string> {
+  const line1 = await renderLine1(status);
+  const line2 = await renderLine2(status);
+  return [line1, line2].filter(Boolean).join("\n");
+}
+
+async function defaultTheme(input?: string): Promise<string> {
   if (input) {
-    const result = statusSchema.safeParse(input);
-
-    if (result.success) {
-      const status = result.data;
-      const currentDir = c.blue(currentDirStatus(status));
-      const git = c.green(await currentGitStatus());
-      const model = c.magenta(currentModelStatus(status));
-      const sessionId = c.blue(currentSessionId(status));
-      const separator = c.bold.gray(" ⋮ ");
-
-      statusLine = [
-        [currentDir, git],
-        [model, sessionId],
-      ]
-        .map((row) => row.join(separator))
-        .join("\n");
-    } else {
+    try {
+      const parsed = JSON.parse(input);
+      const status = statusSchema.parse(parsed);
+      return renderTheme(status);
+    } catch (e) {
+      const error =
+        e instanceof ZodError
+          ? JSON.stringify(e.issues)
+          : e instanceof Error
+            ? e.message
+            : JSON.stringify(e);
+
       log.error("Failed to parse input: {error}", {
-        error: JSON.stringify(z.treeifyError(result.error)),
+        error: error,
       });
-      statusLine = `[malformed status]`;
     }
-  } else {
-    statusLine = `[no status]`;
   }
 
-  return statusLine;
+  return "";
 }
 
 export { defaultTheme };

package/src/themes/powerlineTheme.ts

@@ -0,0 +1,150 @@
+import chalk from "chalk";
+import terminalSize from "terminal-size";
+import { match } from "ts-pattern";
+import { ZodError } from "zod";
+import { log } from "../logging";
+import { type Status, statusSchema } from "../schema/statusLine";
+import { currentBranchName } from "../utils/git";
+import { abbreviateModelId } from "../utils/model";
+import { compress, telescope } from "../utils/path";
+import { getDisplayWidth } from "../utils/term";
+
+// Right-pointing solid triangle (filled separator)
+const RPST = "\uE0B0";
+
+type Rgb = [number, number, number];
+
+interface Segment {
+  text: string;
+  bg: Rgb;
+}
+
+// Muted dark background colors for each segment type
+const BG_MODEL: Rgb = [30, 40, 80];
+const BG_SESSION: Rgb = [60, 30, 70];
+const BG_PROJECT: Rgb = [25, 65, 75];
+const BG_GIT: Rgb = [30, 65, 40];
+const BG_USAGE: Rgb = [85, 70, 20];
+
+/** Apply white foreground and RGB background color to text. */
+function styleContent(text: string, bg: Rgb): string {
+  return chalk.bgRgb(...bg)(chalk.white(text));
+}
+
+/** Render a separator arrow transitioning from one bg color to another (or to default). */
+function styleSep(from: Rgb, to?: Rgb): string {
+  const arrow = chalk.rgb(...from)(RPST);
+  return to ? chalk.bgRgb(...to)(arrow) : arrow;
+}
+
+/** Render an array of segments into a single powerline bar. */
+function renderBar(parts: Segment[]): string {
+  let result = "";
+  let prevBg: Rgb | undefined;
+  for (const seg of parts) {
+    if (prevBg) {
+      result += styleSep(prevBg, seg.bg);
+    }
+    result += styleContent(` ${seg.text} `, seg.bg);
+    prevBg = seg.bg;
+  }
+  if (prevBg) {
+    result += styleSep(prevBg);
+  }
+  return result;
+}
+
+/** Lay out segments across lines, wrapping when a segment would exceed maxWidth. */
+function layoutSegments(segments: Segment[], maxWidth: number): string {
+  const lines: string[] = [];
+  let currentParts: Segment[] = [];
+  let projectedWidth = 0;
+
+  for (const seg of segments) {
+    const contentWidth = getDisplayWidth(` ${seg.text} `);
+
+    if (projectedWidth === 0) {
+      // First segment on this line
+      projectedWidth = contentWidth + 1;
+      currentParts.push(seg);
+    } else if (projectedWidth + contentWidth + 1 <= maxWidth) {
+      // Fits on current line
+      projectedWidth += contentWidth + 1;
+      currentParts.push(seg);
+    } else {
+      // Doesn't fit — close current line and start a new one
+      lines.push(renderBar(currentParts));
+      currentParts = [seg];
+      projectedWidth = contentWidth + 1;
+    }
+  }
+
+  if (currentParts.length > 0) {
+    lines.push(renderBar(currentParts));
+  }
+
+  return lines.join("\n");
+}
+
+async function renderLine1(status: Status): Promise<string> {
+  const modelId = abbreviateModelId(status.model.id);
+  const modelText = `🤖 ${modelId} (${status.version})`;
+
+  const sessionText = `📃 ${status.session_id}`;
+
+  const projectDir = compress(telescope(status.workspace.project_dir));
+  const projectText = `🗂️ ${projectDir}`;
+
+  const branch = await currentBranchName();
+  const branchText = match(branch)
+    .with({ status: "none" }, () => `💾`)
+    .with({ status: "branch" }, ({ name }) => `🌿 ${name}`)
+    .with({ status: "detached" }, ({ commit }) => `🪾 ${commit}`)
+    .with({ status: "error" }, () => `💥`)
+    .exhaustive();
+
+  const usedPercentage = status.context_window.used_percentage ?? 0;
+
+  const segments: Segment[] = [
+    { text: modelText, bg: BG_MODEL },
+    { text: sessionText, bg: BG_SESSION },
+    { text: projectText, bg: BG_PROJECT },
+    { text: branchText, bg: BG_GIT },
+  ];
+
+  if (usedPercentage > 0) {
+    segments.push({ text: `${usedPercentage}%`, bg: BG_USAGE });
+  }
+
+  const maxWidth = terminalSize().columns;
+  return layoutSegments(segments, maxWidth);
+}
+
+async function renderTheme(status: Status): Promise<string> {
+  return renderLine1(status);
+}
+
+async function powerlineTheme(input?: string): Promise<string> {
+  if (input) {
+    try {
+      const parsed = JSON.parse(input);
+      const status = statusSchema.parse(parsed);
+      return renderTheme(status);
+    } catch (e) {
+      const error =
+        e instanceof ZodError
+          ? JSON.stringify(e.issues)
+          : e instanceof Error
+            ? e.message
+            : JSON.stringify(e);
+
+      log.error("Failed to parse input: {error}", {
+        error: error,
+      });
+    }
+  }
+
+  return "";
+}
+
+export { powerlineTheme };

package/src/utils/git.ts

@@ -0,0 +1,89 @@
+import { type SimpleGit, simpleGit } from "simple-git";
+import { match } from "ts-pattern";
+
+/**
+ * Result type for currentBranchName function.
+ * - `branch`: The current branch name when on a branch
+ * - `detached`: In detached HEAD state (checked out a specific commit)
+ * - `error`: Failed to get branch info (not a git repo, etc.)
+ */
+type BranchResult =
+  | { status: "none" }
+  | { status: "branch"; name: string }
+  | { status: "detached"; commit: string }
+  | { status: "error"; message: string };
+
+/**
+ * Gets the current git branch name using simple-git.
+ * Handles edge cases like detached HEAD state and non-git directories.
+ * @param cwd - Optional working directory (defaults to process.cwd())
+ * @returns BranchResult indicating branch name, detached state, or error
+ */
+async function currentBranchName(cwd?: string): Promise<BranchResult> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    // Check if we're in a git repository first
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return { status: "none" };
+    }
+
+    const branchSummary = await git.branch();
+    const current = branchSummary.current;
+
+    // Detached HEAD: current will be a commit hash or empty
+    // In detached state, branchSummary.detached is true
+    if (branchSummary.detached) {
+      // Get the short commit hash for display
+      const shortHash = await git.revparse(["--short", "HEAD"]);
+      return { status: "detached", commit: shortHash.trim() };
+    }
+
+    // Empty current can happen in fresh repos with no commits
+    // Use symbolic-ref as fallback to get the intended branch name
+    if (!current) {
+      try {
+        const symbolicRef = await git.raw(["symbolic-ref", "--short", "HEAD"]);
+        const branchName = symbolicRef.trim();
+        if (branchName) {
+          return { status: "branch", name: branchName };
+        }
+      } catch {
+        // symbolic-ref fails in detached HEAD, but we already checked for that
+      }
+      return { status: "error", message: "Unable to determine current branch" };
+    }
+
+    return { status: "branch", name: current };
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Unknown error occurred";
+    return { status: "error", message };
+  }
+}
+
+/**
+ * Returns a formatted git status string with emoji indicators.
+ * Uses the current working directory to determine git state.
+ *
+ * @returns A formatted string:
+ *   - `🌿 <branch>` - On a branch (e.g., "🌿 main")
+ *   - `🪾 <hash>` - Detached HEAD with short commit hash
+ *   - `💾` - Not in a git repository
+ *   - `💥` - Error determining git status
+ */
+async function currentGitStatus() {
+  const gitBranch = await currentBranchName();
+  const gitStatus = match(gitBranch)
+    .with({ status: "branch" }, ({ name }) => `🌿 ${name}`)
+    .with({ status: "detached" }, ({ commit }) => `🪾 ${commit}`)
+    .with({ status: "none" }, () => "💾")
+    .with({ status: "error" }, () => "💥")
+    .exhaustive();
+
+  return gitStatus;
+}
+
+export { currentBranchName, currentGitStatus };
+export type { BranchResult };

package/src/utils/model.ts

@@ -0,0 +1,23 @@
+/**
+ * Abbreviates a model ID by stripping the "claude-" prefix and truncating
+ * to `tail` characters (using `…` prefix when truncated).
+ *
+ * @param model - The model ID string
+ * @param options.tail - Maximum character length of the result (default: 12).
+ *
+ * @example abbreviateModelId("claude-opus-4.5")           // "opus-4.5"
+ * @example abbreviateModelId("some-very-long-model-name") // "…-model-name"
+ */
+function abbreviateModelId(model: string, options?: { tail?: number }): string {
+  const tail = options?.tail ?? 12;
+
+  // Step 1: Strip "claude-" prefix
+  const name = model.replace(/^claude-/, "");
+
+  // Step 2: Truncate if needed, keeping the last (tail - 1) chars
+  if (name.length <= tail) return name;
+  if (tail <= 1) return "…";
+  return `…${name.slice(-(tail - 1))}`;
+}
+
+export { abbreviateModelId };

package/src/utils/path.ts

@@ -0,0 +1,95 @@
+import { homedir } from "node:os";
+
+const HORIZONTAL_ELLIPSIS = "\u2026";
+
+/**
+ * Compresses a path by converting all segments except the last to a single character.
+ *
+ * @param path - The path to compress
+ * @returns The compressed path
+ *
+ * @example compress("/home/username/foo/bar/baz") // "/h/u/f/b/baz"
+ * @example compress("/foo/bar/baz")               // "/f/b/baz"
+ * @example compress("~/projects/myapp")           // "~/p/myapp"
+ * @example compress("a/b/c/d")                    // "a/b/c/d"
+ */
+function compress(path: string): string {
+  const segments = path.split("/");
+
+  if (segments.length <= 1) {
+    return path;
+  }
+
+  const compressed = segments.map((segment, index) => {
+    // Keep last segment full, compress others to first char
+    if (index === segments.length - 1) return segment;
+
+    // For empty segments (absolute path root), keep empty
+    if (segment === "") return segment;
+
+    return segment[0];
+  });
+
+  return compressed.join("/");
+}
+
+/**
+ * Converts a path starting with the home directory to use `~`.
+ *
+ * @param path - The path to convert
+ * @returns The path with home directory replaced by `~`, or the original path if it doesn't start with home
+ *
+ * @example tildify("/home/user/projects/myapp") // "~/projects/myapp"
+ * @example tildify("/home/user")                // "~"
+ * @example tildify("/etc/nginx")                // "/etc/nginx"
+ */
+function tildify(path: string): string {
+  const home = homedir();
+
+  if (path === home) {
+    return "~";
+  }
+
+  if (path.startsWith(`${home}/`)) {
+    return `~${path.slice(home.length)}`;
+  }
+
+  return path;
+}
+
+/**
+ * Telescopes a path by keeping only the first and last segments,
+ * with a horizontal ellipsis in between.
+ *
+ * First tildifies the path, then applies the telescoping transformation.
+ * If the path has 2 or fewer segments, it is returned unchanged.
+ *
+ * @param path - The path to telescope
+ * @returns The telescoped path
+ *
+ * @example telescope("/home/user/projects/myapp") // "~/…/myapp"
+ * @example telescope("/a/b/c/d")                  // "/a/…/d"
+ * @example telescope("~/a/b/c")                   // "~/…/c"
+ * @example telescope("a/b/c")                     // "a/…/c"
+ * @example telescope("~/foo")                     // "~/foo"
+ */
+function telescope(path: string): string {
+  const tildified = tildify(path);
+  const segments = tildified.split("/");
+
+  if (segments.length <= 2) {
+    return tildified;
+  }
+
+  const first = segments[0];
+  const last = segments[segments.length - 1];
+
+  // Handle absolute paths: first segment is empty string
+  if (first === "" && segments.length > 1) {
+    return `/${segments[1]}/${HORIZONTAL_ELLIPSIS}/${last}`;
+  }
+
+  return `${first}/${HORIZONTAL_ELLIPSIS}/${last}`;
+}
+
+export { compress, tildify, telescope, HORIZONTAL_ELLIPSIS };

package/src/utils/term.ts

@@ -0,0 +1,21 @@
+const EMOJI_REGEX = /\p{Extended_Pictographic}/gu;
+
+/**
+ * Calculates the display width of a string, accounting for emojis
+ * which occupy 2 character columns in terminal displays.
+ *
+ * @param str - The string to measure
+ * @returns The display width in columns
+ */
+function getDisplayWidth(str: string): number {
+  // 1. Count regular characters
+  const charCount = Array.from(str).length;
+
+  // 2. Count emojis (each emoji counts as 2 characters)
+  const emojiCount = (str.match(EMOJI_REGEX) || []).length;
+
+  // 3. Total width = characters + extra count for emojis (since each emoji is 2 wide)
+  return charCount + emojiCount;
+}
+
+export { getDisplayWidth };

package/src/utils.ts

@@ -1,173 +0,0 @@
-import { homedir } from "node:os";
-import { simpleGit, type SimpleGit } from "simple-git";
-import { match } from "ts-pattern";
-import type { Status } from "./statusLineSchema";
-
-/**
- * Abbreviates a path by reducing all segments except the last to their first character.
- * If the path starts with the home directory, it's replaced with ~.
- * @example abbreviatePath("/home/user/projects/myapp") // "~/p/myapp"
- * @example abbreviatePath("/foo/bar/baz/etc/last") // "/f/b/b/e/last"
- */
-function abbreviatePath(path: string): string {
-  const home = homedir();
-
-  // Replace homedir with ~ if path starts with it
-  let normalizedPath = path;
-  let prefix = "";
-  if (path.startsWith(home)) {
-    normalizedPath = path.slice(home.length);
-    prefix = "~";
-  }
-
-  const segments = normalizedPath.split("/");
-  if (segments.length <= 1) return prefix + normalizedPath;
-
-  const abbreviated = segments.map((segment, index) => {
-    // Keep last segment full, abbreviate others to first char (if non-empty)
-    if (index === segments.length - 1) return segment;
-    return segment.length > 0 ? segment[0] : segment;
-  });
-
-  return prefix + abbreviated.join("/");
-}
-
-/**
- * Removes the "claude-" prefix from a model name if present.
- * @example abbreviateModelId("claude-opus-4.5") // "opus-4.5"
- * @example abbreviateModelId("opus-4.5") // "opus-4.5"
- */
-function abbreviateModelId(model: string): string {
-  return model.startsWith("claude-") ? model.slice(7) : model;
-}
-
-/**
- * Result type for currentBranchName function.
- * - `branch`: The current branch name when on a branch
- * - `detached`: In detached HEAD state (checked out a specific commit)
- * - `error`: Failed to get branch info (not a git repo, etc.)
- */
-type BranchResult =
-  | { status: "not-git" }
-  | { status: "branch"; name: string }
-  | { status: "detached"; commit: string }
-  | { status: "error"; message: string };
-
-/**
- * Gets the current git branch name using simple-git.
- * Handles edge cases like detached HEAD state and non-git directories.
- * @param cwd - Optional working directory (defaults to process.cwd())
- * @returns BranchResult indicating branch name, detached state, or error
- */
-async function currentBranchName(cwd?: string): Promise<BranchResult> {
-  const git: SimpleGit = simpleGit(cwd);
-
-  try {
-    // Check if we're in a git repository first
-    const isRepo = await git.checkIsRepo();
-    if (!isRepo) {
-      return { status: "not-git" };
-    }
-
-    const branchSummary = await git.branch();
-    const current = branchSummary.current;
-
-    // Detached HEAD: current will be a commit hash or empty
-    // In detached state, branchSummary.detached is true
-    if (branchSummary.detached) {
-      // Get the short commit hash for display
-      const shortHash = await git.revparse(["--short", "HEAD"]);
-      return { status: "detached", commit: shortHash.trim() };
-    }
-
-    // Empty current can happen in fresh repos with no commits
-    // Use symbolic-ref as fallback to get the intended branch name
-    if (!current) {
-      try {
-        const symbolicRef = await git.raw(["symbolic-ref", "--short", "HEAD"]);
-        const branchName = symbolicRef.trim();
-        if (branchName) {
-          return { status: "branch", name: branchName };
-        }
-      } catch {
-        // symbolic-ref fails in detached HEAD, but we already checked for that
-      }
-      return { status: "error", message: "Unable to determine current branch" };
-    }
-
-    return { status: "branch", name: current };
-  } catch (error) {
-    const message =
-      error instanceof Error ? error.message : "Unknown error occurred";
-    return { status: "error", message };
-  }
-}
-
-/**
- * Returns a formatted git status string with emoji indicators.
- * Uses the current working directory to determine git state.
- *
- * @returns A formatted string:
- *   - `🌿 <branch>` - On a branch (e.g., "🌿 main")
- *   - `🪾 <hash>` - Detached HEAD with short commit hash
- *   - `💾` - Not in a git repository
- *   - `💥` - Error determining git status
- */
-async function currentGitStatus() {
-  const gitBranch = await currentBranchName();
-  const gitStatus = match(gitBranch)
-    .with({ status: "branch" }, ({ name }) => `🌿 ${name}`)
-    .with({ status: "detached" }, ({ commit }) => `🪾 ${commit}`)
-    .with({ status: "not-git" }, () => "💾")
-    .with({ status: "error" }, () => "💥")
-    .exhaustive();
-
-  return gitStatus;
-}
-
-/**
- * Returns a formatted model status string with the Claude icon.
- * Strips the "claude-" prefix from the model ID for brevity.
- *
- * @param status - The Status object containing model information
- * @returns A formatted string like "⏣ opus-4.5" or "⏣ sonnet-4"
- */
-function currentModelStatus(status: Status) {
-  return `⏣ ${abbreviateModelId(status.model.id)}`;
-}
-
-/**
- * Returns a formatted directory status string showing workspace location.
- * Both paths are abbreviated (e.g., "/home/user/projects" → "~/p").
- *
- * @param status - The Status object containing workspace information
- * @returns Either the abbreviated project directory alone (when current dir matches),
- *          or "projectDir/currentDir" format when projectDir/currentDir don't match
- * @example currentDirStatus({...}) // "🗂️ ~/p/myapp" or "🗂️ ~/p/myapp 📂 ~/s/components"
- */
-function currentDirStatus(status: Status) {
-  const projectDir = abbreviatePath(status.workspace.project_dir);
-  const currentDir = abbreviatePath(status.workspace.current_dir);
-  const dirStatus =
-    projectDir === currentDir
-      ? `🗂️ ${projectDir}`
-      : `🗂️ ${projectDir} 📂 ${currentDir}`;
-
-  return dirStatus;
-}
-
-function currentSessionId(status: Status) {
-  return `📝 ${status.session_id}`;
-}
-
-export {
-  abbreviateModelId,
-  abbreviatePath,
-  currentBranchName,
-  currentDirStatus,
-  currentGitStatus,
-  currentModelStatus,
-  currentSessionId,
-};
-
-export type { BranchResult };