@bastra-recall/statusline 0.9.2 → 1.0.1

package/src/utils/budget.ts

@@ -18,7 +18,7 @@ export function calculateBudgetPercentage(
   budget: number | undefined,
 ): number | null {
   if (!budget || budget <= 0 || cost < 0) return null;
-  return Math.min(100, (cost / budget) * 100);
+  return (cost / budget) * 100;
 }
 
 export function getBudgetStatus(

package/src/utils/claude.ts

@@ -71,6 +71,21 @@ export interface ClaudeHookData {
   };
 }
 
+// A rate-limit window whose percentage is not a finite number carries no
+// usage data; drop it so no renderer reads null as 0%.
+export function dropUnreadableRateLimits(
+  hookData: ClaudeHookData,
+): ClaudeHookData {
+  const limits = hookData.rate_limits;
+  if (!limits) return hookData;
+  const readable = (w?: { used_percentage: number }) =>
+    typeof w?.used_percentage === "number" && Number.isFinite(w.used_percentage);
+  const rate_limits = { ...limits };
+  if (!readable(limits.five_hour)) delete rate_limits.five_hour;
+  if (!readable(limits.seven_day)) delete rate_limits.seven_day;
+  return { ...hookData, rate_limits };
+}
+
 export function getEffortLevel(hookData: ClaudeHookData): string | null {
   const level = hookData.effort?.level;
   if (typeof level !== "string") return null;
@@ -140,6 +155,24 @@ export async function findProjectPaths(
   return projectPaths;
 }
 
+// Whether the usage source itself can be read. Only then does "no entries"
+// mean nothing was spent; a missing or unreadable projects directory means
+// the usage is unknown.
+export async function canReadProjects(): Promise<boolean> {
+  let readable = false;
+
+  for (const claudePath of getClaudePaths()) {
+    try {
+      await readdir(join(claudePath, "projects"));
+      readable = true;
+    } catch (error) {
+      if ((error as { code?: string }).code !== "ENOENT") return false;
+    }
+  }
+
+  return readable;
+}
+
 export async function findTranscriptFile(
   sessionId: string,
 ): Promise<string | null> {
@@ -296,28 +329,34 @@ const STREAMING_THRESHOLD_BYTES = 1024 * 1024;
 
 export async function parseJsonlFile(filePath: string): Promise<ParsedEntry[]> {
   try {
-    const stats = await stat(filePath);
-    const fileSizeBytes = stats.size;
-    let entries: ParsedEntry[];
-
-    if (fileSizeBytes > STREAMING_THRESHOLD_BYTES) {
-      debug(
-        `Using streaming parser for large file ${filePath} (${Math.round(fileSizeBytes / 1024)}KB)`,
-      );
-      entries = await parseJsonlFileStreaming(filePath);
-    } else {
-      entries = await parseJsonlFileInMemory(filePath);
-    }
-
-    debug(`Parsed ${entries.length} entries from ${filePath}`);
-
-    return entries;
+    return await readJsonlFile(filePath);
   } catch (error) {
     debug(`Failed to read file ${filePath}:`, error);
     return [];
   }
 }
 
+// parseJsonlFile for callers that must tell an unreadable file from an empty
+// one: a read error throws instead of yielding no entries.
+export async function readJsonlFile(filePath: string): Promise<ParsedEntry[]> {
+  const stats = await stat(filePath);
+  const fileSizeBytes = stats.size;
+  let entries: ParsedEntry[];
+
+  if (fileSizeBytes > STREAMING_THRESHOLD_BYTES) {
+    debug(
+      `Using streaming parser for large file ${filePath} (${Math.round(fileSizeBytes / 1024)}KB)`,
+    );
+    entries = await parseJsonlFileStreaming(filePath);
+  } else {
+    entries = await parseJsonlFileInMemory(filePath);
+  }
+
+  debug(`Parsed ${entries.length} entries from ${filePath}`);
+
+  return entries;
+}
+
 async function parseJsonlFileInMemory(
   filePath: string,
 ): Promise<ParsedEntry[]> {

package/src/utils/formatters.ts

@@ -6,13 +6,14 @@ interface TokenBreakdown {
 }
 
 export function formatCost(cost: number | null): string {
-  if (cost === null) return "$0.00";
+  if (cost === null) return "--";
+  if (cost === 0) return "$0.00";
   if (cost < 0.01) return "<$0.01";
   return `$${cost.toFixed(2)}`;
 }
 
 export function formatTokens(tokens: number | null): string {
-  if (tokens === null) return "0 tokens";
+  if (tokens === null) return "--";
   if (tokens === 0) return "0 tokens";
   if (tokens >= 1_000_000) {
     return `${(tokens / 1_000_000).toFixed(1)}M tokens`;
@@ -23,7 +24,7 @@ export function formatTokens(tokens: number | null): string {
 }
 
 export function formatTokenBreakdown(breakdown: TokenBreakdown | null): string {
-  if (!breakdown) return "0 tokens";
+  if (!breakdown) return "--";
 
   const parts: string[] = [];
 
@@ -130,8 +131,14 @@ export function collapseHome(dirPath: string, homeDir?: string): string {
     homeDir ??
     globalThis.process?.env?.HOME ??
     globalThis.process?.env?.USERPROFILE;
-  if (home && dirPath.startsWith(home)) {
-    return dirPath.replace(home, "~");
+  if (
+    home &&
+    dirPath.startsWith(home) &&
+    (dirPath.length === home.length ||
+      dirPath[home.length] === "/" ||
+      dirPath[home.length] === "\\")
+  ) {
+    return `~${dirPath.slice(home.length)}`;
   }
   return dirPath;
 }

package/src/utils/terminal.ts

@@ -1,6 +1,7 @@
 export const ESC = String.fromCharCode(27);
 const ANSI_REGEX = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
 export const ANSI_SPLIT = new RegExp(`(${ESC}\\[[0-9;]*m)`);
+const COMBINING_MARK = /[\p{Mn}\p{Me}]/u;
 
 export function stripAnsi(str: string): string {
   return str.replace(ANSI_REGEX, "");
@@ -14,12 +15,11 @@ export function stripAnsi(str: string): string {
  */
 export function codePointWidth(cp: number): number {
   if (
-    (cp >= 0x0300 && cp <= 0x036f) || // combining diacritics
-    (cp >= 0x1ab0 && cp <= 0x1aff) ||
-    (cp >= 0x1dc0 && cp <= 0x1dff) ||
-    (cp >= 0x20d0 && cp <= 0x20ff) || // combining for symbols
     (cp >= 0xfe00 && cp <= 0xfe0f) || // variation selectors
-    cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0xfeff
+    cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0xfeff ||
+    // Unicode mark categories avoid a fixed list of scripts. Mc spacing
+    // marks still occupy a column; Mn/Me marks do not.
+    (cp >= 0x0300 && cp <= 0x10ffff && COMBINING_MARK.test(String.fromCodePoint(cp)))
   ) {
     return 0;
   }