@jeremyy_prt/cc-config 1.0.0

package/scripts/statusline/src/index.ts

@@ -0,0 +1,199 @@
+#!/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,
+	numberOfLines: 1 | 2 | 3,
+): string {
+	const isSonnet = modelName.toLowerCase().includes("sonnet");
+	const sep = `${colors.GRAY} ${separator} ${colors.LIGHT_GRAY}`;
+
+	// Mode 3 lignes : chemin + git (pas de model)
+	if (numberOfLines === 3) {
+		if (branch) {
+			return `${colors.LIGHT_GRAY}${dirPath}${sep}${branch}${colors.RESET}`;
+		}
+		return `${colors.LIGHT_GRAY}${dirPath}${colors.RESET}`;
+	}
+
+	// Mode 1 ou 2 lignes : comportement original
+	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,
+	numberOfLines: 1 | 2 | 3,
+): string {
+	let line = formatSession(
+		sessionCost,
+		tokensUsed,
+		tokensMax,
+		contextPercentage,
+		sessionConfig,
+	);
+
+	// Mode 3 lignes : ne pas ajouter les limites sur la ligne 2
+	if (numberOfLines === 3) {
+		line += colors.RESET;
+		return line;
+	}
+
+	// Mode 1 ou 2 lignes : ajouter les limites sur la même ligne
+	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} ${colors.GRAY}Session:${colors.LIGHT_GRAY} ${bar} ${colors.LIGHT_GRAY}${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} restant)`;
+		} else {
+			line += ` ${sep} ${colors.GRAY}Session:${colors.LIGHT_GRAY} ${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} restant)`;
+		}
+	}
+
+	line += colors.RESET;
+
+	return line;
+}
+
+function buildThirdLine(
+	fiveHourUtilization: number | null,
+	fiveHourReset: string | null,
+	limitsConfig: StatuslineConfig["limits"],
+): string {
+	if (fiveHourUtilization === null || !fiveHourReset) {
+		return "";
+	}
+
+	const resetTime = formatResetTime(fiveHourReset);
+	let line = "";
+
+	if (limitsConfig.showProgressBar) {
+		const bar = formatProgressBar(
+			fiveHourUtilization,
+			limitsConfig.progressBarLength,
+			limitsConfig.color,
+		);
+		line = `${colors.GRAY}Session:${colors.LIGHT_GRAY} ${bar} ${colors.LIGHT_GRAY}${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} restant)${colors.RESET}`;
+	} else {
+		line = `${colors.GRAY}Session:${colors.LIGHT_GRAY} ${fiveHourUtilization}${colors.GRAY}% ${colors.GRAY}(${resetTime} restant)${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,
+			defaultConfig.numberOfLines,
+		);
+		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,
+			defaultConfig.numberOfLines,
+		);
+		const thirdLine = buildThirdLine(
+			usageLimits.five_hour?.utilization ?? null,
+			usageLimits.five_hour?.resets_at ?? null,
+			defaultConfig.limits,
+		);
+
+		if (defaultConfig.numberOfLines === 1) {
+			// Mode 1 ligne : tout sur une seule ligne
+			const sep = ` ${colors.GRAY}${defaultConfig.separator}${colors.LIGHT_GRAY} `;
+			console.log(`${firstLine}${sep}${secondLine}`);
+			console.log(""); // Empty second line for spacing
+		} else if (defaultConfig.numberOfLines === 2) {
+			// Mode 2 lignes : chemin+git sur ligne 1, session+limites sur ligne 2
+			console.log(firstLine);
+			console.log(secondLine);
+		} else {
+			// Mode 3 lignes : chemin sur ligne 1, session sur ligne 2, limites sur ligne 3
+			console.log(firstLine);
+			console.log(secondLine);
+			console.log(thirdLine);
+		}
+	} 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/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),
+  };
+}

package/scripts/statusline/src/lib/formatters.ts

