ccstatusline-usage 2.0.28 → 2.0.30

package/defaults/settings-enhanced.json

@@ -0,0 +1,73 @@
+{
+  "version": 3,
+  "lines": [
+    [
+      {
+        "id": "session-usage",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "scripts/usage.sh session"
+      },
+      {
+        "id": "sep-session-weekly",
+        "type": "separator"
+      },
+      {
+        "id": "weekly-usage",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "scripts/usage.sh weekly"
+      },
+      {
+        "id": "sep-weekly-reset",
+        "type": "separator"
+      },
+      {
+        "id": "reset-timer",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "scripts/usage.sh reset"
+      },
+      {
+        "id": "sep-reset-model",
+        "type": "separator"
+      },
+      {
+        "id": "model",
+        "type": "model",
+        "color": "magenta"
+      },
+      {
+        "id": "sep-model-chatid",
+        "type": "separator"
+      },
+      {
+        "id": "chat-id",
+        "type": "claude-session-id",
+        "color": "cyan"
+      }
+    ],
+    [
+      {
+        "id": "context-usage",
+        "type": "custom-command",
+        "color": "blue",
+        "commandPath": "scripts/context.sh"
+      }
+    ],
+    []
+  ],
+  "flexMode": "full-minus-40",
+  "compactThreshold": 60,
+  "colorLevel": 2,
+  "inheritSeparatorColors": false,
+  "globalBold": false,
+  "powerline": {
+    "enabled": false,
+    "separators": [""],
+    "separatorInvertBackground": [false],
+    "startCaps": [],
+    "endCaps": [],
+    "autoAlign": false
+  }
+}

package/dist/ccstatusline.js

