@nutthead/cc-statusline 0.1.0

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "outputStyle": "Explanatory",
+  "permissions": {
+    "allow": [
+      "Bash(bun test:*)"
+    ]
+  }
+}

package/CLAUDE.md

@@ -0,0 +1,33 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+Default to using Bun instead of Node.js.
+
+- Use `bun <file>` instead of `node <file>` or `ts-node <file>`
+- Use `bun test` instead of `jest` or `vitest`
+- Use `bun build <file.ts>` instead of `webpack` or `esbuild`
+- Use `bun install` instead of `npm install` or `yarn install` or `pnpm install`
+- Use `bun run <script>` instead of `npm run <script>` or `yarn run <script>` or `pnpm run <script>`
+- Bun automatically loads .env, so don't use dotenv.
+
+## APIs
+
+- `bun:sqlite` for SQLite. Don't use `better-sqlite3`.
+- `Bun.sql` for Postgres. Don't use `pg` or `postgres.js`.
+- Prefer `Bun.file` over `node:fs`'s readFile/writeFile
+- Bun.$`ls` instead of execa.
+
+## Testing
+
+Use `bun test` to run tests.
+
+```ts#index.test.ts
+import { test, expect } from "bun:test";
+
+test("hello world", () => {
+  expect(1).toBe(1);
+});
+```
+
+For more information, read the Bun API docs in `node_modules/bun-types/docs/**.md`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Behrang Saeedzadeh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# Claude Code Status Line
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To build:
+
+```bash
+bun run build:binary
+```
+
+To copy to `~/.claude`:
+
+```bash
+bun run install:binary
+```
+
+## Configure your Claude Code's statusline
+
+Edit your `~/.claude/settings.json` file to include:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "/path/to/.claude/statusline",
+    "padding": 0
+  }
+}
+```
+
+## Logs
+
+Execution logs are stored in `~/.local/state/statusline/app.log`.
+
+## License
+
+MIT

package/bun.lock

@@ -0,0 +1,56 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "statusline",
+      "dependencies": {
+        "@logtape/file": "^1.3.6",
+        "@logtape/logtape": "^1.3.6",
+        "ansi-colors": "^4.1.3",
+        "simple-git": "^3.30.0",
+        "type-fest": "^5.3.1",
+        "zod": "^4.3.5",
+      },
+      "devDependencies": {
+        "@types/bun": "latest",
+      },
+      "peerDependencies": {
+        "typescript": "^5",
+      },
+    },
+  },
+  "packages": {
+    "@kwsites/file-exists": ["@kwsites/file-exists@1.1.1", "", { "dependencies": { "debug": "^4.1.1" } }, "sha512-m9/5YGR18lIwxSFDwfE3oA7bWuq9kdau6ugN4H2rJeyhFQZcG9AgSHkQtSD15a8WvTgfz9aikZMrKPHvbpqFiw=="],
+
+    "@kwsites/promise-deferred": ["@kwsites/promise-deferred@1.1.1", "", {}, "sha512-GaHYm+c0O9MjZRu0ongGBRbinu8gVAMd2UZjji6jVmqKtZluZnptXGWhz1E8j8D2HJ3f/yMxKAUC0b+57wncIw=="],
+
+    "@logtape/file": ["@logtape/file@1.3.6", "", { "peerDependencies": { "@logtape/logtape": "^1.3.6" } }, "sha512-wYh1qb8uOj2LtoAHyzCnkjvScJsJiOSYPcrPaaa3QxLdvR6ZQHo3939jRdeqkv5oQMW/rfMImmY7ma/kgW6Ogw=="],
+
+    "@logtape/logtape": ["@logtape/logtape@1.3.6", "", {}, "sha512-OaK8eal8zcjB0GZbllXKgUC2T9h/GyNLQyQXjJkf1yum7SZKTWs9gs/t8NMS0kVVaSnA7bhU0Sjws/Iy4e0/IQ=="],
+
+    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
+
+    "@types/node": ["@types/node@25.0.4", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-9L7EOcoPf2mpvBL6GbE4z6zY9oaaP389dZ5ZZ05n2K9p3e1rEUwcXqwhXIKRMbK/uV1U8MYactPf1XH0xmtZWg=="],
+
+    "ansi-colors": ["ansi-colors@4.1.3", "", {}, "sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw=="],
+
+    "bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
+
+    "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
+
+    "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="],
+
+    "simple-git": ["simple-git@3.30.0", "", { "dependencies": { "@kwsites/file-exists": "^1.1.1", "@kwsites/promise-deferred": "^1.1.1", "debug": "^4.4.0" } }, "sha512-q6lxyDsCmEal/MEGhP1aVyQ3oxnagGlBDOVSIB4XUVLl1iZh0Pah6ebC9V4xBap/RfgP2WlI8EKs0WS0rMEJHg=="],
+
+    "tagged-tag": ["tagged-tag@1.0.0", "", {}, "sha512-yEFYrVhod+hdNyx7g5Bnkkb0G6si8HJurOoOEgC8B/O0uXLHlaey/65KRv6cuWBNhBgHKAROVpc7QyYqE5gFng=="],
+
+    "type-fest": ["type-fest@5.3.1", "", { "dependencies": { "tagged-tag": "^1.0.0" } }, "sha512-VCn+LMHbd4t6sF3wfU/+HKT63C9OoyrSIf4b+vtWHpt2U7/4InZG467YDNMFMR70DdHjAdpPWmw2lzRdg0Xqqg=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+
+    "zod": ["zod@4.3.5", "", {}, "sha512-k7Nwx6vuWx1IJ9Bjuf4Zt1PEllcwe7cls3VNzm4CQ1/hgtFUK2bRNG3rvnpPUhFjmqJKAKtjV576KnUkHocg/g=="],
+  }
+}

package/fixtures/statusline-1.json

@@ -0,0 +1,26 @@
+{
+  "session_id": "fc9bbbee-466c-45b8-ad86-8f3d848823f2",
+  "transcript_path": "/home/amadeus/.claude/projects/-home-amadeus-Code-behrangsa-statusline/fc9bbbee-466c-45b8-ad86-8f3d848823f2.jsonl",
+  "cwd": "/home/amadeus/Code/behrangsa/statusline",
+  "model": { "id": "claude-opus-4-5-20251101", "display_name": "Opus 4.5" },
+  "workspace": {
+    "current_dir": "/home/amadeus/Code/behrangsa/statusline",
+    "project_dir": "/home/amadeus/Code/behrangsa/statusline"
+  },
+  "version": "2.1.3",
+  "output_style": { "name": "Explanatory" },
+  "cost": {
+    "total_cost_usd": 0,
+    "total_duration_ms": 1345,
+    "total_api_duration_ms": 0,
+    "total_lines_added": 0,
+    "total_lines_removed": 0
+  },
+  "context_window": {
+    "total_input_tokens": 0,
+    "total_output_tokens": 0,
+    "context_window_size": 200000,
+    "current_usage": null
+  },
+  "exceeds_200k_tokens": false
+}

package/fixtures/statusline-2.json

@@ -0,0 +1,31 @@
+{
+  "session_id": "09f8e582-5026-4970-9530-fdff14b0dbe9",
+  "transcript_path": "/home/amadeus/.claude/projects/-home-amadeus-Code-behrangsa-statusline/09f8e582-5026-4970-9530-fdff14b0dbe9.jsonl",
+  "cwd": "/home/amadeus/Code/behrangsa/statusline",
+  "model": { "id": "claude-opus-4-5-20251101", "display_name": "Opus 4.5" },
+  "workspace": {
+    "current_dir": "/home/amadeus/Code/behrangsa/statusline",
+    "project_dir": "/home/amadeus/Code/behrangsa/statusline"
+  },
+  "version": "2.1.3",
+  "output_style": { "name": "Explanatory" },
+  "cost": {
+    "total_cost_usd": 0.057773349999999994,
+    "total_duration_ms": 122167,
+    "total_api_duration_ms": 18488,
+    "total_lines_added": 0,
+    "total_lines_removed": 0
+  },
+  "context_window": {
+    "total_input_tokens": 753,
+    "total_output_tokens": 665,
+    "context_window_size": 200000,
+    "current_usage": {
+      "input_tokens": 10,
+      "output_tokens": 3,
+      "cache_creation_input_tokens": 212,
+      "cache_read_input_tokens": 21034
+    }
+  },
+  "exceeds_200k_tokens": false
+}

package/index.ts

@@ -0,0 +1,36 @@
+import { configure } from "@logtape/logtape";
+import { z } from "zod";
+import { log, logtapeConfig } from "./src/logging";
+import { statusSchema } from "./src/statusLineSchema";
+import {
+  currentDirStatus,
+  currentGitStatus,
+  currentModelStatus,
+} from "./src/utils";
+
+import c from "ansi-colors";
+
+await configure(logtapeConfig);
+
+const input = await Bun.stdin.stream().json();
+log.debug("stdin: {input}", input);
+
+const result = statusSchema.safeParse(input);
+
+let statusLine = null;
+if (result.success) {
+  const status = result.data;
+  const dirStatus = c.blue(currentDirStatus(status));
+  const gitStatus = c.green(await currentGitStatus());
+  const modelStatus = c.magenta(currentModelStatus(status));
+  const separator = c.bold.gray("⋮");
+
+  statusLine = `${dirStatus} ${separator} ${gitStatus} ${separator} ${modelStatus}`;
+} else {
+  log.error("Failed to parse input: {error}", {
+    error: JSON.stringify(z.treeifyError(result.error)),
+  });
+  statusLine = `[]`;
+}
+
+console.log(statusLine);

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@nutthead/cc-statusline",
+  "description": "Status Line for Claude Code",
+  "version": "0.1.0",
+  "module": "index.ts",
+  "type": "module",
+  "private": false,
+  "license": "MIT",
+  "author": {
+    "name": "Behrang Saeedzadeh",
+    "email": "hello@behrang.org",
+    "url": "https://behrang.org"
+  },
+  "scripts": {
+    "build:binary": "mkdir -p target && bun build --compile ./index.ts --outfile target/statusline",
+    "install:binary": "cp target/statusline ~/.claude/"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@logtape/file": "^1.3.6",
+    "@logtape/logtape": "^1.3.6",
+    "ansi-colors": "^4.1.3",
+    "simple-git": "^3.30.0",
+    "type-fest": "^5.3.1",
+    "zod": "^4.3.5"
+  },
+  "packageManager": "pnpm@10.28.0+sha512.05df71d1421f21399e053fde567cea34d446fa02c76571441bfc1c7956e98e363088982d940465fd34480d4d90a0668bc12362f8aa88000a64e83d0b0e47be48"
+}

package/src/logging.ts

@@ -0,0 +1,24 @@
+import { getFileSink } from "@logtape/file";
+import { getLogger, type Config } from "@logtape/logtape";
+import { homedir } from "node:os";
+
+const logtapeConfig: Config<"file", string> = {
+  sinks: {
+    file: getFileSink(`${homedir()}/.local/state/statusline/app.log`),
+  },
+  loggers: [
+    {
+      category: "statusline",
+      lowestLevel: "debug",
+      sinks: ["file"],
+    },
+    {
+      category: ["logtape", "meta"],
+      sinks: ["file"],
+    },
+  ],
+};
+
+const log = getLogger(["statusline"]);
+
+export { logtapeConfig, log };

package/src/statusLineSchema.test.ts

@@ -0,0 +1,22 @@
+import { test, expect, describe } from "bun:test";
+import { statusSchema } from "./statusLineSchema";
+import { readdirSync } from "node:fs";
+
+const fixturesDir = `${import.meta.dir}/../fixtures`;
+const fixtureFiles = readdirSync(fixturesDir).filter((f) =>
+  f.endsWith(".json")
+);
+
+describe("statusLineSchema", () => {
+  describe("fixtures validation", () => {
+    test.each(fixtureFiles)(
+      "%s does not lead to an error",
+      async (filename) => {
+        const fixture = await Bun.file(`${fixturesDir}/${filename}`).json();
+        const result = statusSchema.safeParse(fixture);
+
+        expect(result.success).toBe(true);
+      }
+    );
+  });
+});

package/src/statusLineSchema.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+
+export const statusSchema = z.object({
+  hook_event_name: z.string().optional(),
+  session_id: z.string(),
+  transcript_path: z.string(),
+  cwd: z.string(),
+  model: z.object({
+    id: z.string(),
+    display_name: z.string(),
+  }),
+  workspace: z.object({
+    current_dir: z.string(),
+    project_dir: z.string(),
+  }),
+  version: z.string(),
+  output_style: z
+    .object({
+      name: z.string(),
+    })
+    .optional(),
+  cost: z.object({
+    total_cost_usd: z.number(),
+    total_duration_ms: z.number(),
+    total_api_duration_ms: z.number(),
+    total_lines_added: z.number(),
+    total_lines_removed: z.number(),
+  }),
+  context_window: z
+    .object({
+      input_tokens: z.number().optional(),
+      output_tokens: z.number().optional(),
+      cache_creation_input_tokens: z.number().optional(),
+      cache_read_input_tokens: z.number().optional(),
+    })
+    .nullable(),
+});
+
+export type Status = z.infer<typeof statusSchema>;

package/src/utils.test.ts

@@ -0,0 +1,472 @@
+import { test, expect, describe, mock, beforeAll, afterAll } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Mock homedir to return a consistent value for testing
+mock.module("node:os", () => ({
+  homedir: () => "/home/testuser",
+}));
+
+// Import after mocking
+import {
+  abbreviatePath,
+  abbreviateModelId,
+  currentBranchName,
+  currentDirStatus,
+  currentGitStatus,
+  currentModelStatus,
+} from "./utils";
+import type { Status } from "./statusLineSchema";
+
+/** Default Status fixture with sensible test values */
+const defaultStatus: Status = {
+  session_id: "test-session",
+  transcript_path: "/tmp/transcript.json",
+  cwd: "/test/cwd",
+  model: {
+    id: "claude-opus-4.5",
+    display_name: "Test Model",
+  },
+  workspace: {
+    project_dir: "/home/testuser/project",
+    current_dir: "/home/testuser/project",
+  },
+  version: "1.0.0",
+  cost: {
+    total_cost_usd: 0,
+    total_duration_ms: 0,
+    total_api_duration_ms: 0,
+    total_lines_added: 0,
+    total_lines_removed: 0,
+  },
+  context_window: null,
+};
+
+describe("abbreviatePath", () => {
+  describe("home directory replacement", () => {
+    test("replaces homedir with ~ at start of path", () => {
+      expect(abbreviatePath("/home/testuser/projects/myapp")).toBe("~/p/myapp");
+    });
+
+    test("returns ~ for exact homedir match", () => {
+      expect(abbreviatePath("/home/testuser")).toBe("~");
+    });
+
+    test("does not replace homedir if not at start", () => {
+      expect(abbreviatePath("/var/home/testuser/data")).toBe("/v/h/t/data");
+    });
+
+    test("handles path immediately under homedir", () => {
+      expect(abbreviatePath("/home/testuser/file.txt")).toBe("~/file.txt");
+    });
+  });
+
+  describe("path abbreviation", () => {
+    test("abbreviates all segments except the last", () => {
+      expect(abbreviatePath("/foo/bar/baz/etc/last")).toBe("/f/b/b/e/last");
+    });
+
+    test("keeps single segment paths unchanged", () => {
+      expect(abbreviatePath("filename")).toBe("filename");
+    });
+
+    test("handles relative paths", () => {
+      expect(abbreviatePath("relative/path/here")).toBe("r/p/here");
+    });
+
+    test("handles two segment absolute paths", () => {
+      expect(abbreviatePath("/etc/nginx")).toBe("/e/nginx");
+    });
+
+    test("handles deep paths", () => {
+      expect(abbreviatePath("/a/b/c/d/e/f/g/target")).toBe(
+        "/a/b/c/d/e/f/g/target"
+      );
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handles empty string", () => {
+      expect(abbreviatePath("")).toBe("");
+    });
+
+    test("handles root path", () => {
+      expect(abbreviatePath("/")).toBe("/");
+    });
+
+    test("handles path with only one segment after root", () => {
+      expect(abbreviatePath("/single")).toBe("/single");
+    });
+
+    test("preserves trailing slash behavior", () => {
+      // Trailing slash creates empty last segment which is preserved
+      expect(abbreviatePath("/foo/bar/")).toBe("/f/b/");
+    });
+
+    test("handles homedir with subdirectories", () => {
+      expect(abbreviatePath("/home/testuser/Code/project/src")).toBe(
+        "~/C/p/src"
+      );
+    });
+  });
+});
+
+describe("abbreviateModelId", () => {
+  describe("claude prefix removal", () => {
+    test("removes claude- prefix from model name", () => {
+      expect(abbreviateModelId("claude-opus-4.5")).toBe("opus-4.5");
+    });
+
+    test("removes claude- prefix from sonnet model", () => {
+      expect(abbreviateModelId("claude-sonnet-4")).toBe("sonnet-4");
+    });
+
+    test("removes claude- prefix from haiku model", () => {
+      expect(abbreviateModelId("claude-haiku-3.5")).toBe("haiku-3.5");
+    });
+  });
+
+  describe("non-claude models", () => {
+    test("returns non-claude model unchanged", () => {
+      expect(abbreviateModelId("gpt-4")).toBe("gpt-4");
+    });
+
+    test("returns model without prefix unchanged", () => {
+      expect(abbreviateModelId("opus-4.5")).toBe("opus-4.5");
+    });
+
+    test("does not match partial claude prefix", () => {
+      expect(abbreviateModelId("claud-model")).toBe("claud-model");
+    });
+
+    test("does not match claude without hyphen", () => {
+      expect(abbreviateModelId("claudemodel")).toBe("claudemodel");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handles empty string", () => {
+      expect(abbreviateModelId("")).toBe("");
+    });
+
+    test("handles just the prefix", () => {
+      expect(abbreviateModelId("claude-")).toBe("");
+    });
+
+    test("is case-sensitive (uppercase not matched)", () => {
+      expect(abbreviateModelId("Claude-opus")).toBe("Claude-opus");
+    });
+
+    test("only removes prefix once", () => {
+      expect(abbreviateModelId("claude-claude-test")).toBe("claude-test");
+    });
+  });
+});
+
+describe("currentBranchName", () => {
+  describe("valid git repository", () => {
+    test("returns branch name for current repository", async () => {
+      // This test uses the actual repo we're in
+      const result = await currentBranchName(process.cwd());
+      expect(result.status).toBe("branch");
+      if (result.status === "branch") {
+        expect(result.name).toBe("master");
+      }
+    });
+  });
+
+  describe("non-git directory", () => {
+    let tempDir: string;
+
+    beforeAll(async () => {
+      tempDir = await mkdtemp(join(tmpdir(), "git-test-"));
+    });
+
+    afterAll(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    test("returns not-git status for non-git directory", async () => {
+      const result = await currentBranchName(tempDir);
+      expect(result.status).toBe("not-git");
+    });
+  });
+
+  describe("detached HEAD state", () => {
+    let tempDir: string;
+
+    beforeAll(async () => {
+      tempDir = await mkdtemp(join(tmpdir(), "git-detached-"));
+      // Initialize a git repo, create a commit, then detach HEAD
+      const proc = Bun.spawn(
+        [
+          "bash",
+          "-c",
+          `
+          cd "${tempDir}" &&
+          git init &&
+          git config user.email "test@test.com" &&
+          git config user.name "Test" &&
+          echo "test" > file.txt &&
+          git add file.txt &&
+          git commit -m "initial" &&
+          git checkout --detach HEAD
+        `,
+        ],
+        { stdout: "pipe", stderr: "pipe" }
+      );
+      await proc.exited;
+    });
+
+    afterAll(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    test("returns detached status with commit hash", async () => {
+      const result = await currentBranchName(tempDir);
+      expect(result.status).toBe("detached");
+      if (result.status === "detached") {
+        // Commit hash should be 7 characters (short hash)
+        expect(result.commit).toMatch(/^[a-f0-9]{7}$/);
+      }
+    });
+  });
+
+  describe("fresh git repository", () => {
+    let tempDir: string;
+
+    beforeAll(async () => {
+      tempDir = await mkdtemp(join(tmpdir(), "git-fresh-"));
+      const proc = Bun.spawn(["git", "init", tempDir], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      await proc.exited;
+    });
+
+    afterAll(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    test("returns branch name for fresh repo with no commits", async () => {
+      const result = await currentBranchName(tempDir);
+      // Fresh repos have a branch but no commits - should still work
+      expect(result.status).toBe("branch");
+      if (result.status === "branch") {
+        // Default branch is typically "master" or "main"
+        expect(["master", "main"]).toContain(result.name);
+      }
+    });
+  });
+});
+
+describe("currentGitStatus", () => {
+  describe("output format", () => {
+    test("returns branch emoji format in current repository", async () => {
+      // Since we're in a git repo on master branch
+      const result = await currentGitStatus();
+      expect(result).toBe("🌿 master");
+    });
+
+    test("returns a non-empty string", async () => {
+      const result = await currentGitStatus();
+      expect(typeof result).toBe("string");
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    test("result starts with one of the expected emojis", async () => {
+      const result = await currentGitStatus();
+      // Should start with 🌿, 🪾, 💾, or 💥
+      const validPrefixes = ["🌿", "🪾", "💾", "💥"];
+      const startsWithValidEmoji = validPrefixes.some((emoji) =>
+        result.startsWith(emoji)
+      );
+      expect(startsWithValidEmoji).toBe(true);
+    });
+  });
+});
+
+describe("currentModelStatus", () => {
+  describe("Claude models", () => {
+    test("formats opus model with icon and strips claude- prefix", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "claude-opus-4.5" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ opus-4.5");
+    });
+
+    test("formats sonnet model with icon and strips claude- prefix", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "claude-sonnet-4" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ sonnet-4");
+    });
+
+    test("formats haiku model with icon and strips claude- prefix", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "claude-haiku-3.5" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ haiku-3.5");
+    });
+  });
+
+  describe("non-Claude models", () => {
+    test("formats non-Claude model without modification", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "gpt-4-turbo" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ gpt-4-turbo");
+    });
+
+    test("keeps model name when already without claude- prefix", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "opus-4.5" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ opus-4.5");
+    });
+  });
+
+  describe("output format", () => {
+    test("always starts with Model icon", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "any-model" },
+      };
+      expect(currentModelStatus(status)).toStartWith("⏣ ");
+    });
+
+    test("returns string type", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "claude-opus-4.5" },
+      };
+      expect(typeof currentModelStatus(status)).toBe("string");
+    });
+  });
+
+  describe("edge cases", () => {
+    test("handles empty model id", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ ");
+    });
+
+    test("handles model id that is just 'claude-'", () => {
+      const status = {
+        ...defaultStatus,
+        model: { ...defaultStatus.model, id: "claude-" },
+      };
+      expect(currentModelStatus(status)).toBe("⏣ ");
+    });
+  });
+});
+
+describe("currentDirStatus", () => {
+  describe("same directory", () => {
+    test("returns single path when project and current dir match", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/project",
+          current_dir: "/home/testuser/project",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ ~/project");
+    });
+
+    test("abbreviates path segments except last", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/Code/myapp",
+          current_dir: "/home/testuser/Code/myapp",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ ~/C/myapp");
+    });
+  });
+
+  describe("different directories", () => {
+    test("returns both paths with separator when dirs differ", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/project",
+          current_dir: "/home/testuser/other",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ ~/project 📂 ~/other");
+    });
+
+    test("abbreviates both paths independently", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/Code/frontend",
+          current_dir: "/home/testuser/Code/backend",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ ~/C/frontend 📂 ~/C/backend");
+    });
+
+    test("handles deeply nested current directory", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/project",
+          current_dir: "/home/testuser/project/src/components",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ ~/project 📂 ~/p/s/components");
+    });
+  });
+
+  describe("path abbreviation", () => {
+    test("replaces home directory with ~", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/myapp",
+          current_dir: "/home/testuser/myapp",
+        },
+      };
+      expect(currentDirStatus(status)).toStartWith("🗂️ ~");
+    });
+
+    test("handles non-home paths", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/var/www/app",
+          current_dir: "/var/www/app",
+        },
+      };
+      expect(currentDirStatus(status)).toBe("🗂️ /v/w/app");
+    });
+  });
+
+  describe("output format", () => {
+    test("returns string type", () => {
+      expect(typeof currentDirStatus(defaultStatus)).toBe("string");
+    });
+
+    test("uses folder emoji as separator for different directories", () => {
+      const status = {
+        ...defaultStatus,
+        workspace: {
+          project_dir: "/home/testuser/a",
+          current_dir: "/home/testuser/b",
+        },
+      };
+      expect(currentDirStatus(status)).toContain(" 📂 ");
+    });
+  });
+});

package/src/utils.ts

@@ -0,0 +1,168 @@
+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;
+}
+
+export {
+  abbreviateModelId,
+  abbreviatePath,
+  currentBranchName,
+  currentDirStatus,
+  currentGitStatus,
+  currentModelStatus,
+};
+
+export type { BranchResult };

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}