@@ -0,0 +1,218 @@
+import type { Separator, StatuslineConfig } from "../../statusline.config";
+import type { GitStatus } from "./git";
+
+export const colors = {
+	GREEN: "\x1b[0;32m",
+	RED: "\x1b[0;31m",
+	PURPLE: "\x1b[0;35m",
+	YELLOW: "\x1b[0;33m",
+	ORANGE: "\x1b[38;5;208m",
+	GRAY: "\x1b[0;90m",
+	LIGHT_GRAY: "\x1b[0;37m",
+	RESET: "\x1b[0m",
+} as const;
+
+export function formatBranch(
+	git: GitStatus,
+	gitConfig: StatuslineConfig["git"],
+): string {
+	let result = "";
+
+	if (gitConfig.showBranch) {
+		result = git.branch;
+	}
+
+	if (git.hasChanges) {
+		const changes: string[] = [];
+
+		if (gitConfig.showDirtyIndicator) {
+			result += `${colors.PURPLE}*${colors.RESET}`;
+		}
+
+		if (gitConfig.showChanges) {
+			const totalAdded = git.staged.added + git.unstaged.added;
+			const totalDeleted = git.staged.deleted + git.unstaged.deleted;
+
+			if (totalAdded > 0) {
+				changes.push(`${colors.GREEN}+${totalAdded}${colors.RESET}`);
+			}
+			if (totalDeleted > 0) {
+				changes.push(`${colors.RED}-${totalDeleted}${colors.RESET}`);
+			}
+		}
+
+		if (gitConfig.showStaged && git.staged.files > 0) {
+			changes.push(`${colors.GRAY}~${git.staged.files}${colors.RESET}`);
+		}
+
+		if (gitConfig.showUnstaged && git.unstaged.files > 0) {
+			changes.push(`${colors.YELLOW}~${git.unstaged.files}${colors.RESET}`);
+		}
+
+		if (changes.length > 0) {
+			result += ` ${changes.join(" ")}`;
+		}
+	}
+
+	return result;
+}
+
+export function formatPath(
+	path: string,
+	mode: "full" | "truncated" | "basename" = "truncated",
+): string {
+	const home = process.env.HOME || "";
+	let formattedPath = path;
+
+	if (home && path.startsWith(home)) {
+		formattedPath = `~${path.slice(home.length)}`;
+	}
+
+	if (mode === "basename") {
+		const segments = path.split("/").filter((s) => s.length > 0);
+		return segments[segments.length - 1] || path;
+	}
+
+	if (mode === "truncated") {
+		const segments = formattedPath.split("/").filter((s) => s.length > 0);
+		if (segments.length > 2) {
+			return `/${segments.slice(-2).join("/")}`;
+		}
+	}
+
+	return formattedPath;
+}
+
+export function formatCost(cost: number): string {
+	return cost.toFixed(2);
+}
+
+export function formatTokens(tokens: number, showDecimals = true): string {
+	if (tokens >= 1000000) {
+		const value = tokens / 1000000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${number}${colors.GRAY}m${colors.LIGHT_GRAY}`;
+	}
+	if (tokens >= 1000) {
+		const value = tokens / 1000;
+		const number = showDecimals
+			? value.toFixed(1)
+			: Math.round(value).toString();
+		return `${number}${colors.GRAY}k${colors.LIGHT_GRAY}`;
+	}
+	return tokens.toString();
+}
+
+export function formatDuration(ms: number): string {
+	const minutes = Math.floor(ms / 60000);
+	const hours = Math.floor(minutes / 60);
+	const mins = minutes % 60;
+
+	if (hours > 0) {
+		return `${hours}h ${mins}m`;
+	}
+	return `${mins}m`;
+}
+
+export function formatResetTime(resetsAt: string): string {
+	try {
+		const resetDate = new Date(resetsAt);
+		const now = new Date();
+		const diffMs = resetDate.getTime() - now.getTime();
+
+		if (diffMs <= 0) {
+			return "now";
+		}
+
+		const hours = Math.floor(diffMs / 3600000);
+		const minutes = Math.floor((diffMs % 3600000) / 60000);
+
+		if (hours > 0) {
+			return `${hours}h${minutes}m`;
+		}
+		return `${minutes}m`;
+	} catch {
+		return "N/A";
+	}
+}
+
+export function formatProgressBar(
+	percentage: number,
+	length: number,
+	colorMode: "progressive" | "green" | "yellow" | "red",
+): string {
+	const filled = Math.round((percentage / 100) * length);
+	const empty = length - filled;
+
+	const filledBar = "█".repeat(filled);
+	const emptyBar = "░".repeat(empty);
+
+	let barColor: string;
+	if (colorMode === "progressive") {
+		if (percentage < 50) {
+			barColor = colors.GRAY;
+		} else if (percentage < 70) {
+			barColor = colors.YELLOW;
+		} else if (percentage < 90) {
+			barColor = colors.ORANGE;
+		} else {
+			barColor = colors.RED;
+		}
+	} else if (colorMode === "green") {
+		barColor = colors.GREEN;
+	} else if (colorMode === "yellow") {
+		barColor = colors.YELLOW;
+	} else {
+		barColor = colors.RED;
+	}
+
+	return `${barColor}${filledBar}${colors.GRAY}${emptyBar}${colors.RESET}`;
+}
+
+export interface SessionConfig {
+	infoSeparator: Separator | null;
+	showCost: boolean;
+	showTokens: boolean;
+	showMaxTokens: boolean;
+	showTokenDecimals: boolean;
+	showPercentage: boolean;
+}
+
+export function formatSession(
+	cost: string,
+	tokensUsed: number,
+	tokensMax: number,
+	percentage: number,
+	config: SessionConfig,
+): string {
+	const sessionItems: string[] = [];
+
+	if (config.showCost) {
+		sessionItems.push(`$${cost}`);
+	}
+	if (config.showTokens) {
+		const formattedUsed = formatTokens(tokensUsed, config.showTokenDecimals);
+		if (config.showMaxTokens) {
+			const formattedMax = formatTokens(tokensMax, config.showTokenDecimals);
+			sessionItems.push(
+				`${formattedUsed}${colors.GRAY}/${formattedMax}${colors.LIGHT_GRAY}`,
+			);
+		} else {
+			sessionItems.push(formattedUsed);
+		}
+	}
+	if (config.showPercentage) {
+		sessionItems.push(`${percentage}${colors.GRAY}%${colors.LIGHT_GRAY}`);
+	}
+
+	if (sessionItems.length === 0) {
+		return "";
+	}
+
+	const infoSep = config.infoSeparator
+		? ` ${colors.GRAY}${config.infoSeparator}${colors.LIGHT_GRAY} `
+		: " ";
+	return `${colors.GRAY}Contexte:${colors.LIGHT_GRAY} ${sessionItems.join(infoSep)}`;
+}

package/scripts/statusline/src/lib/git.ts

@@ -0,0 +1,100 @@
+import { $ } from "bun";
+
+export interface GitStatus {
+	branch: string;
+	hasChanges: boolean;
+	staged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+	unstaged: {
+		added: number;
+		deleted: number;
+		files: number;
+	};
+}
+
+export async function getGitStatus(): Promise<GitStatus> {
+	try {
+		const isGitRepo = await $`git rev-parse --git-dir`.quiet().nothrow();
+		if (isGitRepo.exitCode !== 0) {
+			return {
+				branch: "no-git",
+				hasChanges: false,
+				staged: { added: 0, deleted: 0, files: 0 },
+				unstaged: { added: 0, deleted: 0, files: 0 },
+			};
+		}
+
+		const branchResult = await $`git branch --show-current`.quiet().text();
+		const branch = branchResult.trim() || "detached";
+
+		const diffCheck = await $`git diff-index --quiet HEAD --`.quiet().nothrow();
+		const cachedCheck = await $`git diff-index --quiet --cached HEAD --`
+			.quiet()
+			.nothrow();
+
+		if (diffCheck.exitCode !== 0 || cachedCheck.exitCode !== 0) {
+			const unstagedDiff = await $`git diff --numstat`.quiet().text();
+			const stagedDiff = await $`git diff --cached --numstat`.quiet().text();
+			const stagedFilesResult = await $`git diff --cached --name-only`
+				.quiet()
+				.text();
+			const unstagedFilesResult = await $`git diff --name-only`.quiet().text();
+
+			const parseStats = (diff: string) => {
+				let added = 0;
+				let deleted = 0;
+				for (const line of diff.split("\n")) {
+					if (!line.trim()) continue;
+					const [a, d] = line
+						.split("\t")
+						.map((n) => Number.parseInt(n, 10) || 0);
+					added += a;
+					deleted += d;
+				}
+				return { added, deleted };
+			};
+
+			const unstagedStats = parseStats(unstagedDiff);
+			const stagedStats = parseStats(stagedDiff);
+
+			const stagedFilesCount = stagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+			const unstagedFilesCount = unstagedFilesResult
+				.split("\n")
+				.filter((f) => f.trim()).length;
+
+			return {
+				branch,
+				hasChanges: true,
+				staged: {
+					added: stagedStats.added,
+					deleted: stagedStats.deleted,
+					files: stagedFilesCount,
+				},
+				unstaged: {
+					added: unstagedStats.added,
+					deleted: unstagedStats.deleted,
+					files: unstagedFilesCount,
+				},
+			};
+		}
+
+		return {
+			branch,
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	} catch {
+		return {
+			branch: "no-git",
+			hasChanges: false,
+			staged: { added: 0, deleted: 0, files: 0 },
+			unstaged: { added: 0, deleted: 0, files: 0 },
+		};
+	}
+}