@nutthead/cc-statusline 0.2.1 → 0.2.2

package/README.md

@@ -1,4 +1,17 @@
-# Claude Code Status Line
+# statusline
+
+Custom status line for Claude Code.
+
+## Preview
+
+The default theme renders a two-row status line:
+
+```
+🗂️ ~/C/b/statusline ⋮ 🌿 master
+⏣ opus-4-6 ⋮ 📝 fc9bbbee-...
+```
+
+Row 1 shows the abbreviated working directory and git branch. Row 2 shows the model and session ID.
 
 ## Install
 
@@ -6,11 +19,7 @@
 bunx @nutthead/cc-statusline install
 ```
 
-Use `--overwrite` to replace an existing installation.
-
-## Configure
-
-Add to `~/.claude/settings.json`:
+Then add to `~/.claude/settings.json`:
 
 ```json
 {
@@ -21,45 +30,55 @@ Add to `~/.claude/settings.json`:
 }
 ```
 
-### Custom Theme
+Use `--overwrite` to replace an existing installation.
+
+## Custom Themes
 
-1. Create a directory for the custom theme:
+Create a JS file that default-exports a theme function (e.g. `~/.config/cc-statusline/theme.js`):
 
-   ```bash
-   mkdir ~/.config/cc-statusline
-   ```
+```js
+export default function theme(input) {
+  if (!input) return "";
 
-2. Write a custom theme (e.g. in `~/.config/cc-statusline/theme.js`)
+  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;
 
-   ```js
-   export default function theme(input) {
-     if (input) {
-       // parse input
-       const json = JSON.parse(input);
+  return `${model} | ${dir} | ctx: ${Math.round(ctx)}%`;
+}
+```
+
+Then point to it in `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "~/.claude/statusline --theme ~/.config/cc-statusline/theme.js"
+  }
+}
+```
 
-       // construct status line
-       const statusLine = "...";
+## Available Fields
 
-       // return status line
-       return statusLine;
-     } else {
-       return "";
-     }
-   }
-   ```
+The JSON object passed to your theme function contains these fields:
 
-3. Configure Claude Code
+| 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"`          |
 
-   ```json
-   {
-     "statusLine": {
-       "type": "command",
-       "command": "~/.claude/statusline --theme ~/.config/cc-statusline/theme.js"
-     }
-   }
-   ```
+See [`src/statusLineSchema.ts`](src/statusLineSchema.ts) for the full schema.
 
-## Logs
+## Troubleshooting
 
 Execution logs are stored in `~/.local/state/statusline/app.log`.
 

package/bin/cc-statusline.js

