aiblueprint-cli 1.1.4 → 1.1.8

package/claude-code-config/scripts/statusline/README.md

@@ -0,0 +1,105 @@
+# Claude Code Statusline
+
+Clean, modular statusline for Claude Code with TypeScript + Bun.
+
+## Features
+
+- 🌿 Git branch with changes (+added -deleted)
+- 💰 Session cost and duration
+- 🧩 Context tokens used
+- 📊 Context percentage (0-100%)
+- ⏱️ Five-hour usage limit with reset time
+
+## Structure
+
+```
+src/
+├── index.ts              # Main entry point
+└── lib/
+    ├── types.ts          # TypeScript interfaces
+    ├── git.ts            # Git status
+    ├── context.ts        # Context calculation from transcript
+    ├── usage-limits.ts   # Claude API usage limits
+    └── formatters.ts     # Formatting utilities
+```
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run the statusline (needs stdin JSON)
+echo '{ ... }' | bun run start
+
+# View today's spending
+bun run spend:today
+
+# View this month's spending
+bun run spend:month
+
+# Format code
+bun run format
+
+# Lint code
+bun run lint
+```
+
+## Spend Tracking
+
+The statusline automatically saves session data to `data/spend.json`. You can view your spending with:
+
+```bash
+# Today's sessions and cost
+bun run spend:today
+
+# This month's sessions grouped by date
+bun run spend:month
+```
+
+Each session tracks:
+- Cost (USD)
+- Duration
+- Lines added/removed
+- Working directory
+
+## 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 start
+```

package/claude-code-config/scripts/statusline/biome.json

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

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

@@ -0,0 +1,5 @@
+# Ignore all data and cache files
+*.json
+
+# But keep this .gitignore
+!.gitignore

package/claude-code-config/scripts/statusline/fixtures/test-input.json

@@ -0,0 +1,25 @@
+{
+	"session_id": "06a7b019-03f8-4083-a9db-410d95cb01e6",
+	"transcript_path": "/Users/melvynx/.claude/projects/-Users-melvynx--claude/06a7b019-03f8-4083-a9db-410d95cb01e6.jsonl",
+	"cwd": "/Users/melvynx/.claude",
+	"model": {
+		"id": "claude-sonnet-4-5-20250929",
+		"display_name": "Sonnet 4.5"
+	},
+	"workspace": {
+		"current_dir": "/Users/melvynx/.claude",
+		"project_dir": "/Users/melvynx/.claude"
+	},
+	"version": "2.0.31",
+	"output_style": {
+		"name": "default"
+	},
+	"cost": {
+		"total_cost_usd": 0.17468000000000003,
+		"total_duration_ms": 385160,
+		"total_api_duration_ms": 252694,
+		"total_lines_added": 185,
+		"total_lines_removed": 75
+	},
+	"exceeds_200k_tokens": false
+}

package/claude-code-config/scripts/statusline/package.json

@@ -0,0 +1,21 @@
+{
+	"name": "statusline",
+	"version": "1.0.0",
+	"module": "src/index.ts",
+	"type": "module",
+	"scripts": {
+		"start": "bun run src/index.ts",
+		"test": "bun run test.ts",
+		"spend:today": "bun run src/commands/spend-today.ts",
+		"spend:month": "bun run src/commands/spend-month.ts",
+		"lint": "biome check --write .",
+		"format": "biome format --write ."
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.3.2",
+		"@types/bun": "latest"
+	},
+	"peerDependencies": {
+		"typescript": "^5.0.0"
+	}
+}

package/claude-code-config/scripts/statusline/src/commands/CLAUDE.md

@@ -0,0 +1,3 @@
+Important :
+
+This folder only include command that we can run using `/Users/melvynx/.claude/scripts/statusline/package.json` commands. Please don't write anything else here.

package/claude-code-config/scripts/statusline/src/commands/spend-month.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env bun
+
+import { formatCost, formatDuration } from "../lib/formatters";
+import {
+	calculateTotalCost,
+	calculateTotalDuration,
+	filterSessionsByDate,
+	getMonthStart,
+	loadSpendData,
+} from "../lib/spend";
+
+async function main() {
+	const data = await loadSpendData();
+	const monthStart = getMonthStart();
+	const monthSessions = filterSessionsByDate(data.sessions, monthStart);
+
+	if (monthSessions.length === 0) {
+		console.log("📊 No sessions this month");
+		return;
+	}
+
+	const totalCost = calculateTotalCost(monthSessions);
+	const totalDuration = calculateTotalDuration(monthSessions);
+
+	// Group by date
+	const sessionsByDate = monthSessions.reduce(
+		(acc, session) => {
+			if (!acc[session.date]) {
+				acc[session.date] = [];
+			}
+			acc[session.date].push(session);
+			return acc;
+		},
+		{} as Record<string, typeof monthSessions>,
+	);
+
+	const monthName = monthStart.toLocaleString("default", { month: "long" });
+
+	console.log(`\n📊 ${monthName}'s Spend\n`);
+	console.log(`Sessions: ${monthSessions.length}`);
+	console.log(`Total Cost: $${formatCost(totalCost)}`);
+	console.log(`Total Duration: ${formatDuration(totalDuration)}`);
+	console.log(`\n📅 By Date:\n`);
+
+	const sortedDates = Object.keys(sessionsByDate).sort();
+
+	for (const date of sortedDates) {
+		const sessions = sessionsByDate[date];
+		const dayCost = calculateTotalCost(sessions);
+		const dayDuration = calculateTotalDuration(sessions);
+
+		console.log(
+			`  ${date}: $${formatCost(dayCost)} (${formatDuration(dayDuration)}) - ${sessions.length} session(s)`,
+		);
+	}
+
+	console.log("");
+}
+
+main();

