aiblueprint-cli 1.4.59 → 1.4.60

package/agents-config/scripts/biome.json

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

package/agents-config/scripts/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "scripts",
+	"type": "module",
+	"scripts": {
+		"test": "bun test statusline",
+		"statusline:start": "bun statusline/src/index.ts",
+		"statusline:test": "bun test statusline",
+		"statusline:test-fixtures": "bun statusline/test-with-fixtures.ts",
+		"statusline:config": "bun statusline/src/commands/interactive-config.ts",
+		"statusline:lint": "biome check --write statusline",
+		"lint": "biome check --write .",
+		"format": "biome format --write ."
+	},
+	"dependencies": {
+		"picocolors": "^1.1.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.2",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5.0.0"
+	}
+}

package/agents-config/scripts/statusline/CLAUDE.md

@@ -0,0 +1,87 @@
+# Claude Code Statusline - Project Memory
+
+## Overview
+
+Lightweight, type-safe statusline implementation for Claude Code using Bun and TypeScript. Displays session context, git status, model information, duration, and context usage without premium spend or usage-limit tracking.
+
+## Project Setup & Configuration
+
+### Dependencies
+
+- **Bun**: Runtime
+- **picocolors**: Terminal colors
+- **@biomejs/biome**: Linting and formatting
+- **TypeScript**: Type safety
+
+### Configuration in Claude Code
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bun /Users/melvynx/.claude/scripts/statusline/src/index.ts",
+    "padding": 0
+  }
+}
+```
+
+## Architecture
+
+```
+src/
+├── index.ts              # Main entry point
+└── lib/
+    ├── types.ts          # TypeScript interfaces
+    ├── git.ts            # Git operations
+    ├── context.ts        # Payload/transcript context calculation
+    ├── render-pure.ts    # Pure rendering logic
+    └── formatters.ts     # Display utilities and colors
+```
+
+## Data Flow
+
+```
+Claude Code hook -> stdin JSON -> index.ts
+                                -> get git status
+                                -> get context data
+                                -> render statusline
+                                -> stdout
+```
+
+## Component Notes
+
+- `lib/context.ts` calculates context tokens from the hook payload when available, falling back to transcript parsing.
+- `lib/git.ts` detects branch and staged/unstaged changes.
+- `lib/render-pure.ts` renders output from prepared data and config.
+- `src/commands/interactive-config.ts` must stay in sync with `statusline.config.json`.
+
+## Development
+
+```bash
+bun run test
+bun run statusline:test-fixtures
+bun run statusline:config
+```
+
+Manual test:
+
+```bash
+echo '{ ... }' | bun run statusline:start
+```
+
+## Error Handling
+
+The statusline should fail softly:
+
+- Missing transcript -> 0 tokens, 0%
+- Git errors -> no-git fallback
+- Missing config -> default config
+- Invalid stdin -> concise error output
+
+## Critical Requirements
+
+- Keep `statusline.config.json`, `defaults.json`, and `src/commands/interactive-config.ts` aligned.
+- Use Bun for runtime and tests.
+- Keep this free version lightweight: no spend database, no usage-limit API, no OAuth credential dependency.

package/agents-config/scripts/statusline/README.md

@@ -0,0 +1,117 @@
+# Claude Code Statusline
+
+Lightweight statusline for Claude Code with TypeScript + Bun.
+
+## Features
+
+- Git branch with staged/unstaged indicators
+- Current working directory
+- Model name and thinking status
+- Session duration
+- Context tokens and percentage
+
+## Structure
+
+```
+src/
+├── index.ts              # Main entry point
+└── lib/
+    ├── types.ts          # TypeScript interfaces
+    ├── git.ts            # Git status
+    ├── context.ts        # Context calculation from payload/transcript
+    └── formatters.ts     # Formatting utilities
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run the statusline (needs stdin JSON)
+echo '{ ... }' | bun run statusline:start
+
+# Interactive config
+bun run statusline:config
+
+# Format code
+bun run format
+
+# Lint code
+bun run lint
+```
+
+## Interactive Config
+
+Explore all configuration options with a live preview:
+
+```bash
+bun run statusline:config
+```
+
+This opens an interactive menu where you can:
+- Toggle any config option with arrow keys and spacebar
+- See instant preview of how the statusline changes
+- Navigate through all available settings
+- Reset to defaults with `R`
+- Explore session, context, path, and git display options
+
+**Controls:**
+- `↑↓` or `j/k` - Navigate options
+- `Space` - Toggle selected option
+- `R` - Reset to defaults
+- `Q` - Quit
+
+## Configuration
+
+The statusline can be customized via `statusline.config.json`.
+
+### Other Configuration Options
+
+- **Session display**: Duration, tokens, context percentage
+- **Git display**: Branch, changes, staged/unstaged files
+- **Path display**: Full, truncated, or basename modes
+- **Progress bars**: Multiple styles and color schemes
+
+See `statusline.config.json` for all available options and defaults.
+
+## Usage in Claude Code
+
+Update your `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bun /Users/melvynx/.claude/scripts/statusline/src/index.ts",
+    "padding": 0
+  }
+}
+```
+
+## Testing
+
+```bash
+echo '{
+  "session_id": "test",
+  "transcript_path": "/path/to/transcript.jsonl",
+  "cwd": "/path",
+  "model": {
+    "id": "claude-sonnet-4-5",
+    "display_name": "Sonnet 4.5"
+  },
+  "workspace": {
+    "current_dir": "/path",
+    "project_dir": "/path"
+  },
+  "version": "2.0.31",
+  "output_style": { "name": "default" },
+  "cost": {
+    "total_cost_usd": 0.15,
+    "total_duration_ms": 300000,
+    "total_api_duration_ms": 200000,
+    "total_lines_added": 100,
+    "total_lines_removed": 50
+  }
+}' | bun run statusline:start
+```

package/agents-config/scripts/statusline/__tests__/context.test.ts

@@ -0,0 +1,229 @@
+import { afterAll, beforeAll, describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getContextData, getContextLength } from "../src/lib/context";
+
+const TEST_DIR = join(import.meta.dir, "..", "fixtures", "test-transcripts");
+
+beforeAll(() => {
+	mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterAll(() => {
+	rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+function createTranscript(lines: object[]): string {
+	return lines.map((l) => JSON.stringify(l)).join("\n");
+}
+
+describe("getContextLength", () => {
+	it("should return 0 for empty transcript", async () => {
+		const path = join(TEST_DIR, "empty.jsonl");
+		writeFileSync(path, "");
+		expect(await getContextLength(path)).toBe(0);
+	});
+
+	it("should return 0 for transcript with no usage data", async () => {
+		const path = join(TEST_DIR, "no-usage.jsonl");
+		const content = createTranscript([
+			{ type: "user", message: { role: "user", content: "hello" } },
+		]);
+		writeFileSync(path, content);
+		expect(await getContextLength(path)).toBe(0);
+	});
+
+	it("should calculate tokens from most recent entry", async () => {
+		const path = join(TEST_DIR, "with-usage.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 1000, output_tokens: 100 },
+				},
+			},
+			{
+				timestamp: "2025-01-01T10:05:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 5000, output_tokens: 200 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+		expect(await getContextLength(path)).toBe(5000);
+	});
+
+	it("should include cache tokens in calculation", async () => {
+		const path = join(TEST_DIR, "with-cache.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: {
+						input_tokens: 1000,
+						cache_read_input_tokens: 2000,
+						cache_creation_input_tokens: 3000,
+						output_tokens: 100,
+					},
+				},
+			},
+		]);
+		writeFileSync(path, content);
+		expect(await getContextLength(path)).toBe(6000);
+	});
+
+	it("should skip sidechain entries", async () => {
+		const path = join(TEST_DIR, "with-sidechain.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 1000, output_tokens: 100 },
+				},
+			},
+			{
+				timestamp: "2025-01-01T10:05:00Z",
+				isSidechain: true,
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 99999, output_tokens: 200 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+		expect(await getContextLength(path)).toBe(1000);
+	});
+
+	it("should skip API error messages", async () => {
+		const path = join(TEST_DIR, "with-error.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 1000, output_tokens: 100 },
+				},
+			},
+			{
+				timestamp: "2025-01-01T10:05:00Z",
+				isApiErrorMessage: true,
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 99999, output_tokens: 200 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+		expect(await getContextLength(path)).toBe(1000);
+	});
+
+	it("should return 0 for non-existent file", async () => {
+		expect(await getContextLength("/non/existent/path.jsonl")).toBe(0);
+	});
+});
+
+describe("getContextData", () => {
+	it("should return zeros for non-existent file", async () => {
+		const result = await getContextData({
+			transcriptPath: "/non/existent/path.jsonl",
+			maxContextTokens: 200000,
+			autocompactBufferTokens: 45000,
+		});
+		expect(result).toEqual({ tokens: 0, percentage: 0 });
+	});
+
+	it("should calculate percentage correctly", async () => {
+		const path = join(TEST_DIR, "percentage.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 100000, output_tokens: 100 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+
+		const result = await getContextData({
+			transcriptPath: path,
+			maxContextTokens: 200000,
+			autocompactBufferTokens: 45000,
+		});
+
+		expect(result.tokens).toBe(100000);
+		expect(result.percentage).toBe(50);
+	});
+
+	it("should add autocompact buffer when useUsableContextOnly is true", async () => {
+		const path = join(TEST_DIR, "usable.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 50000, output_tokens: 100 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+
+		const result = await getContextData({
+			transcriptPath: path,
+			maxContextTokens: 200000,
+			autocompactBufferTokens: 45000,
+			useUsableContextOnly: true,
+		});
+
+		expect(result.tokens).toBe(95000);
+	});
+
+	it("should add overhead tokens", async () => {
+		const path = join(TEST_DIR, "overhead.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 50000, output_tokens: 100 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+
+		const result = await getContextData({
+			transcriptPath: path,
+			maxContextTokens: 200000,
+			autocompactBufferTokens: 45000,
+			overheadTokens: 20000,
+		});
+
+		expect(result.tokens).toBe(70000);
+	});
+
+	it("should cap percentage at 100", async () => {
+		const path = join(TEST_DIR, "over100.jsonl");
+		const content = createTranscript([
+			{
+				timestamp: "2025-01-01T10:00:00Z",
+				message: {
+					role: "assistant",
+					usage: { input_tokens: 250000, output_tokens: 100 },
+				},
+			},
+		]);
+		writeFileSync(path, content);
+
+		const result = await getContextData({
+			transcriptPath: path,
+			maxContextTokens: 200000,
+			autocompactBufferTokens: 45000,
+		});
+
+		expect(result.percentage).toBe(100);
+	});
+});

package/agents-config/scripts/statusline/__tests__/formatters.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from "bun:test";
+import {
+	formatCost,
+	formatDuration,
+	formatPath,
+	formatResetTime,
+	formatTokens,
+} from "../src/lib/formatters";
+
+describe("formatPath", () => {
+	it("should return basename for basename mode", () => {
+		expect(formatPath("/Users/test/project/src/file.ts", "basename")).toBe(
+			"file.ts",
+		);
+	});
+
+	it("should truncate long paths in truncated mode", () => {
+		const result = formatPath("/Users/test/deep/nested/path/file.ts");
+		expect(result).toContain("path");
+		expect(result).toContain("file.ts");
+	});
+
+	it("should handle Windows-style paths", () => {
+		expect(formatPath("C:\\Users\\test\\project\\file.ts", "basename")).toBe(
+			"file.ts",
+		);
+	});
+
+	it("should handle mixed separators", () => {
+		expect(formatPath("/Users/test\\mixed/path", "basename")).toBe("path");
+	});
+});
+
+describe("formatCost", () => {
+	it("should format with 1 decimal by default", () => {
+		expect(formatCost(1.234)).toBe("1.2");
+	});
+
+	it("should format as integer when specified", () => {
+		expect(formatCost(1.789, "integer")).toBe("2");
+	});
+
+	it("should format with 2 decimals when specified", () => {
+		expect(formatCost(1.789, "decimal2")).toBe("1.79");
+	});
+});
+
+describe("formatTokens", () => {
+	it("should format thousands with k suffix", () => {
+		const result = formatTokens(5000);
+		expect(result).toContain("5.0");
+		expect(result).toContain("k");
+	});
+
+	it("should format millions with m suffix", () => {
+		const result = formatTokens(1500000);
+		expect(result).toContain("1.5");
+		expect(result).toContain("m");
+	});
+
+	it("should return raw number for small values", () => {
+		const result = formatTokens(500);
+		expect(result).toContain("500");
+	});
+
+	it("should hide decimals when showDecimals is false", () => {
+		const result = formatTokens(5500, false);
+		expect(result).toContain("6");
+	});
+});
+
+describe("formatDuration", () => {
+	it("should format minutes only for short durations", () => {
+		expect(formatDuration(300000)).toBe("5m");
+	});
+
+	it("should format hours and minutes for long durations", () => {
+		expect(formatDuration(5400000)).toBe("1h 30m");
+	});
+
+	it("should handle zero duration", () => {
+		expect(formatDuration(0)).toBe("0m");
+	});
+});
+
+describe("formatResetTime", () => {
+	it("should return 'now' for past times", () => {
+		const pastTime = new Date(Date.now() - 60000).toISOString();
+		expect(formatResetTime(pastTime)).toBe("now");
+	});
+
+	it("should format future times with hours and minutes", () => {
+		const futureTime = new Date(Date.now() + 3700000).toISOString();
+		const result = formatResetTime(futureTime);
+		expect(result).toContain("h");
+		expect(result).toContain("m");
+	});
+
+	it("should format minutes only for short durations", () => {
+		const futureTime = new Date(Date.now() + 1800000).toISOString();
+		const result = formatResetTime(futureTime);
+		expect(result).toMatch(/^\d+m$/);
+	});
+
+	it("should return N/A for invalid dates", () => {
+		expect(formatResetTime("invalid-date")).toBe("N/A");
+	});
+});