claude-limitline 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tyler Gray
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,281 @@
+# claude-limitline
+
+A statusline for Claude Code showing real-time usage limits and weekly tracking.
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)
+![TypeScript](https://img.shields.io/badge/typescript-5.3-blue.svg)
+
+## Features
+
+- **5-Hour Block Limit** - Shows current usage percentage with time remaining until reset
+- **7-Day Rolling Limit** - Tracks weekly usage with progress indicator
+- **Real-time Tracking** - Uses Anthropic's OAuth usage API for accurate usage data
+- **Progress Bar Display** - Visual progress bars for quick status checks
+- **Cross-Platform** - Works on Windows, macOS, and Linux
+- **Zero Runtime Dependencies** - Lightweight and fast
+- **Multiple Themes** - Dark, light, nord, and gruvbox themes included
+
+## Prerequisites
+
+- **Node.js** 18.0.0 or higher
+- **Claude Code** CLI installed and authenticated (for OAuth token)
+- **Nerd Font** (optional, for powerline symbols)
+
+## Installation
+
+### From npm (recommended)
+
+```bash
+npm install -g claude-limitline
+```
+
+### From Source
+
+```bash
+git clone https://github.com/tylergraydev/claude-limitline.git
+cd claude-limitline
+npm install
+npm run build
+npm link
+```
+
+### Using Docker
+
+```bash
+# Build the image
+docker build -t claude-limitline .
+
+# Run (mount your .claude directory for OAuth token access)
+docker run --rm -v ~/.claude:/root/.claude claude-limitline
+```
+
+## Quick Start
+
+The easiest way to use claude-limitline is to add it directly to your Claude Code settings.
+
+**Add to your Claude Code settings file** (`~/.claude/settings.json`):
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "npx claude-limitline"
+  }
+}
+```
+
+That's it! The status line will now show your usage limits in Claude Code.
+
+### Full Settings Example
+
+Here's a complete example with other common settings:
+
+```json
+{
+  "permissions": {
+    "defaultMode": "default"
+  },
+  "statusLine": {
+    "type": "command",
+    "command": "npx claude-limitline"
+  }
+}
+```
+
+### Alternative: Global Install
+
+If you prefer a global installation (slightly faster startup):
+
+```bash
+npm install -g claude-limitline
+```
+
+Then update your settings:
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "claude-limitline"
+  }
+}
+```
+
+### Test It
+
+Run standalone to verify it's working:
+
+```bash
+npx claude-limitline
+```
+
+You should see output like:
+```
+⏳ ████████░░ 45% (2h 30m left) | 📅 ██████░░░░ 62% (wk 43%)
+```
+
+## Configuration
+
+Create a `.claude-limitline.json` file in your home directory (`~/.claude-limitline.json`) or current working directory:
+
+```json
+{
+  "display": {
+    "style": "minimal",
+    "useNerdFonts": true
+  },
+  "block": {
+    "enabled": true,
+    "displayStyle": "bar",
+    "barWidth": 10,
+    "showTimeRemaining": true
+  },
+  "weekly": {
+    "enabled": true,
+    "displayStyle": "bar",
+    "barWidth": 10,
+    "showWeekProgress": true
+  },
+  "budget": {
+    "pollInterval": 15,
+    "warningThreshold": 80
+  },
+  "theme": "dark"
+}
+```
+
+### Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `display.useNerdFonts` | Use Nerd Font symbols (⏳📅) vs ASCII | `true` |
+| `block.enabled` | Show 5-hour block usage | `true` |
+| `block.displayStyle` | `"bar"` or `"text"` | `"bar"` |
+| `block.barWidth` | Width of progress bar in characters | `10` |
+| `block.showTimeRemaining` | Show time until block resets | `true` |
+| `weekly.enabled` | Show 7-day rolling usage | `true` |
+| `weekly.displayStyle` | `"bar"` or `"text"` | `"bar"` |
+| `weekly.barWidth` | Width of progress bar in characters | `10` |
+| `weekly.showWeekProgress` | Show week progress percentage | `true` |
+| `budget.pollInterval` | Minutes between API calls | `15` |
+| `budget.warningThreshold` | Percentage to trigger warning color | `80` |
+| `theme` | Color theme name | `"dark"` |
+
+### Available Themes
+
+- `dark` - Default dark theme
+- `light` - Light background theme
+- `nord` - Nord color palette
+- `gruvbox` - Gruvbox color palette
+
+## How It Works
+
+claude-limitline retrieves your Claude usage data from Anthropic's OAuth usage API. It reads your OAuth token from:
+
+| Platform | Location |
+|----------|----------|
+| **Windows** | Credential Manager or `~/.claude/.credentials.json` |
+| **macOS** | Keychain or `~/.claude/.credentials.json` |
+| **Linux** | secret-tool (GNOME Keyring) or `~/.claude/.credentials.json` |
+
+The usage data is cached locally to respect API rate limits. The cache duration is configurable via `budget.pollInterval` (default: 15 minutes).
+
+### API Response
+
+The tool queries Anthropic's usage endpoint which returns:
+
+- **5-hour block**: Usage percentage and reset time for the rolling 5-hour window
+- **7-day rolling**: Usage percentage and reset time for the rolling 7-day window
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/tylergraydev/claude-limitline.git
+cd claude-limitline
+npm install
+```
+
+### Build
+
+```bash
+npm run build
+```
+
+### Development Mode (watch)
+
+```bash
+npm run dev
+```
+
+### Type Checking
+
+```bash
+npm run typecheck
+```
+
+### Run Locally
+
+```bash
+node dist/index.js
+```
+
+## Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```bash
+# Linux/macOS
+CLAUDE_LIMITLINE_DEBUG=true claude-limitline
+
+# Windows (PowerShell)
+$env:CLAUDE_LIMITLINE_DEBUG="true"; claude-limitline
+
+# Windows (CMD)
+set CLAUDE_LIMITLINE_DEBUG=true && claude-limitline
+```
+
+Debug output is written to stderr so it won't interfere with the status line output.
+
+## Troubleshooting
+
+### "No data" or empty output
+
+1. **Check OAuth token**: Make sure you're logged into Claude Code (`claude --login`)
+2. **Check credentials file**: Verify `~/.claude/.credentials.json` exists and contains `claudeAiOauth.accessToken`
+3. **Enable debug mode**: Run with `CLAUDE_LIMITLINE_DEBUG=true` to see detailed logs
+
+### Token not found
+
+The OAuth token is stored by Claude Code when you authenticate. Try:
+
+```bash
+# Re-authenticate with Claude Code
+claude --login
+```
+
+### API returns errors
+
+- Ensure your Claude subscription is active
+- Check if you've exceeded API rate limits (try increasing `pollInterval`)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Acknowledgments
+
+- Inspired by [claude-powerline](https://github.com/Owloops/claude-powerline)
+- Built for use with [Claude Code](https://claude.com/claude-code)

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,635 @@
+#!/usr/bin/env node
+
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// src/utils/logger.ts
+var DEBUG = process.env.CLAUDE_LIMITLINE_DEBUG === "true";
+function debug(...args) {
+  if (DEBUG) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.error(`[${timestamp}] [DEBUG]`, ...args);
+  }
+}
+
+// src/config/types.ts
+var DEFAULT_CONFIG = {
+  display: {
+    style: "minimal",
+    useNerdFonts: true
+  },
+  block: {
+    enabled: true,
+    displayStyle: "bar",
+    barWidth: 10,
+    showTimeRemaining: true
+  },
+  weekly: {
+    enabled: true,
+    displayStyle: "bar",
+    barWidth: 10,
+    showWeekProgress: true
+  },
+  budget: {
+    pollInterval: 15,
+    warningThreshold: 80
+  },
+  theme: "dark"
+};
+
+// src/config/loader.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (sourceValue !== void 0 && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      result[key] = { ...targetValue, ...sourceValue };
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function loadConfig() {
+  const configPaths = [
+    path.join(process.cwd(), ".claude-limitline.json"),
+    path.join(os.homedir(), ".claude-limitline.json"),
+    path.join(os.homedir(), ".config", "claude-limitline", "config.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const userConfig = JSON.parse(content);
+        debug(`Loaded config from ${configPath}`);
+        return deepMerge(DEFAULT_CONFIG, userConfig);
+      }
+    } catch (error) {
+      debug(`Failed to load config from ${configPath}:`, error);
+    }
+  }
+  debug("Using default config");
+  return DEFAULT_CONFIG;
+}
+
+// src/utils/oauth.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs2 from "fs";
+import path2 from "path";
+import os2 from "os";
+var execAsync = promisify(exec);
+async function getOAuthTokenWindows() {
+  try {
+    const { stdout } = await execAsync(
+      `powershell -Command "[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String((Get-StoredCredential -Target 'Claude Code' -AsCredentialObject).Password))"`,
+      { timeout: 5e3 }
+    );
+    const token = stdout.trim();
+    if (token && token.startsWith("sk-ant-oat")) {
+      return token;
+    }
+  } catch (error) {
+    debug("PowerShell credential retrieval failed:", error);
+  }
+  try {
+    const { stdout } = await execAsync(
+      `powershell -Command "$cred = cmdkey /list:Claude* | Select-String -Pattern 'User:.*'; if ($cred) { $cred.Line.Split(':')[1].Trim() }"`,
+      { timeout: 5e3 }
+    );
+    debug("cmdkey output:", stdout);
+  } catch (error) {
+    debug("cmdkey approach failed:", error);
+  }
+  const primaryPath = path2.join(os2.homedir(), ".claude", ".credentials.json");
+  try {
+    if (fs2.existsSync(primaryPath)) {
+      const content = fs2.readFileSync(primaryPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.claudeAiOauth && typeof config.claudeAiOauth === "object") {
+        const token = config.claudeAiOauth.accessToken;
+        if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+          debug(`Found OAuth token in ${primaryPath} under claudeAiOauth.accessToken`);
+          return token;
+        }
+      }
+    }
+  } catch (error) {
+    debug(`Failed to read config from ${primaryPath}:`, error);
+  }
+  const fallbackPaths = [
+    path2.join(os2.homedir(), ".claude", "credentials.json"),
+    path2.join(os2.homedir(), ".config", "claude-code", "credentials.json"),
+    path2.join(process.env.APPDATA || "", "Claude Code", "credentials.json"),
+    path2.join(process.env.LOCALAPPDATA || "", "Claude Code", "credentials.json")
+  ];
+  for (const configPath of fallbackPaths) {
+    try {
+      if (fs2.existsSync(configPath)) {
+        const content = fs2.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        for (const key of ["oauth_token", "token", "accessToken"]) {
+          const token = config[key];
+          if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+            debug(`Found OAuth token in ${configPath} under key ${key}`);
+            return token;
+          }
+        }
+      }
+    } catch (error) {
+      debug(`Failed to read config from ${configPath}:`, error);
+    }
+  }
+  return null;
+}
+async function getOAuthTokenMacOS() {
+  try {
+    const { stdout } = await execAsync(
+      `security find-generic-password -s "Claude Code" -w`,
+      { timeout: 5e3 }
+    );
+    const token = stdout.trim();
+    if (token && token.startsWith("sk-ant-oat")) {
+      return token;
+    }
+  } catch (error) {
+    debug("macOS Keychain retrieval failed:", error);
+  }
+  return null;
+}
+async function getOAuthTokenLinux() {
+  try {
+    const { stdout } = await execAsync(
+      `secret-tool lookup service "Claude Code"`,
+      { timeout: 5e3 }
+    );
+    const token = stdout.trim();
+    if (token && token.startsWith("sk-ant-oat")) {
+      return token;
+    }
+  } catch (error) {
+    debug("Linux secret-tool retrieval failed:", error);
+  }
+  const configPaths = [
+    path2.join(os2.homedir(), ".claude", ".credentials.json"),
+    path2.join(os2.homedir(), ".claude", "credentials.json"),
+    path2.join(os2.homedir(), ".config", "claude-code", "credentials.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      if (fs2.existsSync(configPath)) {
+        const content = fs2.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(content);
+        if (config.claudeAiOauth && typeof config.claudeAiOauth === "object") {
+          const token = config.claudeAiOauth.accessToken;
+          if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+            debug(`Found OAuth token in ${configPath} under claudeAiOauth.accessToken`);
+            return token;
+          }
+        }
+        for (const key of ["oauth_token", "token", "accessToken"]) {
+          const token = config[key];
+          if (token && typeof token === "string" && token.startsWith("sk-ant-oat")) {
+            debug(`Found OAuth token in ${configPath} under key ${key}`);
+            return token;
+          }
+        }
+      }
+    } catch (error) {
+      debug(`Failed to read config from ${configPath}:`, error);
+    }
+  }
+  return null;
+}
+async function getOAuthToken() {
+  const platform = process.platform;
+  debug(`Attempting to retrieve OAuth token on platform: ${platform}`);
+  switch (platform) {
+    case "win32":
+      return getOAuthTokenWindows();
+    case "darwin":
+      return getOAuthTokenMacOS();
+    case "linux":
+      return getOAuthTokenLinux();
+    default:
+      debug(`Unsupported platform for OAuth token retrieval: ${platform}`);
+      return null;
+  }
+}
+async function fetchUsageFromAPI(token) {
+  try {
+    const response = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "claude-limitline/1.0.0",
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      }
+    });
+    if (!response.ok) {
+      debug(`Usage API returned status ${response.status}: ${response.statusText}`);
+      return null;
+    }
+    const data = await response.json();
+    debug("Usage API response:", JSON.stringify(data));
+    const parseUsageBlock = (block) => {
+      if (!block) return null;
+      return {
+        resetAt: block.resets_at ? new Date(block.resets_at) : /* @__PURE__ */ new Date(),
+        percentUsed: block.utilization ?? 0,
+        isOverLimit: (block.utilization ?? 0) >= 100
+      };
+    };
+    return {
+      fiveHour: parseUsageBlock(data.five_hour),
+      sevenDay: parseUsageBlock(data.seven_day),
+      raw: data
+    };
+  } catch (error) {
+    debug("Failed to fetch usage from API:", error);
+    return null;
+  }
+}
+var cachedUsage = null;
+var cacheTimestamp = 0;
+var cachedToken = null;
+async function getRealtimeUsage(pollIntervalMinutes = 15) {
+  const now = Date.now();
+  const cacheAgeMs = now - cacheTimestamp;
+  const pollIntervalMs = pollIntervalMinutes * 60 * 1e3;
+  if (cachedUsage && cacheAgeMs < pollIntervalMs) {
+    debug(`Using cached usage data (age: ${Math.round(cacheAgeMs / 1e3)}s)`);
+    return cachedUsage;
+  }
+  if (!cachedToken) {
+    cachedToken = await getOAuthToken();
+    if (!cachedToken) {
+      debug("Could not retrieve OAuth token for realtime usage");
+      return null;
+    }
+  }
+  const usage = await fetchUsageFromAPI(cachedToken);
+  if (usage) {
+    cachedUsage = usage;
+    cacheTimestamp = now;
+    debug("Refreshed realtime usage cache");
+  } else {
+    cachedToken = null;
+  }
+  return usage;
+}
+
+// src/segments/block.ts
+var BlockProvider = class {
+  async getBlockInfo(pollInterval) {
+    const realtimeInfo = await this.getRealtimeBlockInfo(pollInterval);
+    if (realtimeInfo) {
+      return realtimeInfo;
+    }
+    debug("Realtime mode failed, no block data available");
+    return {
+      percentUsed: null,
+      resetAt: null,
+      timeRemaining: null,
+      isRealtime: false
+    };
+  }
+  async getRealtimeBlockInfo(pollInterval) {
+    try {
+      const usage = await getRealtimeUsage(pollInterval ?? 15);
+      if (!usage || !usage.fiveHour) {
+        debug("No realtime block usage data available");
+        return null;
+      }
+      const fiveHour = usage.fiveHour;
+      const now = /* @__PURE__ */ new Date();
+      const resetAt = new Date(fiveHour.resetAt);
+      const timeRemaining = Math.max(
+        0,
+        Math.round((resetAt.getTime() - now.getTime()) / (1e3 * 60))
+      );
+      debug(
+        `Block segment (realtime): ${fiveHour.percentUsed}% used, resets at ${fiveHour.resetAt.toISOString()}, ${timeRemaining}m remaining`
+      );
+      return {
+        percentUsed: fiveHour.percentUsed,
+        resetAt: fiveHour.resetAt,
+        timeRemaining,
+        isRealtime: true
+      };
+    } catch (error) {
+      debug("Error getting realtime block info:", error);
+      return null;
+    }
+  }
+};
+
+// src/segments/weekly.ts
+var WeeklyProvider = class {
+  calculateWeekProgress(resetDay, resetHour, resetMinute) {
+    const now = /* @__PURE__ */ new Date();
+    const dayOfWeek = now.getDay();
+    const hours = now.getHours();
+    const minutes = now.getMinutes();
+    const targetDay = resetDay ?? 1;
+    const targetHour = resetHour ?? 0;
+    const targetMinute = resetMinute ?? 0;
+    let daysSinceReset = (dayOfWeek - targetDay + 7) % 7;
+    if (daysSinceReset === 0) {
+      const currentMinutes = hours * 60 + minutes;
+      const resetMinutes = targetHour * 60 + targetMinute;
+      if (currentMinutes < resetMinutes) {
+        daysSinceReset = 7;
+      }
+    }
+    const hoursIntoWeek = daysSinceReset * 24 + hours - targetHour + (minutes - targetMinute) / 60;
+    const totalHoursInWeek = 7 * 24;
+    const progress = Math.max(0, Math.min(100, hoursIntoWeek / totalHoursInWeek * 100));
+    return Math.round(progress);
+  }
+  calculateWeekProgressFromResetTime(resetAt) {
+    const now = /* @__PURE__ */ new Date();
+    const resetTime = new Date(resetAt);
+    const periodStart = new Date(resetTime);
+    periodStart.setDate(periodStart.getDate() - 7);
+    if (now > resetTime) {
+      const newPeriodStart = resetTime;
+      const newResetTime = new Date(resetTime);
+      newResetTime.setDate(newResetTime.getDate() + 7);
+      const totalMs2 = newResetTime.getTime() - newPeriodStart.getTime();
+      const elapsedMs2 = now.getTime() - newPeriodStart.getTime();
+      return Math.round(elapsedMs2 / totalMs2 * 100);
+    }
+    const totalMs = resetTime.getTime() - periodStart.getTime();
+    const elapsedMs = now.getTime() - periodStart.getTime();
+    const progress = Math.max(0, Math.min(100, elapsedMs / totalMs * 100));
+    return Math.round(progress);
+  }
+  async getWeeklyInfo(resetDay, resetHour, resetMinute, pollInterval) {
+    const realtimeInfo = await this.getRealtimeWeeklyInfo(pollInterval);
+    if (realtimeInfo) {
+      return realtimeInfo;
+    }
+    debug("Realtime mode failed, falling back to estimate mode");
+    const weekProgressPercent = this.calculateWeekProgress(resetDay, resetHour, resetMinute);
+    return {
+      percentUsed: null,
+      resetAt: null,
+      isRealtime: false,
+      weekProgressPercent
+    };
+  }
+  async getRealtimeWeeklyInfo(pollInterval) {
+    try {
+      const usage = await getRealtimeUsage(pollInterval ?? 15);
+      if (!usage || !usage.sevenDay) {
+        debug("No realtime weekly usage data available");
+        return null;
+      }
+      const sevenDay = usage.sevenDay;
+      const weekProgressPercent = this.calculateWeekProgressFromResetTime(sevenDay.resetAt);
+      debug(
+        `Weekly segment (realtime): ${sevenDay.percentUsed}% used, resets at ${sevenDay.resetAt.toISOString()}`
+      );
+      return {
+        percentUsed: sevenDay.percentUsed,
+        resetAt: sevenDay.resetAt,
+        isRealtime: true,
+        weekProgressPercent
+      };
+    } catch (error) {
+      debug("Error getting realtime weekly info:", error);
+      return null;
+    }
+  }
+};
+
+// src/utils/constants.ts
+var SYMBOLS = {
+  right: "\uE0B0",
+  left: "\uE0B2",
+  branch: "\uE0A0",
+  separator: "\uE0B1",
+  block_cost: "\uF252",
+  // Hourglass
+  weekly_cost: "\uF073",
+  // Calendar
+  progress_full: "\u2588",
+  // Full block
+  progress_empty: "\u2591"
+  // Light shade
+};
+var TEXT_SYMBOLS = {
+  right: ">",
+  left: "<",
+  branch: "",
+  separator: "|",
+  block_cost: "BLK",
+  weekly_cost: "WK",
+  progress_full: "#",
+  progress_empty: "-"
+};
+var RESET_CODE = "\x1B[0m";
+
+// src/themes/index.ts
+var color = (n) => `\x1B[38;5;${n}m`;
+var bgColor = (n) => `\x1B[48;5;${n}m`;
+var themes = {
+  dark: {
+    blockBg: bgColor(236),
+    blockFg: color(252),
+    weeklyBg: bgColor(236),
+    weeklyFg: color(252),
+    warningBg: bgColor(172),
+    warningFg: color(232),
+    criticalBg: bgColor(160),
+    criticalFg: color(255),
+    progressFull: color(76),
+    progressEmpty: color(240),
+    separatorFg: color(244)
+  },
+  light: {
+    blockBg: bgColor(254),
+    blockFg: color(236),
+    weeklyBg: bgColor(254),
+    weeklyFg: color(236),
+    warningBg: bgColor(214),
+    warningFg: color(232),
+    criticalBg: bgColor(196),
+    criticalFg: color(255),
+    progressFull: color(34),
+    progressEmpty: color(250),
+    separatorFg: color(244)
+  },
+  nord: {
+    blockBg: bgColor(236),
+    blockFg: color(110),
+    weeklyBg: bgColor(236),
+    weeklyFg: color(110),
+    warningBg: bgColor(179),
+    warningFg: color(232),
+    criticalBg: bgColor(131),
+    criticalFg: color(255),
+    progressFull: color(108),
+    progressEmpty: color(239),
+    separatorFg: color(60)
+  },
+  gruvbox: {
+    blockBg: bgColor(237),
+    blockFg: color(223),
+    weeklyBg: bgColor(237),
+    weeklyFg: color(223),
+    warningBg: bgColor(214),
+    warningFg: color(235),
+    criticalBg: bgColor(167),
+    criticalFg: color(235),
+    progressFull: color(142),
+    progressEmpty: color(239),
+    separatorFg: color(246)
+  }
+};
+function getTheme(name) {
+  return themes[name] || themes.dark;
+}
+
+// src/renderer.ts
+var Renderer = class {
+  config;
+  theme;
+  symbols;
+  constructor(config) {
+    this.config = config;
+    this.theme = getTheme(config.theme || "dark");
+    const useNerd = config.display?.useNerdFonts ?? true;
+    const symbolSet = useNerd ? SYMBOLS : TEXT_SYMBOLS;
+    this.symbols = {
+      block: symbolSet.block_cost,
+      weekly: symbolSet.weekly_cost,
+      separator: symbolSet.separator,
+      progressFull: symbolSet.progress_full,
+      progressEmpty: symbolSet.progress_empty
+    };
+  }
+  formatProgressBar(percent, width, colors) {
+    const filled = Math.round(percent / 100 * width);
+    const empty = width - filled;
+    const filledBar = colors.progressFull + this.symbols.progressFull.repeat(filled);
+    const emptyBar = colors.progressEmpty + this.symbols.progressEmpty.repeat(empty);
+    return filledBar + emptyBar + RESET_CODE;
+  }
+  formatTimeRemaining(minutes) {
+    if (minutes >= 60) {
+      const hours = Math.floor(minutes / 60);
+      const mins = minutes % 60;
+      return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+    }
+    return `${minutes}m`;
+  }
+  getColorForPercent(percent, colors) {
+    const threshold = this.config.budget?.warningThreshold ?? 80;
+    if (percent >= 100) {
+      return { bg: colors.criticalBg, fg: colors.criticalFg };
+    } else if (percent >= threshold) {
+      return { bg: colors.warningBg, fg: colors.warningFg };
+    }
+    return { bg: colors.blockBg, fg: colors.blockFg };
+  }
+  renderBlock(blockInfo) {
+    if (!blockInfo || !this.config.block?.enabled) {
+      return "";
+    }
+    if (blockInfo.percentUsed === null) {
+      return `${this.symbols.block} --`;
+    }
+    const percent = blockInfo.percentUsed;
+    const displayStyle = this.config.block.displayStyle || "bar";
+    const barWidth = this.config.block.barWidth || 10;
+    const showTime = this.config.block.showTimeRemaining ?? true;
+    let display;
+    if (displayStyle === "bar") {
+      const bar = this.formatProgressBar(percent, barWidth, this.theme);
+      display = `${bar} ${Math.round(percent)}%`;
+    } else {
+      display = `${Math.round(percent)}%`;
+    }
+    if (showTime && blockInfo.timeRemaining !== null) {
+      const timeStr = this.formatTimeRemaining(blockInfo.timeRemaining);
+      display += ` (${timeStr} left)`;
+    }
+    return `${this.symbols.block} ${display}`;
+  }
+  renderWeekly(weeklyInfo) {
+    if (!weeklyInfo || !this.config.weekly?.enabled) {
+      return "";
+    }
+    if (weeklyInfo.percentUsed === null) {
+      return `${this.symbols.weekly} --`;
+    }
+    const percent = weeklyInfo.percentUsed;
+    const displayStyle = this.config.weekly.displayStyle || "bar";
+    const barWidth = this.config.weekly.barWidth || 10;
+    const showWeekProgress = this.config.weekly.showWeekProgress ?? true;
+    let display;
+    if (displayStyle === "bar") {
+      const bar = this.formatProgressBar(percent, barWidth, this.theme);
+      display = `${bar} ${Math.round(percent)}%`;
+    } else {
+      display = `${Math.round(percent)}%`;
+    }
+    if (showWeekProgress) {
+      display += ` (wk ${weeklyInfo.weekProgressPercent}%)`;
+    }
+    return `${this.symbols.weekly} ${display}`;
+  }
+  render(blockInfo, weeklyInfo) {
+    const parts = [];
+    const blockSegment = this.renderBlock(blockInfo);
+    if (blockSegment) {
+      parts.push(blockSegment);
+    }
+    const weeklySegment = this.renderWeekly(weeklyInfo);
+    if (weeklySegment) {
+      parts.push(weeklySegment);
+    }
+    if (parts.length === 0) {
+      return "";
+    }
+    const separator = ` ${this.theme.separatorFg}${this.symbols.separator}${RESET_CODE} `;
+    return parts.join(separator);
+  }
+};
+
+// src/index.ts
+async function main() {
+  try {
+    const config = loadConfig();
+    debug("Config loaded:", JSON.stringify(config));
+    const blockProvider = new BlockProvider();
+    const weeklyProvider = new WeeklyProvider();
+    const pollInterval = config.budget?.pollInterval ?? 15;
+    const [blockInfo, weeklyInfo] = await Promise.all([
+      config.block?.enabled ? blockProvider.getBlockInfo(pollInterval) : null,
+      config.weekly?.enabled ? weeklyProvider.getWeeklyInfo(
+        config.budget?.resetDay,
+        config.budget?.resetHour,
+        config.budget?.resetMinute,
+        pollInterval
+      ) : null
+    ]);
+    debug("Block info:", JSON.stringify(blockInfo));
+    debug("Weekly info:", JSON.stringify(weeklyInfo));
+    const renderer = new Renderer(config);
+    const output = renderer.render(blockInfo, weeklyInfo);
+    if (output) {
+      process.stdout.write(output);
+    }
+  } catch (error) {
+    debug("Error in main:", error);
+    process.exit(0);
+  }
+}
+main();

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "claude-limitline",
+  "version": "1.0.0",
+  "description": "A statusline for Claude Code showing real-time usage limits and weekly tracking",
+  "main": "dist/index.js",
+  "bin": {
+    "claude-limitline": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tylergraydev/claude-limitline.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "statusline",
+    "powerline",
+    "usage",
+    "monitoring",
+    "cli",
+    "anthropic"
+  ],
+  "author": "Tyler Gray",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tylergraydev/claude-limitline/issues"
+  },
+  "homepage": "https://github.com/tylergraydev/claude-limitline#readme",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist"
+  ]
+}