aiblueprint-cli 1.4.13 → 1.4.14

package/claude-code-config/scripts/CLAUDE.md

@@ -0,0 +1,50 @@
+# Scripts - Project Memory
+
+Monorepo containing Claude Code utilities and extensions.
+
+## Structure
+
+```
+scripts/
+├── auto-rename-session/  # Auto-generates session titles via AI
+├── claude-code-ai/       # Shared Claude API helpers
+├── command-validator/    # Security validation for bash commands
+├── statusline/           # Custom statusline for Claude Code
+└── package.json          # Root package with all scripts
+```
+
+## Commands
+
+```bash
+bun run test              # Run ALL tests (186 tests)
+bun run lint              # Lint all packages
+```
+
+### Per-Package Commands
+
+| Package | Test | Start |
+|---------|------|-------|
+| auto-rename-session | `bun run auto-rename:test` | `bun run auto-rename:start` |
+| claude-code-ai | `bun run ai:test` | - |
+| command-validator | `bun run validator:test` | `bun run validator:cli` |
+| statusline | `bun run statusline:test` | `bun run statusline:start` |
+
+## Cross-Platform Support
+
+All packages support macOS, Linux, and Windows (via WSL):
+- Use `path.join()` instead of string concatenation
+- Use `os.homedir()` instead of `process.env.HOME`
+- Use `path.sep` or regex `[/\\]` for path splitting
+
+## Shared Dependencies
+
+- `@ai-sdk/anthropic` + `ai` - Claude API access
+- `picocolors` - Terminal colors
+- `@biomejs/biome` - Linting/formatting
+- `bun:test` - Testing
+
+## Credentials
+
+Claude Code OAuth tokens are retrieved via `claude-code-ai/helper/credentials.ts`:
+- macOS: Keychain (`security find-generic-password`)
+- Linux/Windows: `~/.claude/.credentials.json`

package/claude-code-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/claude-code-config/scripts/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "scripts",
+  "type": "module",
+  "scripts": {
+    "test": "bun test auto-rename-session claude-code-ai statusline command-validator",
+    "auto-rename:start": "bun auto-rename-session/src/index.ts",
+    "auto-rename:rename-all": "bun auto-rename-session/src/rename-all.ts",
+    "auto-rename:test": "bun test auto-rename-session",
+    "validator:cli": "bun command-validator/src/cli.ts",
+    "validator:test": "bun test command-validator",
+    "validator:lint": "biome check --write command-validator",
+    "ai:test": "bun test claude-code-ai",
+    "statusline:start": "bun statusline/src/index.ts",
+    "statusline:test-fixtures": "bun statusline/test-with-fixtures.ts",
+    "statusline:test": "bun test statusline",
+    "statusline:spend:today": "bun statusline/src/lib/features/spend/commands/spend-today.ts",
+    "statusline:spend:month": "bun statusline/src/lib/features/spend/commands/spend-month.ts",
+    "statusline:spend:project": "bun statusline/src/lib/features/spend/commands/spend-project.ts",
+    "statusline:migrate": "bun statusline/src/lib/features/spend/commands/migrate-to-sqlite.ts",
+    "statusline:weekly": "bun statusline/src/lib/features/limits/commands/weekly-analysis.ts",
+    "statusline:lint": "biome check --write statusline",
+    "lint": "biome check --write .",
+    "format": "biome format --write ."
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.6",
+    "ai": "^6.0.11",
+    "picocolors": "^1.1.1",
+    "table": "^6.9.0",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.2",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/claude-code-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/claude-code-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");
+	});
+});