aiblueprint-cli 1.4.12 → 1.4.14

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");
+	});
+});

package/claude-code-config/scripts/statusline/__tests__/statusline.test.ts

@@ -0,0 +1,309 @@
+import { describe, expect, it } from "bun:test";
+import { renderStatusline, type StatuslineData } from "../src/index";
+import { defaultConfig, type StatuslineConfig } from "../src/lib/config";
+
+function createMockData(
+	overrides: Partial<StatuslineData> = {},
+): StatuslineData {
+	return {
+		branch: "main",
+		dirPath: "~/project",
+		modelName: "Sonnet 4.5",
+		sessionCost: "0.5",
+		sessionDuration: "10m",
+		contextTokens: 50000,
+		contextPercentage: 25,
+		usageLimits: {
+			five_hour: { utilization: 30, resets_at: "2025-01-01T15:00:00Z" },
+			seven_day: { utilization: 10, resets_at: "2025-01-07T00:00:00Z" },
+		},
+		periodCost: 1.5,
+		todayCost: 2.0,
+		...overrides,
+	};
+}
+
+function createConfig(
+	overrides: Partial<StatuslineConfig> = {},
+): StatuslineConfig {
+	return { ...defaultConfig, ...overrides };
+}
+
+describe("renderStatusline", () => {
+	describe("basic rendering", () => {
+		it("should render branch and directory", () => {
+			const data = createMockData();
+			const config = createConfig();
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("main");
+			expect(output).toContain("~/project");
+		});
+
+		it("should hide Sonnet model name when showSonnetModel is false", () => {
+			const data = createMockData({ modelName: "Sonnet 4.5" });
+			const config = createConfig({ showSonnetModel: false });
+			const output = renderStatusline(data, config);
+
+			expect(output).not.toContain("Sonnet");
+		});
+
+		it("should show Sonnet model name when showSonnetModel is true", () => {
+			const data = createMockData({ modelName: "Sonnet 4.5" });
+			const config = createConfig({ showSonnetModel: true });
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("Sonnet");
+		});
+
+		it("should always show non-Sonnet models", () => {
+			const data = createMockData({ modelName: "Opus 4.5" });
+			const config = createConfig({ showSonnetModel: false });
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("Opus");
+		});
+	});
+
+	describe("session info", () => {
+		it("should show cost when enabled", () => {
+			const data = createMockData({ sessionCost: "1.5" });
+			const config = createConfig({
+				session: {
+					...defaultConfig.session,
+					cost: { enabled: true, format: "decimal1" },
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("$");
+			expect(output).toContain("1.5");
+		});
+
+		it("should hide cost when disabled", () => {
+			const data = createMockData({ sessionCost: "1.5" });
+			const config = createConfig({
+				session: {
+					...defaultConfig.session,
+					cost: { enabled: false, format: "decimal1" },
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("S:");
+		});
+
+		it("should show duration when enabled", () => {
+			const data = createMockData({ sessionDuration: "15m" });
+			const config = createConfig({
+				session: {
+					...defaultConfig.session,
+					duration: { enabled: true },
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("15m");
+		});
+
+		it("should show percentage when enabled", () => {
+			const data = createMockData({ contextPercentage: 45 });
+			const config = createConfig({
+				session: {
+					...defaultConfig.session,
+					percentage: {
+						enabled: true,
+						showValue: true,
+						progressBar: {
+							...defaultConfig.session.percentage.progressBar,
+							enabled: false,
+						},
+					},
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("45");
+			expect(output).toContain("%");
+		});
+	});
+
+	describe("limits section", () => {
+		it("should show limits when enabled", () => {
+			const data = createMockData({
+				usageLimits: {
+					five_hour: { utilization: 50, resets_at: "2025-01-01T15:00:00Z" },
+					seven_day: null,
+				},
+			});
+			const config = createConfig({
+				limits: {
+					...defaultConfig.limits,
+					enabled: true,
+					percentage: {
+						enabled: true,
+						showValue: true,
+						progressBar: {
+							...defaultConfig.limits.percentage.progressBar,
+							enabled: false,
+						},
+					},
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("L:");
+			expect(output).toContain("50");
+		});
+
+		it("should hide limits when disabled", () => {
+			const data = createMockData();
+			const config = createConfig({
+				limits: { ...defaultConfig.limits, enabled: false },
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).not.toContain("L:");
+		});
+
+		it("should show reset time when enabled", () => {
+			const futureTime = new Date(Date.now() + 3600000).toISOString();
+			const data = createMockData({
+				usageLimits: {
+					five_hour: { utilization: 50, resets_at: futureTime },
+					seven_day: null,
+				},
+			});
+			const config = createConfig({
+				limits: {
+					...defaultConfig.limits,
+					enabled: true,
+					showTimeLeft: true,
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toMatch(/\(\d+[hm]/);
+		});
+	});
+
+	describe("weekly usage", () => {
+		it("should show weekly when enabled=true", () => {
+			const data = createMockData({
+				usageLimits: {
+					five_hour: { utilization: 30, resets_at: null },
+					seven_day: { utilization: 20, resets_at: null },
+				},
+			});
+			const config = createConfig({
+				weeklyUsage: {
+					...defaultConfig.weeklyUsage,
+					enabled: true,
+					percentage: {
+						enabled: true,
+						showValue: true,
+						progressBar: {
+							...defaultConfig.weeklyUsage.percentage.progressBar,
+							enabled: false,
+						},
+					},
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("W:");
+		});
+
+		it("should show weekly when enabled=90% and five_hour >= 90", () => {
+			const data = createMockData({
+				usageLimits: {
+					five_hour: { utilization: 95, resets_at: null },
+					seven_day: { utilization: 20, resets_at: null },
+				},
+			});
+			const config = createConfig({
+				weeklyUsage: {
+					...defaultConfig.weeklyUsage,
+					enabled: "90%",
+					percentage: {
+						enabled: true,
+						showValue: true,
+						progressBar: {
+							...defaultConfig.weeklyUsage.percentage.progressBar,
+							enabled: false,
+						},
+					},
+				},
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("W:");
+		});
+
+		it("should hide weekly when enabled=90% and five_hour < 90", () => {
+			const data = createMockData({
+				usageLimits: {
+					five_hour: { utilization: 50, resets_at: null },
+					seven_day: { utilization: 20, resets_at: null },
+				},
+			});
+			const config = createConfig({
+				weeklyUsage: { ...defaultConfig.weeklyUsage, enabled: "90%" },
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).not.toContain("W:");
+		});
+	});
+
+	describe("daily spend", () => {
+		it("should show daily cost when enabled and > 0", () => {
+			const data = createMockData({ todayCost: 5.5 });
+			const config = createConfig({
+				dailySpend: { cost: { enabled: true, format: "decimal1" } },
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("D:");
+			expect(output).toContain("5.5");
+		});
+
+		it("should hide daily cost when todayCost is 0", () => {
+			const data = createMockData({ todayCost: 0 });
+			const config = createConfig({
+				dailySpend: { cost: { enabled: true, format: "decimal1" } },
+			});
+			const output = renderStatusline(data, config);
+
+			expect(output).not.toContain("D:");
+		});
+	});
+
+	describe("separators", () => {
+		it("should use configured separator", () => {
+			const data = createMockData();
+			const config = createConfig({ separator: "|" });
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("|");
+		});
+	});
+
+	describe("one line vs two lines", () => {
+		it("should render on one line when oneLine is true", () => {
+			const data = createMockData();
+			const config = createConfig({ oneLine: true });
+			const output = renderStatusline(data, config);
+
+			expect(output.split("\n").length).toBe(1);
+		});
+
+		it("should render on two lines when oneLine is false", () => {
+			const data = createMockData();
+			const config = createConfig({ oneLine: false });
+			const output = renderStatusline(data, config);
+
+			expect(output).toContain("\n");
+		});
+	});
+});

package/claude-code-config/scripts/statusline/data/.gitignore

@@ -0,0 +1,8 @@
+# Ignore all data files
+*.db
+*.json
+
+# But keep this .gitignore
+!.gitignore
+
+last_payload.txt