@@ -9408,8 +9408,8 @@ var meow = (helpText, options = {}) => {
 };
 
 // src/cli.ts
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, copyFileSync, unlinkSync } from "node:fs";
+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";
@@ -9437,53 +9437,78 @@ var cli = meow(`
     }
   }
 });
-function build() {
+async function fileExists(path3) {
+  try {
+    await access(path3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var defaultFs = {
+  exists: fileExists,
+  mkdir: async (path3, options) => {
+    await mkdir(path3, options);
+  },
+  copy: async (src, dest) => {
+    await copyFile(src, dest);
+  },
+  remove: async (path3) => {
+    await unlink(path3);
+  }
+};
+async function build() {
   console.log("Building statusline binary...");
-  execSync("mkdir -p target && bun build --compile ./index.ts --outfile target/statusline", { stdio: "inherit" });
+  await mkdir("target", { recursive: true });
+  const result = spawnSync("bun", ["build", "--compile", "./index.ts", "--outfile", "target/statusline"], { stdio: "inherit" });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`Build failed with exit code ${result.status}`);
+  }
   console.log("Build complete.");
 }
-var defaultDeps = {
-  claudeDir: CLAUDE_DIR,
-  targetPath: TARGET_PATH,
-  sourcePath: join(process.cwd(), "target", BINARY_NAME),
-  doBuild: build,
-  existsSync,
-  mkdirSync,
-  copyFileSync,
-  unlinkSync
-};
-function installBinary(overwrite, deps = defaultDeps) {
-  deps.doBuild();
-  if (!deps.existsSync(deps.claudeDir)) {
-    deps.mkdirSync(deps.claudeDir, { recursive: true });
-  }
-  if (deps.existsSync(deps.targetPath)) {
-    if (!overwrite) {
-      console.error(`Error: ${deps.targetPath} already exists.`);
-      console.error("Use --overwrite to replace the existing file.");
-      process.exit(1);
-    }
-    console.log(`Overwriting existing file at ${deps.targetPath}...`);
-    deps.unlinkSync(deps.targetPath);
-  }
-  deps.copyFileSync(deps.sourcePath, deps.targetPath);
-  console.log(`Installed statusline to ${deps.targetPath}`);
+async function installBinary(options, deps) {
+  await deps.build();
+  if (!await deps.fs.exists(options.claudeDir)) {
+    await deps.fs.mkdir(options.claudeDir, { recursive: true });
+  }
+  if (await deps.fs.exists(options.targetPath)) {
+    if (!options.overwrite) {
+      throw new Error(`${options.targetPath} already exists. Use --overwrite to replace the existing file.`);
+    }
+    console.log(`Overwriting existing file at ${options.targetPath}...`);
+    await deps.fs.remove(options.targetPath);
+  }
+  await deps.fs.copy(options.sourcePath, options.targetPath);
+  console.log(`Installed statusline to ${options.targetPath}`);
 }
-function install(overwrite) {
-  installBinary(overwrite);
+async function install(overwrite) {
+  await installBinary({
+    overwrite,
+    claudeDir: CLAUDE_DIR,
+    targetPath: TARGET_PATH,
+    sourcePath: join(process.cwd(), "target", BINARY_NAME)
+  }, { fs: defaultFs, build });
 }
-function main() {
-  const command = cli.input[0];
-  switch (command) {
-    case "install":
-      install(cli.flags.overwrite);
-      break;
-    case undefined:
-      cli.showHelp();
-      break;
-    default:
-      console.error(`Unknown command: ${command}`);
-      cli.showHelp(1);
+async function main() {
+  try {
+    const command = cli.input[0];
+    switch (command) {
+      case "install":
+        await install(cli.flags.overwrite);
+        break;
+      case undefined:
+        cli.showHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        cli.showHelp(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
   }
 }
 if (__require.main == __require.module) {

package/bunfig.toml

@@ -0,0 +1,2 @@
+[test]
+preload = ["./test/setup.ts"]

package/index.ts

@@ -1,23 +1,21 @@
 import meow from "meow";
 import { configure } from "@logtape/logtape";
 import { log, logtapeConfig } from "./src/logging";
-import { defaultTheme } from "./src/defaultTheme";
+import { defaultTheme } from "./src/themes/defaultTheme";
 import { loadTheme } from "./src/theme/loadTheme";
 
 await configure(logtapeConfig);
 
 const cli = meow(
   `
-	Usage
-	  $ cc-statusline
+  Usage
+    $ cc-statusline
 
-	Options
-	  --theme, -t  Use a custom theme
+  Options
+   --theme, -t  Use a custom theme
 
-	Examples
-	  $ cc-statusline --rainbow
+  Examples
     $ cc-statusline --theme ~/.config/cc-statusline/basic.js
-	  
 `,
   {
     importMeta: import.meta, // This is required

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nutthead/cc-statusline",
   "description": "Status Line for Claude Code",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "bin": {
     "cc-statusline": "bin/cc-statusline.js"

package/src/cli.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 import meow from "meow";
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, copyFileSync, unlinkSync } from "node:fs";
+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";
 
@@ -36,81 +36,130 @@ const cli = meow(
   },
 );
 
-export function build(): void {
-  console.log("Building statusline binary...");
-  execSync(
-    "mkdir -p target && bun build --compile ./index.ts --outfile target/statusline",
-    { stdio: "inherit" },
-  );
-  console.log("Build complete.");
+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>;
 }
 
-export interface InstallDeps {
+interface InstallOptions {
+  overwrite: boolean;
   claudeDir: string;
   targetPath: string;
   sourcePath: string;
-  doBuild: () => void;
-  existsSync: (path: string) => boolean;
-  mkdirSync: (path: string, options?: { recursive?: boolean }) => void;
-  copyFileSync: (src: string, dest: string) => void;
-  unlinkSync: (path: string) => void;
 }
 
-const defaultDeps: InstallDeps = {
-  claudeDir: CLAUDE_DIR,
-  targetPath: TARGET_PATH,
-  sourcePath: join(process.cwd(), "target", BINARY_NAME),
-  doBuild: build,
-  existsSync,
-  mkdirSync,
-  copyFileSync,
-  unlinkSync,
+interface InstallDeps {
+  fs: FileSystem;
+  build: () => Promise<void>;
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+const defaultFs: FileSystem = {
+  exists: fileExists,
+  mkdir: async (path, options) => {
+    await mkdir(path, options);
+  },
+  copy: async (src, dest) => {
+    await copyFile(src, dest);
+  },
+  remove: async (path) => {
+    await unlink(path);
+  },
 };
 
-export function installBinary(
-  overwrite: boolean,
-  deps: InstallDeps = defaultDeps,
-): void {
-  deps.doBuild();
+async function build(): Promise<void> {
+  console.log("Building statusline binary...");
+  await mkdir("target", { recursive: true });
+  const result = spawnSync(
+    "bun",
+    ["build", "--compile", "./index.ts", "--outfile", "target/statusline"],
+    { stdio: "inherit" },
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`Build failed with exit code ${result.status}`);
+  }
+  console.log("Build complete.");
+}
 
-  if (!deps.existsSync(deps.claudeDir)) {
-    deps.mkdirSync(deps.claudeDir, { recursive: true });
+async function installBinary(
+  options: InstallOptions,
+  deps: InstallDeps,
+): Promise<void> {
+  await deps.build();
+
+  if (!(await deps.fs.exists(options.claudeDir))) {
+    await deps.fs.mkdir(options.claudeDir, { recursive: true });
   }
 
-  if (deps.existsSync(deps.targetPath)) {
-    if (!overwrite) {
-      console.error(`Error: ${deps.targetPath} already exists.`);
-      console.error("Use --overwrite to replace the existing file.");
-      process.exit(1);
+  if (await deps.fs.exists(options.targetPath)) {
+    if (!options.overwrite) {
+      throw new Error(
+        `${options.targetPath} already exists. Use --overwrite to replace the existing file.`,
+      );
     }
-    console.log(`Overwriting existing file at ${deps.targetPath}...`);
-    deps.unlinkSync(deps.targetPath);
+    console.log(`Overwriting existing file at ${options.targetPath}...`);
+    await deps.fs.remove(options.targetPath);
   }
 
-  deps.copyFileSync(deps.sourcePath, deps.targetPath);
-  console.log(`Installed statusline to ${deps.targetPath}`);
+  await deps.fs.copy(options.sourcePath, options.targetPath);
+  console.log(`Installed statusline to ${options.targetPath}`);
 }
 
-export function install(overwrite: boolean): void {
-  installBinary(overwrite);
+async function install(overwrite: boolean): Promise<void> {
+  await installBinary(
+    {
+      overwrite,
+      claudeDir: CLAUDE_DIR,
+      targetPath: TARGET_PATH,
+      sourcePath: join(process.cwd(), "target", BINARY_NAME),
+    },
+    { fs: defaultFs, build },
+  );
 }
 
-function main(): void {
-  const command = cli.input[0];
-
-  switch (command) {
-    case "install":
-      install(cli.flags.overwrite);
-      break;
-    case undefined:
-      cli.showHelp();
-      break;
-    default:
-      console.error(`Unknown command: ${command}`);
-      cli.showHelp(1);
+async function main(): Promise<void> {
+  try {
+    const command = cli.input[0];
+
+    switch (command) {
+      case "install":
+        await install(cli.flags.overwrite);
+        break;
+      case undefined:
+        cli.showHelp();
+        break;
+      default:
+        console.error(`Unknown command: ${command}`);
+        cli.showHelp(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
   }
 }
 
 if (import.meta.main) {
   main();
 }
+
+export {
+  build,
+  install,
+  installBinary,
+  type FileSystem,
+  type InstallDeps,
+  type InstallOptions,
+};

package/src/logging.ts

@@ -4,7 +4,9 @@ import { homedir } from "node:os";
 
 const logtapeConfig: Config<"file", string> = {
   sinks: {
-    file: getFileSink(`${homedir()}/.local/state/statusline/app.log`),
+    file: getFileSink(`${homedir()}/.local/state/statusline/app.log`, {
+      lazy: true,
+    }),
   },
   loggers: [
     {

package/src/statusLineSchema.ts

@@ -1,7 +1,6 @@
 import { z } from "zod";
 
-export const statusSchema = z.object({
-  hook_event_name: z.string().optional(),
+const statusSchema = z.object({
   session_id: z.string(),
   transcript_path: z.string(),
   cwd: z.string(),
@@ -14,26 +13,33 @@ export const statusSchema = z.object({
     project_dir: z.string(),
   }),
   version: z.string(),
-  output_style: z
-    .object({
+  output_style: z.object({
+    name: z.string(),
+  }),
+  context_window: z.object({
+    total_input_tokens: z.number(),
+    total_output_tokens: z.number(),
+    context_window_size: z.number(),
+    current_usage: z
+      .object({
+        input_tokens: z.number(),
+        output_tokens: z.number(),
+        cache_creation_input_tokens: z.number(),
+        cache_read_input_tokens: z.number(),
+      })
+      .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(),
-    })
-    .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(),
+      type: z.string(),
+    }),
   }),
-  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>;
+type Status = z.infer<typeof statusSchema>;
+
+export { statusSchema, type Status };

package/src/{defaultTheme.ts → themes/defaultTheme.ts}

@@ -1,12 +1,12 @@
 import { z } from "zod";
-import { log } from "./logging";
-import { statusSchema } from "./statusLineSchema";
+import { log } from "../logging";
+import { statusSchema } from "../statusLineSchema";
 import {
   currentDirStatus,
   currentGitStatus,
   currentModelStatus,
   currentSessionId,
-} from "./utils";
+} from "../utils";
 
 import c from "ansi-colors";
 
@@ -18,15 +18,15 @@ async function defaultTheme(input?: string): Promise<string> {
 
     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 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 = [
-        [dirStatus, gitStatus],
-        [modelStatus, sessionId],
+        [currentDir, git],
+        [model, sessionId],
       ]
         .map((row) => row.join(separator))
         .join("\n");