@@ -32383,8 +32383,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path5, { windows } = {}) => {
-    const segs = path5.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path6, { windows } = {}) => {
+    const segs = path6.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -50982,18 +50982,18 @@ var SettingsSchema = exports_external.object({
   version: exports_external.number().default(CURRENT_VERSION),
   lines: exports_external.array(exports_external.array(WidgetItemSchema)).min(1).default([
     [
-      { id: "model", type: "model", color: "magenta" },
+      { id: "session-usage", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh session", timeout: 5000, label: "Session Usage" },
       { id: "sep1", type: "separator" },
-      { id: "context", type: "context-percentage", color: "blue" },
+      { id: "weekly-usage", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh weekly", timeout: 5000, label: "Weekly Usage" },
       { id: "sep2", type: "separator" },
-      { id: "session-clock", type: "session-clock", color: "yellow" },
+      { id: "reset-timer", type: "custom-command", color: "brightBlue", commandPath: "$PKG/scripts/usage.sh reset", timeout: 5000, label: "Reset Timer" },
       { id: "sep3", type: "separator" },
+      { id: "model", type: "model", color: "magenta" },
+      { id: "sep4", type: "separator" },
       { id: "session-id", type: "claude-session-id", color: "cyan" }
     ],
     [
-      { id: "git-branch", type: "git-branch", color: "green" },
-      { id: "sep4", type: "separator" },
-      { id: "git-changes", type: "git-changes", color: "yellow" }
+      { id: "context-usage", type: "custom-command", color: "blue", commandPath: "$PKG/scripts/context.sh", timeout: 5000, label: "Context Bar" }
     ],
     []
   ]),
@@ -51450,7 +51450,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.0.28";
+var PACKAGE_VERSION = "2.0.30";
 function getPackageVersion() {
   if (/^\d+\.\d+\.\d+/.test(PACKAGE_VERSION)) {
     return PACKAGE_VERSION;
@@ -53812,8 +53812,56 @@ var CustomTextEditor = ({ widget, onComplete, onCancel }) => {
 };
 // src/widgets/CustomCommand.tsx
 import { execSync as execSync7 } from "child_process";
+import * as fs6 from "fs";
 var import_react30 = __toESM(require_react(), 1);
 var jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+import * as path5 from "path";
+function getPackageDir() {
+  const scriptPath = process.argv[1];
+  if (scriptPath) {
+    try {
+      const realPath = fs6.realpathSync(scriptPath);
+      let dir = path5.dirname(realPath);
+      for (let i = 0;i < 10; i++) {
+        const pkgJson = path5.join(dir, "package.json");
+        if (fs6.existsSync(pkgJson)) {
+          try {
+            const pkg = JSON.parse(fs6.readFileSync(pkgJson, "utf8"));
+            if (pkg.name === "ccstatusline-usage") {
+              return dir;
+            }
+          } catch {}
+        }
+        const scriptsDir = path5.join(dir, "scripts");
+        if (fs6.existsSync(path5.join(scriptsDir, "usage.sh"))) {
+          return dir;
+        }
+        dir = path5.dirname(dir);
+      }
+    } catch {}
+  }
+  const home = process.env.HOME ?? "";
+  const npxPaths = [
+    path5.join(home, ".npm", "_npx"),
+    path5.join(home, ".cache", "npm", "_npx"),
+    path5.join(home, ".local", "share", "npm", "_npx")
+  ];
+  for (const npxBase of npxPaths) {
+    if (fs6.existsSync(npxBase)) {
+      try {
+        const entries = fs6.readdirSync(npxBase);
+        for (const entry of entries) {
+          const pkgDir = path5.join(npxBase, entry, "node_modules", "ccstatusline-usage");
+          if (fs6.existsSync(path5.join(pkgDir, "scripts", "usage.sh"))) {
+            return pkgDir;
+          }
+        }
+      } catch {}
+    }
+  }
+  return "";
+}
+var PKG_DIR = getPackageDir();
 
 class CustomCommandWidget {
   getDefaultColor() {
@@ -53826,9 +53874,11 @@ class CustomCommandWidget {
     return "Custom Command";
   }
   getEditorDisplay(item) {
-    const cmd = item.commandPath ?? "No command";
-    const truncatedCmd = cmd.length > 20 ? `${cmd.substring(0, 17)}...` : cmd;
-    const displayText = `${this.getDisplayName()} (${truncatedCmd})`;
+    const displayText = item.label ? item.label : (() => {
+      const cmd = item.commandPath ?? "No command";
+      const truncatedCmd = cmd.length > 20 ? `${cmd.substring(0, 17)}...` : cmd;
+      return `${this.getDisplayName()} (${truncatedCmd})`;
+    })();
     const modifiers = [];
     if (item.maxWidth) {
       modifiers.push(`max:${item.maxWidth}`);
@@ -53850,6 +53900,17 @@ class CustomCommandWidget {
     }
     return null;
   }
+  resolveCommandPath(commandPath) {
+    if (commandPath.startsWith("$PKG/") || commandPath.startsWith("$PACKAGE_DIR/")) {
+      const relativePath = commandPath.replace(/^\$(PKG|PACKAGE_DIR)\//, "");
+      const resolved = path5.join(PKG_DIR, relativePath);
+      return resolved;
+    }
+    if (commandPath.startsWith("$HOME/")) {
+      return commandPath.replace("$HOME", process.env.HOME ?? "~");
+    }
+    return commandPath;
+  }
   render(item, context, settings) {
     if (context.isPreview) {
       return item.commandPath ? `[cmd: ${item.commandPath.substring(0, 20)}${item.commandPath.length > 20 ? "..." : ""}]` : "[No command]";
@@ -53857,7 +53918,8 @@ class CustomCommandWidget {
       try {
         const timeout = item.timeout ?? 1000;
         const jsonInput = JSON.stringify(context.data);
-        let output = execSync7(item.commandPath, {
+        const resolvedPath = this.resolveCommandPath(item.commandPath);
+        let output = execSync7(resolvedPath, {
           encoding: "utf8",
           input: jsonInput,
           timeout,
@@ -54278,13 +54340,13 @@ class CurrentWorkingDirWidget {
   supportsColors(item) {
     return true;
   }
-  abbreviatePath(path5) {
+  abbreviatePath(path6) {
     const homeDir = os5.homedir();
-    const useBackslash = path5.includes("\\") && !path5.includes("/");
+    const useBackslash = path6.includes("\\") && !path6.includes("/");
     const sep = useBackslash ? "\\" : "/";
-    let normalizedPath = path5;
-    if (path5.startsWith(homeDir)) {
-      normalizedPath = "~" + path5.slice(homeDir.length);
+    let normalizedPath = path6;
+    if (path6.startsWith(homeDir)) {
+      normalizedPath = "~" + path6.slice(homeDir.length);
     }
     const parts = normalizedPath.split(/[\\/]+/).filter((part) => part !== "");
     const abbreviated = parts.map((part, index) => {
@@ -58238,42 +58300,42 @@ var StatusJSONSchema = exports_external.looseObject({
 });
 
 // src/utils/jsonl.ts
-import * as fs6 from "fs";
-import path6 from "node:path";
+import * as fs7 from "fs";
+import path7 from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
-import path5, { 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 dirname2, normalize, relative, resolve as resolve2, sep } from "path";
+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(path5) {
-  let normalized = normalize(path5);
+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(path5, separator) {
-  return path5.replace(SLASHES_REGEX, separator);
+function convertSlashes(path6, separator) {
+  return path6.replace(SLASHES_REGEX, separator);
 }
 var WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
-function isRootDirectory(path5) {
-  return path5 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path5);
+function isRootDirectory(path6) {
+  return path6 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path6);
 }
-function normalizePath(path5, options) {
+function normalizePath(path6, options) {
   const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
-  const pathNeedsCleaning = process.platform === "win32" && path5.includes("/") || path5.startsWith(".");
+  const pathNeedsCleaning = process.platform === "win32" && path6.includes("/") || path6.startsWith(".");
   if (resolvePaths)
-    path5 = resolve2(path5);
+    path6 = resolve2(path6);
   if (normalizePath$1 || pathNeedsCleaning)
-    path5 = cleanPath(path5);
-  if (path5 === ".")
+    path6 = cleanPath(path6);
+  if (path6 === ".")
     return "";
-  const needsSeperator = path5[path5.length - 1] !== pathSeparator;
-  return convertSlashes(needsSeperator ? path5 + pathSeparator : path5, pathSeparator);
+  const needsSeperator = path6[path6.length - 1] !== pathSeparator;
+  return convertSlashes(needsSeperator ? path6 + pathSeparator : path6, pathSeparator);
 }
 function joinPathWithBasePath(filename, directoryPath) {
   return directoryPath + filename;
@@ -58313,9 +58375,9 @@ var pushDirectory = (directoryPath, paths) => {
   paths.push(directoryPath || ".");
 };
 var pushDirectoryFilter = (directoryPath, paths, filters) => {
-  const path5 = directoryPath || ".";
-  if (filters.every((filter) => filter(path5, true)))
-    paths.push(path5);
+  const path6 = directoryPath || ".";
+  if (filters.every((filter) => filter(path6, true)))
+    paths.push(path6);
 };
 var empty$2 = () => {};
 function build$6(root, options) {
@@ -58372,29 +58434,29 @@ var empty = () => {};
 function build$3(options) {
   return options.group ? groupFiles : empty;
 }
-var resolveSymlinksAsync = function(path5, state, callback$1) {
-  const { queue, fs: fs6, options: { suppressErrors } } = state;
+var resolveSymlinksAsync = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
-  fs6.realpath(path5, (error43, resolvedPath) => {
+  fs7.realpath(path6, (error43, resolvedPath) => {
     if (error43)
       return queue.dequeue(suppressErrors ? null : error43, state);
-    fs6.stat(resolvedPath, (error$1, stat) => {
+    fs7.stat(resolvedPath, (error$1, stat) => {
       if (error$1)
         return queue.dequeue(suppressErrors ? null : error$1, state);
-      if (stat.isDirectory() && isRecursive(path5, 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(path5, state, callback$1) {
-  const { queue, fs: fs6, options: { suppressErrors } } = state;
+var resolveSymlinks = function(path6, state, callback$1) {
+  const { queue, fs: fs7, options: { suppressErrors } } = state;
   queue.enqueue();
   try {
-    const resolvedPath = fs6.realpathSync(path5);
-    const stat = fs6.statSync(resolvedPath);
-    if (stat.isDirectory() && isRecursive(path5, resolvedPath, state))
+    const resolvedPath = fs7.realpathSync(path6);
+    const stat = fs7.statSync(resolvedPath);
+    if (stat.isDirectory() && isRecursive(path6, resolvedPath, state))
       return;
     callback$1(stat, resolvedPath);
   } catch (e) {
@@ -58407,10 +58469,10 @@ function build$2(options, isSynchronous) {
     return null;
   return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
 }
-function isRecursive(path5, resolved, state) {
+function isRecursive(path6, resolved, state) {
   if (state.options.useRealPaths)
     return isRecursiveUsingRealPaths(resolved, state);
-  let parent = dirname2(path5);
+  let parent = dirname3(path6);
   let depth = 1;
   while (parent !== state.root && depth < 2) {
     const resolvedPath = state.symlinks.get(parent);
@@ -58418,9 +58480,9 @@ function isRecursive(path5, resolved, state) {
     if (isSameRoot)
       depth++;
     else
-      parent = dirname2(parent);
+      parent = dirname3(parent);
   }
-  state.symlinks.set(path5, resolved);
+  state.symlinks.set(path6, resolved);
   return depth > 1;
 }
 function isRecursiveUsingRealPaths(resolved, state) {
@@ -58476,23 +58538,23 @@ var walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
   state.queue.enqueue();
   if (currentDepth < 0)
     return state.queue.dequeue(null, state);
-  const { fs: fs6 } = state;
+  const { fs: fs7 } = state;
   state.visited.push(crawlPath);
   state.counts.directories++;
-  fs6.readdir(crawlPath || ".", readdirOpts, (error43, entries = []) => {
+  fs7.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: fs6 } = state;
+  const { fs: fs7 } = state;
   if (currentDepth < 0)
     return;
   state.visited.push(crawlPath);
   state.counts.directories++;
   let entries = [];
   try {
-    entries = fs6.readdirSync(crawlPath || ".", readdirOpts);
+    entries = fs7.readdirSync(crawlPath || ".", readdirOpts);
   } catch (e) {
     if (!state.options.suppressErrors)
       throw e;
@@ -58598,23 +58660,23 @@ var Walker = class {
         const filename = this.joinPath(entry.name, directoryPath);
         this.pushFile(filename, files, this.state.counts, filters);
       } else if (entry.isDirectory()) {
-        let path5 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
-        if (exclude && exclude(entry.name, path5))
+        let path6 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+        if (exclude && exclude(entry.name, path6))
           continue;
-        this.pushDirectory(path5, paths, filters);
-        this.walkDirectory(this.state, path5, path5, 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 path5 = joinPathWithBasePath(entry.name, directoryPath);
-        this.resolveSymlink(path5, 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 : path5 + pathSeparator))
+            if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path6 + pathSeparator))
               return;
-            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path5 + pathSeparator, depth - 1, this.walk);
+            this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path6 + pathSeparator, depth - 1, this.walk);
           } else {
-            resolvedPath = useRealPaths ? resolvedPath : path5;
+            resolvedPath = useRealPaths ? resolvedPath : path6;
             const filename = basename2(resolvedPath);
-            const directoryPath$1 = normalizePath(dirname2(resolvedPath), this.state.options);
+            const directoryPath$1 = normalizePath(dirname3(resolvedPath), this.state.options);
             resolvedPath = this.joinPath(filename, directoryPath$1);
             this.pushFile(resolvedPath, files, this.state.counts, filters);
           }
@@ -58772,7 +58834,7 @@ var Builder = class {
       isMatch = globFn(patterns, ...options);
       this.globCache[patterns.join("\x00")] = isMatch;
     }
-    this.options.filters.push((path5) => isMatch(path5));
+    this.options.filters.push((path6) => isMatch(path6));
     return this;
   }
 };
@@ -58851,7 +58913,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
   if (!result.endsWith("*") && expandDirectories)
     result += "/**";
   const escapedCwd = escapePath(cwd2);
-  if (path5.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
+  if (path6.isAbsolute(result.replace(ESCAPING_BACKSLASHES, "")))
     result = posix.relative(escapedCwd, result);
   else
     result = posix.normalize(result);
@@ -58888,7 +58950,7 @@ function normalizePattern(pattern, expandDirectories, cwd2, props, isIgnore) {
     }
     props.depthOffset = newCommonPath.length;
     props.commonPath = newCommonPath;
-    props.root = newCommonPath.length > 0 ? path5.posix.join(cwd2, ...newCommonPath) : cwd2;
+    props.root = newCommonPath.length > 0 ? path6.posix.join(cwd2, ...newCommonPath) : cwd2;
   }
   return result;
 }
@@ -59021,18 +59083,18 @@ function globSync(patternsOrOptions, options) {
     ...options,
     patterns: patternsOrOptions
   } : patternsOrOptions;
-  const cwd2 = opts.cwd ? path5.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(fs6.readFile);
-var readFileSync4 = fs6.readFileSync;
-var statSync4 = fs6.statSync;
+var readFile4 = promisify(fs7.readFile);
+var readFileSync5 = fs7.readFileSync;
+var statSync4 = fs7.statSync;
 async function getSessionDuration(transcriptPath) {
   try {
-    if (!fs6.existsSync(transcriptPath)) {
+    if (!fs7.existsSync(transcriptPath)) {
       return null;
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59084,7 +59146,7 @@ async function getSessionDuration(transcriptPath) {
 }
 async function getTokenMetrics(transcriptPath) {
   try {
-    if (!fs6.existsSync(transcriptPath)) {
+    if (!fs7.existsSync(transcriptPath)) {
       return { inputTokens: 0, outputTokens: 0, cachedTokens: 0, totalTokens: 0, contextLength: 0 };
     }
     const content = await readFile4(transcriptPath, "utf-8");
@@ -59137,7 +59199,7 @@ function getBlockMetrics() {
 function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
   const sessionDurationMs = sessionDurationHours * 60 * 60 * 1000;
   const now = new Date;
-  const pattern = path6.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
@@ -59231,7 +59293,7 @@ function findMostRecentBlockStartTime(rootDir, sessionDurationHours = 5) {
 function getAllTimestampsFromFile(filePath) {
   const timestamps = [];
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(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.0.28",
+  "version": "2.0.30",
   "description": "A customizable status line formatter for Claude Code CLI",
   "module": "src/ccstatusline.ts",
   "type": "module",
@@ -8,7 +8,11 @@
     "ccstatusline": "dist/ccstatusline.js"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "scripts/usage.sh",
+    "scripts/context.sh",
+    "scripts/setup-enhanced.sh",
+    "defaults/"
   ],
   "scripts": {
     "start": "bun run src/ccstatusline.ts",

package/scripts/context.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+CACHE_FILE="$HOME/.claude/.statusline/context.json"
+
+make_bar() {
+  local pct="$1"
+  local width=15
+  local filled=$((pct * width / 100))
+  local empty=$((width - filled))
+  printf "["
+  printf "█%.0s" $(seq 1 "$filled")
+  printf "░%.0s" $(seq 1 "$empty")
+  printf "]"
+}
+
+format_tokens() {
+  local tokens="$1"
+  if [[ $tokens -ge 1000 ]]; then
+    echo "$((tokens / 1000))k"
+  else
+    echo "$tokens"
+  fi
+}
+
+if [[ ! -f "$CACHE_FILE" ]]; then
+  BAR=$(make_bar 0)
+  echo "Context: $BAR 0k/200k (0%)"
+  exit 0
+fi
+
+INPUT=$(cat "$CACHE_FILE")
+
+MAX_TOKENS=$(echo "$INPUT" | jq -r '.context_window_size // empty')
+CURRENT_USAGE=$(echo "$INPUT" | jq -r '.current_usage // empty')
+
+if [[ -z "$MAX_TOKENS" || "$MAX_TOKENS" == "null" || -z "$CURRENT_USAGE" || "$CURRENT_USAGE" == "null" ]]; then
+  BAR=$(make_bar 0)
+  echo "Context: $BAR 0k/200k (0%)"
+  exit 0
+fi
+
+INPUT_TOKENS=$(echo "$INPUT" | jq -r '.current_usage.input_tokens // 0')
+CACHE_CREATE=$(echo "$INPUT" | jq -r '.current_usage.cache_creation_input_tokens // 0')
+CACHE_READ=$(echo "$INPUT" | jq -r '.current_usage.cache_read_input_tokens // 0')
+
+CURRENT_TOKENS=$((INPUT_TOKENS + CACHE_CREATE + CACHE_READ))
+
+if [[ $MAX_TOKENS -gt 0 ]]; then
+  PERCENT=$((CURRENT_TOKENS * 100 / MAX_TOKENS))
+else
+  PERCENT=0
+fi
+
+CURRENT_FMT=$(format_tokens "$CURRENT_TOKENS")
+MAX_FMT=$(format_tokens "$MAX_TOKENS")
+BAR=$(make_bar "$PERCENT")
+
+echo "Context: $BAR ${CURRENT_FMT}/${MAX_FMT} (${PERCENT}%)"

package/scripts/setup-enhanced.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# Setup script for ccstatusline-usage enhanced configuration
+# Installs usage scripts and applies enhanced settings
+
+set -euo pipefail
+
+SCRIPT_DIR="$HOME/.local/share/ccstatusline"
+CONFIG_DIR="$HOME/.config/ccstatusline"
+SETTINGS_FILE="$CONFIG_DIR/settings.json"
+
+# Find the package directory (where this script is located)
+PKG_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+
+echo "Setting up ccstatusline-usage enhanced configuration..."
+
+# Create directories
+mkdir -p "$SCRIPT_DIR"
+mkdir -p "$CONFIG_DIR"
+
+# Copy scripts
+if [[ -f "$PKG_DIR/scripts/usage.sh" ]]; then
+    cp "$PKG_DIR/scripts/usage.sh" "$SCRIPT_DIR/"
+    chmod +x "$SCRIPT_DIR/usage.sh"
+    echo "✓ Installed usage.sh to $SCRIPT_DIR/"
+else
+    echo "✗ usage.sh not found in package"
+    exit 1
+fi
+
+if [[ -f "$PKG_DIR/scripts/context.sh" ]]; then
+    cp "$PKG_DIR/scripts/context.sh" "$SCRIPT_DIR/"
+    chmod +x "$SCRIPT_DIR/context.sh"
+    echo "✓ Installed context.sh to $SCRIPT_DIR/"
+else
+    echo "✗ context.sh not found in package"
+    exit 1
+fi
+
+# Create enhanced settings with correct paths
+cat > "$SETTINGS_FILE" << 'EOF'
+{
+  "version": 3,
+  "lines": [
+    [
+      {
+        "id": "session-usage",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "$HOME/.local/share/ccstatusline/usage.sh session",
+        "timeout": 5000
+      },
+      {"id": "sep1", "type": "separator"},
+      {
+        "id": "weekly-usage",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "$HOME/.local/share/ccstatusline/usage.sh weekly",
+        "timeout": 5000
+      },
+      {"id": "sep2", "type": "separator"},
+      {
+        "id": "reset-timer",
+        "type": "custom-command",
+        "color": "brightBlue",
+        "commandPath": "$HOME/.local/share/ccstatusline/usage.sh reset",
+        "timeout": 5000
+      },
+      {"id": "sep3", "type": "separator"},
+      {"id": "model", "type": "model", "color": "magenta"},
+      {"id": "sep4", "type": "separator"},
+      {"id": "session-id", "type": "claude-session-id", "color": "cyan"}
+    ],
+    [
+      {
+        "id": "context-usage",
+        "type": "custom-command",
+        "color": "blue",
+        "commandPath": "$HOME/.local/share/ccstatusline/context.sh",
+        "timeout": 5000
+      }
+    ],
+    []
+  ],
+  "flexMode": "full-minus-40",
+  "compactThreshold": 60,
+  "colorLevel": 2
+}
+EOF
+
+# Expand $HOME in the settings file
+sed -i.bak "s|\$HOME|$HOME|g" "$SETTINGS_FILE" && rm -f "$SETTINGS_FILE.bak"
+
+echo "✓ Created enhanced settings at $SETTINGS_FILE"
+echo ""
+echo "Setup complete! Run 'npx ccstatusline-usage' to configure."
+echo ""
+echo "Note: The usage widgets require Anthropic API access."
+echo "Make sure you have valid credentials in ~/.claude/credentials.json"

package/scripts/usage.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+
+# Cross-platform usage script for ccstatusline-usage
+# Works on both macOS and Linux
+
+CACHE_FILE="$HOME/.cache/ccstatusline-api.json"
+LOCK_FILE="$HOME/.cache/ccstatusline-api.lock"
+
+# Detect OS for platform-specific commands
+is_macos() {
+  [[ "$(uname)" == "Darwin" ]]
+}
+
+# Get file modification time (seconds since epoch)
+get_mtime() {
+  if is_macos; then
+    stat -f '%m' "$1" 2>/dev/null
+  else
+    stat -c '%Y' "$1" 2>/dev/null
+  fi
+}
+
+# Get OAuth token from credentials
+get_token() {
+  if is_macos; then
+    # macOS: read from keychain
+    security find-generic-password -s "Claude Code-credentials" -w 2>/dev/null | jq -r '.claudeAiOauth.accessToken // empty'
+  else
+    # Linux: read from credentials file
+    jq -r '.claudeAiOauth.accessToken // empty' ~/.claude/.credentials.json 2>/dev/null
+  fi
+}
+
+# Parse ISO date to epoch
+parse_iso_date() {
+  local iso_date="$1"
+  # Remove fractional seconds and Z suffix
+  local clean_date="${iso_date%%.*}"
+  clean_date="${clean_date%%Z}"
+
+  if is_macos; then
+    TZ=UTC date -j -f "%Y-%m-%dT%H:%M:%S" "$clean_date" "+%s" 2>/dev/null
+  else
+    # Linux: use date -d with ISO format
+    date -d "$clean_date" "+%s" 2>/dev/null
+  fi
+}
+
+fetch_api() {
+  local NOW=$(date +%s)
+
+  # Use cache if < 180 seconds old
+  if [[ -f "$CACHE_FILE" ]]; then
+    local MTIME=$(get_mtime "$CACHE_FILE")
+    if [[ -n "$MTIME" ]]; then
+      local CACHE_AGE=$((NOW - MTIME))
+      [[ $CACHE_AGE -lt 180 ]] && return 0
+    fi
+  fi
+
+  # Rate limit: only try API once per 30 seconds
+  if [[ -f "$LOCK_FILE" ]]; then
+    local LOCK_MTIME=$(get_mtime "$LOCK_FILE")
+    if [[ -n "$LOCK_MTIME" ]]; then
+      local LOCK_AGE=$((NOW - LOCK_MTIME))
+      if [[ $LOCK_AGE -lt 30 ]]; then
+        [[ -f "$CACHE_FILE" ]] && return 0
+        return 1
+      fi
+    fi
+  fi
+
+  touch "$LOCK_FILE"
+
+  TOKEN=$(get_token)
+  [[ -z "$TOKEN" ]] && return 1
+
+  RESPONSE=$(curl -s --max-time 5 "https://api.anthropic.com/api/oauth/usage" \
+    -H "Authorization: Bearer $TOKEN" \
+    -H "anthropic-beta: oauth-2025-04-20" 2>/dev/null)
+  [[ -z "$RESPONSE" ]] && return 1
+
+  # Ensure cache directory exists
+  mkdir -p "$(dirname "$CACHE_FILE")"
+  echo "$RESPONSE" > "$CACHE_FILE"
+  return 0
+}
+
+make_bar() {
+  local pct="$1"
+  local width=15
+  local filled=$((pct * width / 100))
+  local empty=$((width - filled))
+  printf "["
+  printf "█%.0s" $(seq 1 "$filled")
+  printf "░%.0s" $(seq 1 "$empty")
+  printf "]"
+}
+
+MODE="${1:-all}"
+
+fetch_api || { echo "[API Error]"; exit 1; }
+
+case "$MODE" in
+  session)
+    SESSION=$(jq -r '.five_hour.utilization // empty' "$CACHE_FILE" 2>/dev/null)
+    [[ -z "$SESSION" ]] && { echo "[Parse Error]"; exit 1; }
+    SESSION_INT=${SESSION%.*}
+    SESSION_BAR=$(make_bar "$SESSION_INT")
+    echo "Session: $SESSION_BAR ${SESSION}%"
+    ;;
+  weekly)
+    WEEKLY=$(jq -r '.seven_day.utilization // empty' "$CACHE_FILE" 2>/dev/null)
+    [[ -z "$WEEKLY" ]] && { echo "[Parse Error]"; exit 1; }
+    WEEKLY_INT=${WEEKLY%.*}
+    WEEKLY_BAR=$(make_bar "$WEEKLY_INT")
+    echo "Weekly: $WEEKLY_BAR ${WEEKLY}%"
+    ;;
+  reset)
+    RESETS_AT=$(jq -r '.five_hour.resets_at // empty' "$CACHE_FILE" 2>/dev/null)
+    [[ -z "$RESETS_AT" ]] && { echo "[Parse Error]"; exit 1; }
+    RESET_EPOCH=$(parse_iso_date "$RESETS_AT")
+    NOW_EPOCH=$(date -u +%s)
+    if [[ -z "$RESET_EPOCH" ]]; then
+      echo "[Date Error]"
+      exit 1
+    fi
+    DIFF=$((RESET_EPOCH - NOW_EPOCH))
+    if [[ $DIFF -le 0 ]]; then
+      echo "Reset now"
+    else
+      HOURS=$((DIFF / 3600))
+      MINUTES=$(((DIFF % 3600) / 60))
+      echo "${HOURS}:$(printf '%02d' $MINUTES) hr"
+    fi
+    ;;
+  *)
+    SESSION=$(jq -r '.five_hour.utilization // empty' "$CACHE_FILE" 2>/dev/null)
+    WEEKLY=$(jq -r '.seven_day.utilization // empty' "$CACHE_FILE" 2>/dev/null)
+    [[ -z "$SESSION" || -z "$WEEKLY" ]] && { echo "[Parse Error]"; exit 1; }
+    SESSION_INT=${SESSION%.*}
+    WEEKLY_INT=${WEEKLY%.*}
+    SESSION_BAR=$(make_bar "$SESSION_INT")
+    WEEKLY_BAR=$(make_bar "$WEEKLY_INT")
+    echo "Session: $SESSION_BAR ${SESSION}% | Weekly: $WEEKLY_BAR ${WEEKLY}%"
+    ;;
+esac