package/claude-code-config/scripts/statusline/src/commands/spend-today.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+
+import { formatCost, formatDuration } from "../lib/formatters";
+import {
+	calculateTotalCost,
+	calculateTotalDuration,
+	filterSessionsByDate,
+	getTodayStart,
+	loadSpendData,
+} from "../lib/spend";
+
+async function main() {
+	const data = await loadSpendData();
+	const today = getTodayStart();
+	const todaySessions = filterSessionsByDate(data.sessions, today);
+
+	if (todaySessions.length === 0) {
+		console.log("📊 No sessions today");
+		return;
+	}
+
+	const totalCost = calculateTotalCost(todaySessions);
+	const totalDuration = calculateTotalDuration(todaySessions);
+
+	console.log(`\n📊 Today's Spend\n`);
+	console.log(`Sessions: ${todaySessions.length}`);
+	console.log(`Total Cost: $${formatCost(totalCost)}`);
+	console.log(`Total Duration: ${formatDuration(totalDuration)}`);
+	console.log(`\n📝 Sessions:\n`);
+
+	for (const session of todaySessions) {
+		console.log(
+			`  • $${formatCost(session.cost)} (${formatDuration(session.duration_ms)})`,
+		);
+		console.log(`    ${session.cwd}`);
+		console.log(
+			`    +${session.lines_added} -${session.lines_removed} lines\n`,
+		);
+	}
+}
+
+main();

package/claude-code-config/scripts/statusline/src/index.ts

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+
+import type { StatuslineConfig } from "../statusline.config";
+import { defaultConfig } from "../statusline.config";
+import { getContextData } from "./lib/context";
+import {
+	colors,
+	formatBranch,
+	formatCost,
+	formatDuration,
+	formatPath,
+	formatProgressBar,
+	formatResetTime,
+	formatSession,
+} from "./lib/formatters";
+import { getGitStatus } from "./lib/git";
+import { saveSession } from "./lib/spend";
+import type { HookInput } from "./lib/types";
+import { getUsageLimits } from "./lib/usage-limits";
+
+function buildFirstLine(
+	branch: string,
+	dirPath: string,
+	modelName: string,
+	showSonnetModel: boolean,
+	separator: string,
+): string {
+	const isSonnet = modelName.toLowerCase().includes("sonnet");
+	const sep = `${colors.GRAY}${separator}${colors.LIGHT_GRAY}`;
+
+	if (isSonnet && !showSonnetModel) {
+		return `${colors.LIGHT_GRAY}${branch} ${sep} ${dirPath}${colors.RESET}`;
+	}
+
+	return `${colors.LIGHT_GRAY}${branch} ${sep} ${dirPath} ${sep} ${modelName}${colors.RESET}`;
+}
+
+function buildSecondLine(
+	sessionCost: string,
+	_sessionDuration: string,
+	tokensUsed: number,
+	tokensMax: number,
+	contextPercentage: number,
+	fiveHourUtilization: number | null,
+	fiveHourReset: string | null,
+	sessionConfig: StatuslineConfig["session"],
+	limitsConfig: StatuslineConfig["limits"],
+	separator: string,
+): string {
+	let line = formatSession(
+		sessionCost,
+		tokensUsed,
+		tokensMax,
+		contextPercentage,
+		sessionConfig,
+	);
+
+	if (fiveHourUtilization !== null && fiveHourReset) {
+		const resetTime = formatResetTime(fiveHourReset);
+		const sep = `${colors.GRAY}${separator}`;
+
+		if (limitsConfig.showProgressBar) {
+			const bar = formatProgressBar(
+				fiveHourUtilization,
+				limitsConfig.progressBarLength,
+				limitsConfig.color,
+			);
+			line += ` ${sep} L: ${bar} ${colors.LIGHT_GRAY}${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} left)`;
+		} else {
+			line += ` ${sep} L:${colors.LIGHT_GRAY} ${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} left)`;
+		}
+	}
+
+	line += colors.RESET;
+
+	return line;
+}
+
+async function main() {
+	try {
+		const input: HookInput = await Bun.stdin.json();
+
+		await saveSession(input);
+
+		const git = await getGitStatus();
+		const branch = formatBranch(git, defaultConfig.git);
+		const dirPath = formatPath(
+			input.workspace.current_dir,
+			defaultConfig.pathDisplayMode,
+		);
+
+		const contextData = await getContextData({
+			transcriptPath: input.transcript_path,
+			maxContextTokens: defaultConfig.context.maxContextTokens,
+			autocompactBufferTokens: defaultConfig.context.autocompactBufferTokens,
+			useUsableContextOnly: defaultConfig.context.useUsableContextOnly,
+			overheadTokens: defaultConfig.context.overheadTokens,
+		});
+		const usageLimits = await getUsageLimits();
+
+		const sessionCost = formatCost(input.cost.total_cost_usd);
+		const sessionDuration = formatDuration(input.cost.total_duration_ms);
+
+		const firstLine = buildFirstLine(
+			branch,
+			dirPath,
+			input.model.display_name,
+			defaultConfig.showSonnetModel,
+			defaultConfig.separator,
+		);
+		const secondLine = buildSecondLine(
+			sessionCost,
+			sessionDuration,
+			contextData.tokens,
+			defaultConfig.context.maxContextTokens,
+			contextData.percentage,
+			usageLimits.five_hour?.utilization ?? null,
+			usageLimits.five_hour?.resets_at ?? null,
+			defaultConfig.session,
+			defaultConfig.limits,
+			defaultConfig.separator,
+		);
+
+		if (defaultConfig.oneLine) {
+			const sep = ` ${colors.GRAY}${defaultConfig.separator}${colors.LIGHT_GRAY} `;
+			console.log(`${firstLine}${sep}${secondLine}`);
+			console.log(""); // Empty second line for spacing
+		} else {
+			console.log(firstLine);
+			console.log(secondLine);
+		}
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.log(
+			`${colors.RED}Error:${colors.LIGHT_GRAY} ${errorMessage}${colors.RESET}`,
+		);
+		console.log(`${colors.GRAY}Check statusline configuration${colors.RESET}`);
+	}
+}
+
+main();

