ccstatusline-usage 2.1.11 → 2.1.12

package/README.md

@@ -38,7 +38,7 @@ This fork adds API-based usage widgets beyond the upstream:
 ### Enhanced Status Line Preview
 
 ```
-Session: [████░░░░░░░░░░░] 27.0% | Weekly: [████████████░░░] 86.0% | 1:56 hr | Model: Opus 4.6 ▌▌▌ | Session ID: 0109b99d...
+Session: [████░░░░░░░░░░░] 27.0% | Weekly: [███████████████] 100.0% | Extra: €2.50/€50.00 | Model: Opus 4.6 | Session ID: 0109b99d...
   Context: [███████░░░░░░░░] 103k/200k (51%)
 ```
 
@@ -64,6 +64,10 @@ Session: [████░░░░░░░░░░░] 27.0% | Weekly: [██
 
 ## 🆕 Recent Updates
 
+### [v2.1.12](https://github.com/pcvelz/ccstatusline-usage/releases/tag/v2.1.12) - Remove thinking effort bars from model widget
+
+- [pcvelz/ccstatusline-usage](https://github.com/pcvelz/ccstatusline-usage): **Remove thinking effort bars** — Claude Code now shows thinking intensity natively in its own UI, so the `▌▌▌` bars after the model name have been removed from the Model widget
+
 ### [v2.1.11](https://github.com/pcvelz/ccstatusline-usage/releases/tag/v2.1.11) - Configurable extra usage balance
 
 - [pcvelz/ccstatusline-usage](https://github.com/pcvelz/ccstatusline-usage): **Configurable extra usage balance** — Add `extraUsageBalance` setting (in cents) to `~/.config/ccstatusline/settings.json` to override the API's monthly limit with your actual prepaid balance (e.g., `"extraUsageBalance": 5000` shows `Extra: €0.00/€50.00`)

package/dist/ccstatusline.js

@@ -32401,8 +32401,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path7, { windows } = {}) => {
-    const segs = path7.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path6, { windows } = {}) => {
+    const segs = path6.split(windows ? /[\\/]/ : "/");
     const last2 = segs[segs.length - 1];
     if (last2 === "") {
       return segs[segs.length - 2];
@@ -33924,6 +33924,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if (env.TERM === "xterm-ghostty") {
     return 3;
   }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
   if ("TERM_PROGRAM" in env) {
     const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
@@ -51470,7 +51473,7 @@ import { execSync as execSync3 } from "child_process";
 import * as fs5 from "fs";
 import * as path4 from "path";
 var __dirname = "/Users/peter/Documents/Code/ccstatusline-usage/src/utils";
-var PACKAGE_VERSION = "2.1.11";
+var PACKAGE_VERSION = "2.1.12";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -52320,9 +52323,6 @@ var shouldInsertInput = (input, key) => {
 };
 
 // src/widgets/Model.ts
-import * as fs6 from "fs";
-import { homedir as homedir4 } from "os";
-import * as path5 from "path";
 var MOBILE_THRESHOLD = 80;
 function compactModelName(name) {
   const stripped = name.replace(/^claude-/, "");
@@ -52333,44 +52333,6 @@ function compactModelName(name) {
   }
   return stripped;
 }
-function getEffortLevel() {
-  const envLevel = process.env.CLAUDE_CODE_EFFORT_LEVEL;
-  if (envLevel)
-    return envLevel.toLowerCase();
-  try {
-    const configDir = process.env.CLAUDE_CONFIG_DIR ?? path5.join(homedir4(), ".claude");
-    const settingsPath = path5.join(configDir, "settings.json");
-    const content = fs6.readFileSync(settingsPath, "utf-8");
-    const settings = JSON.parse(content);
-    if (settings.effortLevel)
-      return settings.effortLevel.toLowerCase();
-  } catch {}
-  return "high";
-}
-function effortToLevel(effort) {
-  switch (effort) {
-    case "low":
-      return 1;
-    case "medium":
-      return 2;
-    default:
-      return 3;
-  }
-}
-function renderThinkingBars(level, settings) {
-  if (level <= 0)
-    return "";
-  const colorLevel = getColorLevelString(settings.colorLevel);
-  const activeChalk = getChalkColor("red", colorLevel);
-  const dimChalk = getChalkColor("brightBlack", colorLevel);
-  const bars = ["▌", "▌", "▌"];
-  return " " + bars.map((bar, i) => {
-    if (i < level) {
-      return activeChalk ? activeChalk(bar) : bar;
-    }
-    return dimChalk ? dimChalk(bar) : bar;
-  }).join("");
-}
 
 class ModelWidget {
   getDefaultColor() {
@@ -52390,21 +52352,18 @@ class ModelWidget {
   }
   render(item, context, settings) {
     if (context.isPreview) {
-      const bars2 = renderThinkingBars(3, settings);
-      return item.rawValue ? `Claude${bars2}` : `Model: Claude${bars2}`;
+      return item.rawValue ? "Claude" : "Model: Claude";
     }
     const model = context.data?.model;
     const modelId = typeof model === "string" ? model : model?.id;
     const modelDisplayName = typeof model === "string" ? model : model?.display_name ?? model?.id;
     if (!modelDisplayName)
       return null;
-    const level = effortToLevel(getEffortLevel());
-    const bars = renderThinkingBars(level, settings);
     const mobile = (context.terminalWidth ?? 0) > 0 && (context.terminalWidth ?? 0) < MOBILE_THRESHOLD;
     if (mobile && modelId) {
-      return `M: ${compactModelName(modelId)}${bars}`;
+      return `M: ${compactModelName(modelId)}`;
     }
-    return item.rawValue ? `${modelDisplayName}${bars}` : `Model: ${modelDisplayName}${bars}`;
+    return item.rawValue ? modelDisplayName : `Model: ${modelDisplayName}`;
   }
   supportsRawValue() {
     return true;
@@ -54564,27 +54523,27 @@ class CurrentWorkingDirWidget {
   supportsColors(item) {
     return true;
   }
-  abbreviateHomeDir(path6) {
+  abbreviateHomeDir(path5) {
     const homeDir = os5.homedir();
-    if (path6 === homeDir) {
+    if (path5 === homeDir) {
       return "~";
     }
-    if (path6.startsWith(homeDir)) {
-      const boundaryChar = path6[homeDir.length];
+    if (path5.startsWith(homeDir)) {
+      const boundaryChar = path5[homeDir.length];
       if (boundaryChar !== "/" && boundaryChar !== "\\") {
-        return path6;
+        return path5;
       }
-      return "~" + path6.slice(homeDir.length);
+      return "~" + path5.slice(homeDir.length);
     }
-    return path6;
+    return path5;
   }
-  abbreviatePath(path6) {
+  abbreviatePath(path5) {
     const homeDir = os5.homedir();
-    const useBackslash = path6.includes("\\") && !path6.includes("/");
+    const useBackslash = path5.includes("\\") && !path5.includes("/");
     const sep = useBackslash ? "\\" : "/";
-    let normalizedPath = path6;
-    if (path6.startsWith(homeDir)) {
-      normalizedPath = "~" + path6.slice(homeDir.length);
+    let normalizedPath = path5;
+    if (path5.startsWith(homeDir)) {
+      normalizedPath = "~" + path5.slice(homeDir.length);
     }
     const parts = normalizedPath.split(/[\\/]+/).filter((part) => part !== "");
     const abbreviated = parts.map((part, index) => {
@@ -54708,11 +54667,11 @@ import {
   execSync as execSync6,
   spawnSync
 } from "child_process";
-import * as fs7 from "fs";
+import * as fs6 from "fs";
 import * as os6 from "os";
-import * as path6 from "path";
-var CACHE_FILE = path6.join(os6.homedir(), ".cache", "ccstatusline-api.json");
-var LOCK_FILE = path6.join(os6.homedir(), ".cache", "ccstatusline-api.lock");
+import * as path5 from "path";
+var CACHE_FILE = path5.join(os6.homedir(), ".cache", "ccstatusline-api.json");
+var LOCK_FILE = path5.join(os6.homedir(), ".cache", "ccstatusline-api.lock");
 var CACHE_MAX_AGE = 180;
 var LOCK_MAX_AGE = 30;
 var TOKEN_CACHE_MAX_AGE = 3600;
@@ -54720,10 +54679,10 @@ var cachedData = null;
 var cacheTime = 0;
 var cachedToken = null;
 var tokenCacheTime = 0;
-var CRED_FILE = path6.join(os6.homedir(), ".claude", ".credentials.json");
+var CRED_FILE = path5.join(os6.homedir(), ".claude", ".credentials.json");
 function readTokenFromFile() {
   try {
-    const creds = JSON.parse(fs7.readFileSync(CRED_FILE, "utf8"));
+    const creds = JSON.parse(fs6.readFileSync(CRED_FILE, "utf8"));
     return creds?.claudeAiOauth?.accessToken ?? null;
   } catch {
     return null;
@@ -54760,7 +54719,7 @@ function getToken() {
 }
 function readStaleCache() {
   try {
-    return JSON.parse(fs7.readFileSync(CACHE_FILE, "utf8"));
+    return JSON.parse(fs6.readFileSync(CACHE_FILE, "utf8"));
   } catch {
     return null;
   }
@@ -54818,10 +54777,10 @@ function fetchApiData() {
     return cachedData;
   }
   try {
-    const stat = fs7.statSync(CACHE_FILE);
+    const stat = fs6.statSync(CACHE_FILE);
     const fileAge = now2 - Math.floor(stat.mtimeMs / 1000);
     if (fileAge < CACHE_MAX_AGE) {
-      const fileData = JSON.parse(fs7.readFileSync(CACHE_FILE, "utf8"));
+      const fileData = JSON.parse(fs6.readFileSync(CACHE_FILE, "utf8"));
       if (!fileData.error) {
         cachedData = fileData;
         cacheTime = now2;
@@ -54830,7 +54789,7 @@ function fetchApiData() {
     }
   } catch {}
   try {
-    const lockStat = fs7.statSync(LOCK_FILE);
+    const lockStat = fs6.statSync(LOCK_FILE);
     const lockAge = now2 - Math.floor(lockStat.mtimeMs / 1000);
     if (lockAge < LOCK_MAX_AGE) {
       const stale = readStaleCache();
@@ -54840,11 +54799,11 @@ function fetchApiData() {
     }
   } catch {}
   try {
-    const lockDir = path6.dirname(LOCK_FILE);
-    if (!fs7.existsSync(lockDir)) {
-      fs7.mkdirSync(lockDir, { recursive: true });
+    const lockDir = path5.dirname(LOCK_FILE);
+    if (!fs6.existsSync(lockDir)) {
+      fs6.mkdirSync(lockDir, { recursive: true });
     }
-    fs7.writeFileSync(LOCK_FILE, "");
+    fs6.writeFileSync(LOCK_FILE, "");
   } catch {}
   const token = getToken();
   if (!token) {
@@ -54890,11 +54849,11 @@ function fetchApiData() {
       return { error: "parse-error" };
     }
     try {
-      const cacheDir = path6.dirname(CACHE_FILE);
-      if (!fs7.existsSync(cacheDir)) {
-        fs7.mkdirSync(cacheDir, { recursive: true });
+      const cacheDir = path5.dirname(CACHE_FILE);
+      if (!fs6.existsSync(cacheDir)) {
+        fs6.mkdirSync(cacheDir, { recursive: true });
       }
-      fs7.writeFileSync(CACHE_FILE, JSON.stringify(apiData));
+      fs6.writeFileSync(CACHE_FILE, JSON.stringify(apiData));
     } catch {}
     cachedData = apiData;
     cacheTime = now2;
@@ -55114,7 +55073,7 @@ class ContextBarWidget {
   }
 }
 // src/widgets/SessionName.ts
-import * as fs8 from "fs";
+import * as fs7 from "fs";
 
 class SessionNameWidget {
   getDefaultColor() {
@@ -55141,7 +55100,7 @@ class SessionNameWidget {
       return null;
     }
     try {
-      const content = fs8.readFileSync(transcriptPath, "utf-8");
+      const content = fs7.readFileSync(transcriptPath, "utf-8");
       const lines = content.split(`
 `);
       for (let i = lines.length - 1;i >= 0; i--) {
@@ -55250,7 +55209,7 @@ class FreeMemoryWidget {
 }
 // src/widgets/Battery.ts
 import { execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 function getMacBatteryInfo() {
   try {
     const output = execSync8("pmset -g batt", { encoding: "utf-8", timeout: 2000 });
@@ -55270,8 +55229,8 @@ function getMacBatteryInfo() {
 }
 function getLinuxBatteryInfo() {
   try {
-    const capacity = readFileSync6("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
-    const status = readFileSync6("/sys/class/power_supply/BAT0/status", "utf-8").trim().toLowerCase();
+    const capacity = readFileSync5("/sys/class/power_supply/BAT0/capacity", "utf-8").trim();
+    const status = readFileSync5("/sys/class/power_supply/BAT0/status", "utf-8").trim().toLowerCase();
     const percent = parseInt(capacity, 10);
     if (isNaN(percent)) {
       return null;
@@ -59720,44 +59679,44 @@ function renderCompactOutput(preRenderedLines, settings, maxWidth) {
 }
 
 // src/utils/jsonl.ts
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import { createHash } from "node:crypto";
 import os9 from "node:os";
-import path8 from "node:path";
+import path7 from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
-import path7, { posix } from "path";
+import path6, { posix } from "path";
 
 // node_modules/fdir/dist/index.mjs
 import { createRequire as createRequire2 } from "module";
 import { basename as basename2, dirname as dirname3, normalize, relative, resolve as resolve2, sep } from "path";
 import * as nativeFs from "fs";
 var __require2 = /* @__PURE__ */ createRequire2(import.meta.url);
-function cleanPath(path7) {
-  let normalized = normalize(path7);
+function cleanPath(path6) {
+  let normalized = normalize(path6);
   if (normalized.length > 1 && normalized[normalized.length - 1] === sep)
     normalized = normalized.substring(0, normalized.length - 1);
   return normalized;
 }
 var SLASHES_REGEX = /[\\/]/g;
-function convertSlashes(path7, separator) {
-  return path7.replace(SLASHES_REGEX, separator);
+function convertSlashes(path6, separator) {
+  return path6.replace(SLASHES_REGEX, separator);
 }
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path7) {
-  return path7 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path7);
+function isRootDirectory(path6) {
+  return path6 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path6);
 }
-function normalizePath(path7, options) {
+function normalizePath(path6, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path7.includes("/") || path7.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path6.includes("/") || path6.startsWith(".");
   if (resolvePaths)
-    path7 = resolve2(path7);
+    path6 = resolve2(path6);
   if (normalizePath$1 || pathNeedsCleaning)
-    path7 = cleanPath(path7);
-  if (path7 === ".")
+    path6 = cleanPath(path6);
+  if (path6 === ".")
     return "";
-  const needsSeperator = path7[path7.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path7 + pathSeparator : path7, pathSeparator);
+  const needsSeperator = path6[path6.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path6 + pathSeparator : path6, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -59797,9 +59756,9 @@ var pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 };
 var pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path7 = directoryPath || ".";
-  if (filters.every((filter2) => filter2(path7, true)))
-    paths.push(path7);
+  const path6 = directoryPath || ".";
+  if (filters.every((filter2) => filter2(path6, true)))
+    paths.push(path6);
 };
 var empty$2 = () => {};
 function build$6(root, options) {
@@ -59856,29 +59815,29 @@ var empty = () => {};
 function build$3(options) {
   return options.group ? groupFiles : empty;
 }
-var resolveSymlinksAsync = function(path7, state, callback$1) {
-  const { queue, fs: fs9, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = function(path6, state, callback$1) {
+  const { queue, fs: fs8, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs9.realpath(path7, (error43, resolvedPath) => {
+  fs8.realpath(path6, (error43, resolvedPath) => {
     if (error43)
       return queue.dequeue(suppressErrors ? null : error43, state);
-    fs9.stat(resolvedPath, (error$1, stat) => {
+    fs8.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
+      if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
         return queue.dequeue(null, state);
       callback$1(stat, resolvedPath);
       queue.dequeue(null, state);
     });
   });
 };
-var resolveSymlinks = function(path7, state, callback$1) {
-  const { queue, fs: fs9, options: { suppressErrors } } = state;
+var resolveSymlinks = function(path6, state, callback$1) {
+  const { queue, fs: fs8, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs9.realpathSync(path7);
-    const stat = fs9.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path7, resolvedPath, state))
+    const resolvedPath = fs8.realpathSync(path6);
+    const stat = fs8.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -59891,10 +59850,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path7, resolved, state) {
+function isRecursive(path6, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname3(path7);
+  let parent = dirname3(path6);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -59904,7 +59863,7 @@ function isRecursive(path7, resolved, state) {
     else
       parent = dirname3(parent);
   }
-  state.symlinks.set(path7, resolved);
+  state.symlinks.set(path6, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -59960,23 +59919,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs9 } = state;
+  const { fs: fs8 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs9.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+  fs8.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
     callback$1(entries, directoryPath, currentDepth);
     state.queue.dequeue(state.options.suppressErrors ? null : error43, state);
   });
 };
 var walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
-  const { fs: fs9 } = state;
+  const { fs: fs8 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs9.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs8.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -60082,21 +60041,21 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path7 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path7))
+        let path6 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path6))
           continue;
-        this.pushDirectory(path7, paths, filters);
-        this.walkDirectory(this.state, path7, path7, depth - 1, this.walk);
+        this.pushDirectory(path6, paths, filters);
+        this.walkDirectory(this.state, path6, path6, depth - 1, this.walk);
       } else if (this.resolveSymlink && entry.isSymbolicLink()) {
-        let path7 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path7, this.state, (stat, resolvedPath) => {
+        let path6 = joinPathWithBasePath(entry.name, directoryPath);
+        this.resolveSymlink(path6, this.state, (stat, resolvedPath) => {
           if (stat.isDirectory()) {
             resolvedPath = normalizePath(resolvedPath, this.state.options);
-            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path7 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path6 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path7 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path6 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path7;
+            resolvedPath = useRealPaths ? resolvedPath : path6;
             const filename = basename2(resolvedPath);
             const directoryPath$1 = normalizePath(dirname3(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
@@ -60256,7 +60215,7 @@ var Builder = class {
       isMatch2 = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch2;
     }
-    this.options.filters.push((path7) => isMatch2(path7));
+    this.options.filters.push((path6) => isMatch2(path6));
     return this;
   }
 };
@@ -60335,7 +60294,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
   if (!result2.endsWith("*") && expandDirectories)
     result2 += "/**";
   const escapedCwd = escapePath(cwd2);
-  if (path7.isAbsolute(result2.replace(ESCAPING_BACKSLASHES, "")))
+  if (path6.isAbsolute(result2.replace(ESCAPING_BACKSLASHES, "")))
     result2 = posix.relative(escapedCwd, result2);
   else
     result2 = posix.normalize(result2);
@@ -60372,7 +60331,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path7.posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = newCommonPath.length > 0 ? path6.posix.join(cwd2, ...newCommonPath) : cwd2;
   }
   return result2;
 }
@@ -60505,25 +60464,25 @@ function globSync(patternsOrOptions, options) {
     ...options,
     patterns: patternsOrOptions
   } : patternsOrOptions;
-  const cwd2 = opts.cwd ? path7.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+  const cwd2 = opts.cwd ? path6.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
   return crawl(opts, cwd2, true);
 }
 
 // src/utils/jsonl.ts
 import { promisify } from "util";
-var readFile4 = promisify(fs9.readFile);
-var readFileSync8 = fs9.readFileSync;
-var statSync5 = fs9.statSync;
-var writeFileSync3 = fs9.writeFileSync;
-var mkdirSync4 = fs9.mkdirSync;
-var existsSync8 = fs9.existsSync;
+var readFile4 = promisify(fs8.readFile);
+var readFileSync7 = fs8.readFileSync;
+var statSync5 = fs8.statSync;
+var writeFileSync3 = fs8.writeFileSync;
+var mkdirSync4 = fs8.mkdirSync;
+var existsSync8 = fs8.existsSync;
 function normalizeConfigDir(configDir) {
-  return path8.resolve(configDir);
+  return path7.resolve(configDir);
 }
 function getBlockCachePath(configDir = getClaudeConfigDir()) {
   const normalizedConfigDir = normalizeConfigDir(configDir);
   const configHash = createHash("sha256").update(normalizedConfigDir).digest("hex").slice(0, 16);
-  return path8.join(os9.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
+  return path7.join(os9.homedir(), ".cache", "ccstatusline", `block-cache-${configHash}.json`);
 }
 function readBlockCache(expectedConfigDir) {
   try {
@@ -60532,7 +60491,7 @@ function readBlockCache(expectedConfigDir) {
     if (!existsSync8(cachePath)) {
       return null;
     }
-    const content = readFileSync8(cachePath, "utf-8");
+    const content = readFileSync7(cachePath, "utf-8");
     const cache3 = JSON.parse(content);
     if (typeof cache3.startTime !== "string") {
       return null;
@@ -60558,7 +60517,7 @@ function writeBlockCache(startTime, configDir = getClaudeConfigDir()) {
   try {
     const normalizedConfigDir = normalizeConfigDir(configDir);
     const cachePath = getBlockCachePath(normalizedConfigDir);
-    const cacheDir = path8.dirname(cachePath);
+    const cacheDir = path7.dirname(cachePath);
     if (!existsSync8(cacheDir)) {
       mkdirSync4(cacheDir, { recursive: true });
     }
@@ -60591,7 +60550,7 @@ function getCachedBlockMetrics(sessionDurationHours = 5) {
 }
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs9.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return null;
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -60643,7 +60602,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs9.existsSync(transcriptPath)) {
+    if (!fs8.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -60696,7 +60655,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now2 = new Date;
-  const pattern = path8.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
+  const pattern = path7.posix.join(rootDir.replace(/\\/g, "/"), "projects", "**", "*.jsonl");
   const files = globSync([pattern], {
     absolute: true,
     cwd: rootDir
@@ -60790,7 +60749,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
 function getAllTimestampsFromFile(filePath) {
   const timestamps = [];
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync7(filePath, "utf-8");
     const lines = content.trim().split(`
 `).filter((line) => line.length > 0);
     for (const line of lines) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccstatusline-usage",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "description": "A customizable status line formatter for Claude Code CLI",
   "module": "src/ccstatusline.ts",
   "type": "module",