package/claude-code-config/scripts/statusline/src/lib/context.ts

@@ -0,0 +1,103 @@
+import { existsSync } from "node:fs";
+
+export interface TokenUsage {
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
+}
+
+export interface TranscriptLine {
+  message?: { usage?: TokenUsage };
+  timestamp?: string;
+  isSidechain?: boolean;
+  isApiErrorMessage?: boolean;
+}
+
+export interface ContextResult {
+  tokens: number;
+  percentage: number;
+}
+
+export async function getContextLength(
+  transcriptPath: string,
+): Promise<number> {
+  try {
+    const content = await Bun.file(transcriptPath).text();
+    const lines = content.trim().split("\n");
+
+    if (lines.length === 0) return 0;
+
+    let mostRecentMainChainEntry: TranscriptLine | null = null;
+    let mostRecentTimestamp: Date | null = null;
+
+    for (const line of lines) {
+      try {
+        const data = JSON.parse(line) as TranscriptLine;
+
+        if (!data.message?.usage) continue;
+        if (data.isSidechain === true) continue;
+        if (data.isApiErrorMessage === true) continue;
+        if (!data.timestamp) continue;
+
+        const entryTime = new Date(data.timestamp);
+
+        if (!mostRecentTimestamp || entryTime > mostRecentTimestamp) {
+          mostRecentTimestamp = entryTime;
+          mostRecentMainChainEntry = data;
+        }
+      } catch {}
+    }
+
+    if (!mostRecentMainChainEntry?.message?.usage) {
+      return 0;
+    }
+
+    const usage = mostRecentMainChainEntry.message.usage;
+
+    return (
+      (usage.input_tokens || 0) +
+      (usage.cache_read_input_tokens ?? 0) +
+      (usage.cache_creation_input_tokens ?? 0)
+    );
+  } catch {
+    return 0;
+  }
+}
+
+export interface ContextDataParams {
+  transcriptPath: string;
+  maxContextTokens: number;
+  autocompactBufferTokens: number;
+  useUsableContextOnly?: boolean;
+  overheadTokens?: number;
+}
+
+export async function getContextData({
+  transcriptPath,
+  maxContextTokens,
+  autocompactBufferTokens,
+  useUsableContextOnly = false,
+  overheadTokens = 0,
+}: ContextDataParams): Promise<ContextResult> {
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return { tokens: 0, percentage: 0 };
+  }
+
+  const contextLength = await getContextLength(transcriptPath);
+  let totalTokens = contextLength + overheadTokens;
+
+  // If useUsableContextOnly is true, add the autocompact buffer to displayed tokens
+  if (useUsableContextOnly) {
+    totalTokens += autocompactBufferTokens;
+  }
+
+  // Always calculate percentage based on max context window
+  // (matching /context display behavior)
+  const percentage = Math.min(100, (totalTokens / maxContextTokens) * 100);
+
+  return {
+    tokens: totalTokens,
+    percentage: Math.round(percentage),
+  };
+}