@owloops/claude-powerline 1.0.1 → 1.1.1

package/dist/index.js

@@ -1,263 +1,899 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import process from "process";
-import path from "path";
-import fs from "fs";
-import { execSync as execSync2 } from "child_process";
-import os from "os";
+import process2 from "process";
+import path2 from "path";
+import fs2 from "fs";
+import { execSync as execSync3 } from "child_process";
+import os2 from "os";
 import getStdin from "get-stdin";
 
-// src/powerline.ts
-import { execSync } from "child_process";
+// src/lib/colors.ts
+function hexToAnsi(hex, isBackground) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `\x1B[${isBackground ? "48" : "38"};2;${r};${g};${b}m`;
+}
+function extractBgToFg(ansiCode) {
+  const match = ansiCode.match(/48;2;(\d+);(\d+);(\d+)/);
+  if (match) {
+    return `\x1B[38;2;${match[1]};${match[2]};${match[3]}m`;
+  }
+  return ansiCode.replace("48", "38");
+}
+
+// src/lib/usage-provider.ts
 import {
   loadSessionUsageById,
   loadDailyUsageData,
+  loadSessionBlockData,
   getClaudePaths
 } from "ccusage/data-loader";
-import { calculateTotals } from "ccusage/calculate-cost";
+import { calculateTotals, getTotalTokens } from "ccusage/calculate-cost";
 import { logger } from "ccusage/logger";
-var PowerlineRenderer = class {
-  symbols;
-  colors;
-  constructor() {
-    this.symbols = this.initializeSymbols();
-    this.colors = {
-      colors: {
-        reset: "\x1B[0m",
-        modeBg: "\x1B[48;2;255;107;71m",
-        modeFg: "\x1B[97m",
-        sessionBg: "\x1B[48;2;79;179;217m",
-        sessionFg: "\x1B[97m",
-        dailyBg: "\x1B[48;2;135;206;235m",
-        dailyFg: "\x1B[30m",
-        blockBg: "\x1B[48;2;218;112;214m",
-        blockFg: "\x1B[97m",
-        burnLowBg: "\x1B[48;2;144;238;144m",
-        burnFg: "\x1B[97m"
-      },
-      dark: {
-        reset: "\x1B[0m",
-        modeBg: "\x1B[48;2;139;69;19m",
-        modeFg: "\x1B[97m",
-        sessionBg: "\x1B[48;2;64;64;64m",
-        sessionFg: "\x1B[97m",
-        dailyBg: "\x1B[48;2;45;45;45m",
-        dailyFg: "\x1B[97m",
-        blockBg: "\x1B[48;2;32;32;32m",
-        blockFg: "\x1B[96m",
-        burnLowBg: "\x1B[48;2;28;28;28m",
-        burnFg: "\x1B[97m"
+var UsageProvider = class {
+  async getSessionBlockInfo() {
+    const originalLevel = logger.level;
+    logger.level = 0;
+    try {
+      const blocks = await loadSessionBlockData({
+        mode: "auto",
+        sessionDurationHours: 5
+      });
+      const activeBlock = blocks.find((block) => block.isActive);
+      if (!activeBlock) {
+        return null;
       }
-    };
+      const now = /* @__PURE__ */ new Date();
+      const timeRemaining = Math.round(
+        (activeBlock.endTime.getTime() - now.getTime()) / (1e3 * 60)
+      );
+      const elapsed = Math.round(
+        (now.getTime() - activeBlock.startTime.getTime()) / (1e3 * 60)
+      );
+      const totalTokens = (activeBlock.tokenCounts?.inputTokens || 0) + (activeBlock.tokenCounts?.outputTokens || 0) + (activeBlock.tokenCounts?.cacheCreationInputTokens || 0) + (activeBlock.tokenCounts?.cacheReadInputTokens || 0);
+      const burnRate = elapsed > 0 ? activeBlock.costUSD / elapsed * 60 : null;
+      const tokenBurnRate = elapsed > 0 ? totalTokens / elapsed * 60 : null;
+      return {
+        cost: activeBlock.costUSD,
+        tokens: totalTokens,
+        timeRemaining: Math.max(0, timeRemaining),
+        burnRate,
+        tokenBurnRate,
+        isActive: true
+      };
+    } catch {
+      return null;
+    } finally {
+      logger.level = originalLevel;
+    }
   }
-  initializeSymbols() {
-    return {
-      right: "\uE0B0",
-      branch: "\uE0A0",
-      model: "\u26A1",
-      git_clean: "\u2713",
-      git_dirty: "\u25CF",
-      git_conflicts: "\u26A0",
-      git_ahead: "\u2191",
-      git_behind: "\u2193",
-      session_cost: "Session",
-      daily_cost: "Today"
-    };
+  async getUsageInfo(sessionId) {
+    const originalLevel = logger.level;
+    logger.level = 0;
+    try {
+      const claudePaths = getClaudePaths();
+      if (claudePaths.length === 0) {
+        return {
+          session: { cost: null, tokens: null, tokenBreakdown: null },
+          daily: { cost: 0, tokens: 0, tokenBreakdown: null }
+        };
+      }
+      const [sessionData, dailyData] = await Promise.all([
+        this.getSessionData(sessionId),
+        this.getDailyData()
+      ]);
+      return {
+        session: sessionData,
+        daily: dailyData
+      };
+    } catch {
+      return {
+        session: { cost: null, tokens: null, tokenBreakdown: null },
+        daily: { cost: 0, tokens: 0, tokenBreakdown: null }
+      };
+    } finally {
+      logger.level = originalLevel;
+    }
   }
-  extractBgColor(ansiCode) {
-    const match = ansiCode.match(/48;2;(\d+);(\d+);(\d+)/);
-    if (match) {
-      return `\x1B[38;2;${match[1]};${match[2]};${match[3]}m`;
+  async getSessionData(sessionId) {
+    try {
+      const sessionData = await loadSessionUsageById(sessionId, {
+        mode: "auto"
+      });
+      if (!sessionData) {
+        return { cost: null, tokens: null, tokenBreakdown: null };
+      }
+      const breakdown = sessionData.entries.reduce(
+        (acc, entry) => {
+          const usage = entry.message.usage;
+          return {
+            input: acc.input + usage.input_tokens,
+            output: acc.output + usage.output_tokens,
+            cacheCreation: acc.cacheCreation + (usage.cache_creation_input_tokens || 0),
+            cacheRead: acc.cacheRead + (usage.cache_read_input_tokens || 0)
+          };
+        },
+        { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 }
+      );
+      const totalTokens = breakdown.input + breakdown.output + breakdown.cacheCreation + breakdown.cacheRead;
+      return {
+        cost: sessionData.totalCost,
+        tokens: totalTokens,
+        tokenBreakdown: breakdown
+      };
+    } catch {
+      return { cost: null, tokens: null, tokenBreakdown: null };
     }
-    return ansiCode.replace("48", "38");
   }
-  renderSegment(bgColor, fgColor, text, nextBgColor) {
-    let output = `${bgColor}${fgColor} ${text} `;
-    if (nextBgColor) {
-      const arrowFgColor = this.extractBgColor(bgColor);
-      output += `${nextBgColor}${arrowFgColor}${this.symbols.right}`;
-    } else {
-      const arrowFgColor = this.extractBgColor(bgColor);
-      output += `${this.colors.colors.reset}${arrowFgColor}${this.symbols.right}${this.colors.colors.reset}`;
+  async getDailyData() {
+    try {
+      const today = /* @__PURE__ */ new Date();
+      const todayStr = today.toISOString().split("T")[0]?.replace(/-/g, "") ?? "";
+      const dailyData = await loadDailyUsageData({
+        since: todayStr,
+        until: todayStr,
+        mode: "auto"
+      });
+      if (dailyData.length === 0) {
+        return { cost: 0, tokens: 0, tokenBreakdown: null };
+      }
+      const totals = calculateTotals(dailyData);
+      const breakdown = dailyData.reduce(
+        (acc, entry) => {
+          return {
+            input: acc.input + (entry.inputTokens || 0),
+            output: acc.output + (entry.outputTokens || 0),
+            cacheCreation: acc.cacheCreation + (entry.cacheCreationTokens || 0),
+            cacheRead: acc.cacheRead + (entry.cacheReadTokens || 0)
+          };
+        },
+        { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 }
+      );
+      return {
+        cost: totals.totalCost,
+        tokens: getTotalTokens(totals),
+        tokenBreakdown: breakdown
+      };
+    } catch {
+      return { cost: 0, tokens: 0, tokenBreakdown: null };
     }
-    return output;
   }
-  sanitizePath(path2) {
-    return path2.replace(/[;&|`$(){}[\]<>'"\\]/g, "");
+};
+
+// src/lib/git-service.ts
+import { execSync } from "child_process";
+var GitService = class {
+  sanitizePath(path3) {
+    return path3.replace(/[;&|`$(){}[\]<>'"\\]/g, "");
   }
-  getGitInfo(workingDir) {
+  getGitInfo(workingDir, showSha = false) {
     try {
       const sanitizedDir = this.sanitizePath(workingDir);
-      const branch = execSync("git branch --show-current 2>/dev/null", {
-        cwd: sanitizedDir,
+      const branch = this.getBranch(sanitizedDir);
+      const status = this.getStatus(sanitizedDir);
+      const { ahead, behind } = this.getAheadBehind(sanitizedDir);
+      const sha = showSha ? this.getSha(sanitizedDir) || void 0 : void 0;
+      return {
+        branch: branch || "detached",
+        status,
+        ahead,
+        behind,
+        sha
+      };
+    } catch {
+      return null;
+    }
+  }
+  getBranch(workingDir) {
+    try {
+      return execSync("git branch --show-current 2>/dev/null", {
+        cwd: workingDir,
         encoding: "utf8",
         timeout: 1e3
-      }).trim();
+      }).trim() || null;
+    } catch {
+      return null;
+    }
+  }
+  getStatus(workingDir) {
+    try {
       const gitStatus = execSync("git status --porcelain 2>/dev/null", {
-        cwd: sanitizedDir,
+        cwd: workingDir,
         encoding: "utf8",
         timeout: 1e3
       }).trim();
-      let status = "clean";
-      if (gitStatus) {
-        if (gitStatus.includes("UU") || gitStatus.includes("AA") || gitStatus.includes("DD")) {
-          status = "conflicts";
-        } else {
-          status = "dirty";
-        }
-      }
-      let ahead = 0, behind = 0;
-      try {
-        const aheadResult = execSync(
-          "git rev-list --count @{u}..HEAD 2>/dev/null",
-          {
-            cwd: sanitizedDir,
-            encoding: "utf8",
-            timeout: 1e3
-          }
-        ).trim();
-        ahead = parseInt(aheadResult) || 0;
-        const behindResult = execSync(
-          "git rev-list --count HEAD..@{u} 2>/dev/null",
-          {
-            cwd: sanitizedDir,
-            encoding: "utf8",
-            timeout: 1e3
-          }
-        ).trim();
-        behind = parseInt(behindResult) || 0;
-      } catch {
+      if (!gitStatus) return "clean";
+      if (gitStatus.includes("UU") || gitStatus.includes("AA") || gitStatus.includes("DD")) {
+        return "conflicts";
       }
-      return { branch: branch || "detached", status, ahead, behind };
+      return "dirty";
     } catch {
-      return null;
+      return "clean";
     }
   }
-  async getCostInfo(sessionId) {
-    const originalLevel = logger.level;
-    logger.level = 0;
+  getAheadBehind(workingDir) {
     try {
-      const claudePaths = getClaudePaths();
-      if (claudePaths.length === 0) {
-        logger.level = originalLevel;
-        return { sessionCost: null, dailyCost: 0 };
-      }
-      let sessionCost = null;
-      try {
-        const sessionData = await loadSessionUsageById(sessionId, {
-          mode: "auto"
-        });
-        if (sessionData != null) {
-          sessionCost = sessionData.totalCost;
+      const aheadResult = execSync(
+        "git rev-list --count @{u}..HEAD 2>/dev/null",
+        {
+          cwd: workingDir,
+          encoding: "utf8",
+          timeout: 1e3
         }
-      } catch {
-      }
-      let dailyCost = 0;
-      try {
-        const today = /* @__PURE__ */ new Date();
-        const todayStr = today.toISOString().split("T")[0]?.replace(/-/g, "") ?? "";
-        const dailyData = await loadDailyUsageData({
-          since: todayStr,
-          until: todayStr,
-          mode: "auto"
-        });
-        if (dailyData.length > 0) {
-          const totals = calculateTotals(dailyData);
-          dailyCost = totals.totalCost;
+      ).trim();
+      const behindResult = execSync(
+        "git rev-list --count HEAD..@{u} 2>/dev/null",
+        {
+          cwd: workingDir,
+          encoding: "utf8",
+          timeout: 1e3
         }
-      } catch {
+      ).trim();
+      return {
+        ahead: parseInt(aheadResult) || 0,
+        behind: parseInt(behindResult) || 0
+      };
+    } catch {
+      return { ahead: 0, behind: 0 };
+    }
+  }
+  getSha(workingDir) {
+    try {
+      const sha = execSync("git rev-parse --short=7 HEAD 2>/dev/null", {
+        cwd: workingDir,
+        encoding: "utf8",
+        timeout: 1e3
+      }).trim();
+      return sha || null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/lib/tmux-service.ts
+import { execSync as execSync2 } from "child_process";
+var TmuxService = class {
+  getSessionId() {
+    try {
+      if (!process.env.TMUX_PANE) {
+        return null;
       }
-      logger.level = originalLevel;
-      return { sessionCost, dailyCost };
+      const sessionId = execSync2("tmux display-message -p '#S'", {
+        encoding: "utf8",
+        timeout: 1e3
+      }).trim();
+      return sessionId || null;
     } catch {
-      logger.level = originalLevel;
-      return { sessionCost: null, dailyCost: 0 };
+      return null;
     }
   }
-  formatCost(cost) {
-    if (cost === null) return "N/A";
-    if (cost < 0.01) return "<$0.01";
-    return `$${cost.toFixed(2)}`;
+  isInTmux() {
+    return !!process.env.TMUX_PANE;
   }
-  async generateStatusline(hookData, style = "colors") {
-    const modelName = hookData.model?.display_name || "Claude";
+};
+
+// src/lib/formatters.ts
+function formatCost(cost) {
+  if (cost === null) return "N/A";
+  if (cost < 0.01) return "<$0.01";
+  return `$${cost.toFixed(2)}`;
+}
+function formatTokens(tokens) {
+  if (tokens === null) return "N/A";
+  if (tokens === 0) return "0 tokens";
+  if (tokens >= 1e6) {
+    return `${(tokens / 1e6).toFixed(1)}M tokens`;
+  } else if (tokens >= 1e3) {
+    return `${(tokens / 1e3).toFixed(1)}K tokens`;
+  }
+  return `${tokens} tokens`;
+}
+function formatTokenBreakdown(breakdown) {
+  if (!breakdown) return "N/A";
+  const parts = [];
+  if (breakdown.input > 0) {
+    parts.push(`${formatTokens(breakdown.input).replace(" tokens", "")}in`);
+  }
+  if (breakdown.output > 0) {
+    parts.push(`${formatTokens(breakdown.output).replace(" tokens", "")}out`);
+  }
+  if (breakdown.cacheCreation > 0 || breakdown.cacheRead > 0) {
+    const totalCached = breakdown.cacheCreation + breakdown.cacheRead;
+    parts.push(`${formatTokens(totalCached).replace(" tokens", "")}cached`);
+  }
+  return parts.length > 0 ? parts.join(" + ") : "0 tokens";
+}
+function formatTimeRemaining(minutes) {
+  if (minutes <= 0) return "0m";
+  const hours = Math.floor(minutes / 60);
+  const mins = minutes % 60;
+  if (hours > 0) {
+    return `${hours}h${mins > 0 ? ` ${mins}m` : ""}`;
+  }
+  return `${mins}m`;
+}
+
+// src/lib/budget.ts
+function calculateBudgetPercentage(cost, budget) {
+  if (!budget || budget <= 0 || cost < 0) return null;
+  return Math.min(100, cost / budget * 100);
+}
+function getBudgetStatus(cost, budget, warningThreshold = 80) {
+  const percentage = calculateBudgetPercentage(cost, budget);
+  if (percentage === null) {
+    return {
+      percentage: null,
+      isWarning: false,
+      displayText: ""
+    };
+  }
+  const percentStr = `${percentage.toFixed(0)}%`;
+  const isWarning = percentage >= warningThreshold;
+  let displayText = "";
+  if (isWarning) {
+    displayText = ` !${percentStr}`;
+  } else if (percentage >= 50) {
+    displayText = ` +${percentStr}`;
+  } else {
+    displayText = ` ${percentStr}`;
+  }
+  return {
+    percentage,
+    isWarning,
+    displayText
+  };
+}
+
+// src/lib/segment-renderer.ts
+var SegmentRenderer = class {
+  constructor(config, symbols) {
+    this.config = config;
+    this.symbols = symbols;
+  }
+  renderDirectory(hookData, colors) {
     const currentDir = hookData.workspace?.current_dir || hookData.cwd || "/";
     const projectDir = hookData.workspace?.project_dir;
-    let dirName;
+    const dirName = this.getDisplayDirectoryName(currentDir, projectDir);
+    return {
+      text: dirName,
+      bgColor: colors.modeBg,
+      fgColor: colors.modeFg
+    };
+  }
+  renderGit(gitInfo, colors, showSha = false) {
+    if (!gitInfo) return null;
+    let gitStatusIcon = this.symbols.git_clean;
+    if (gitInfo.status === "conflicts") {
+      gitStatusIcon = this.symbols.git_conflicts;
+    } else if (gitInfo.status === "dirty") {
+      gitStatusIcon = this.symbols.git_dirty;
+    }
+    let text = `${this.symbols.branch} ${gitInfo.branch} ${gitStatusIcon}`;
+    if (gitInfo.sha && showSha) {
+      text += ` ${gitInfo.sha}`;
+    }
+    if (gitInfo.ahead > 0 && gitInfo.behind > 0) {
+      text += ` ${this.symbols.git_ahead}${gitInfo.ahead}${this.symbols.git_behind}${gitInfo.behind}`;
+    } else if (gitInfo.ahead > 0) {
+      text += ` ${this.symbols.git_ahead}${gitInfo.ahead}`;
+    } else if (gitInfo.behind > 0) {
+      text += ` ${this.symbols.git_behind}${gitInfo.behind}`;
+    }
+    return {
+      text,
+      bgColor: colors.gitBg,
+      fgColor: colors.gitFg
+    };
+  }
+  renderModel(hookData, colors) {
+    const modelName = hookData.model?.display_name || "Claude";
+    return {
+      text: `${this.symbols.model} ${modelName}`,
+      bgColor: colors.todayBg,
+      fgColor: colors.todayFg
+    };
+  }
+  renderSession(usageInfo, colors, type = "cost") {
+    const sessionBudget = this.config.budget?.session;
+    const text = `${this.symbols.session_cost} ${this.formatUsageWithBudget(
+      usageInfo.session.cost,
+      usageInfo.session.tokens,
+      usageInfo.session.tokenBreakdown,
+      type,
+      sessionBudget?.amount,
+      sessionBudget?.warningThreshold || 80
+    )}`;
+    return {
+      text,
+      bgColor: colors.sessionBg,
+      fgColor: colors.sessionFg
+    };
+  }
+  renderToday(usageInfo, colors, type = "cost") {
+    const todayBudget = this.config.budget?.today;
+    const text = `Today ${this.formatUsageWithBudget(
+      usageInfo.daily.cost,
+      usageInfo.daily.tokens,
+      usageInfo.daily.tokenBreakdown,
+      type,
+      todayBudget?.amount,
+      todayBudget?.warningThreshold || 80
+    )}`;
+    return {
+      text,
+      bgColor: colors.burnLowBg,
+      fgColor: colors.burnFg
+    };
+  }
+  renderBlock(blockInfo, colors, type = "cost") {
+    if (!blockInfo) return null;
+    const text = `${this.symbols.block_cost} ${this.formatSessionBlockInfo(blockInfo, type)}`;
+    return {
+      text,
+      bgColor: colors.blockBg,
+      fgColor: colors.blockFg
+    };
+  }
+  renderTmux(sessionId, colors) {
+    if (!sessionId) return null;
+    return {
+      text: `tmux:${sessionId}`,
+      bgColor: colors.tmuxBg,
+      fgColor: colors.tmuxFg
+    };
+  }
+  getDisplayDirectoryName(currentDir, projectDir) {
     if (projectDir && projectDir !== currentDir) {
       const projectName = projectDir.split("/").pop() || "project";
       const currentDirName = currentDir.split("/").pop() || "root";
-      dirName = currentDir.includes(projectDir) ? `${projectName}/${currentDirName}` : currentDirName;
-    } else {
-      dirName = currentDir.split("/").pop() || "root";
-    }
-    const gitInfo = this.getGitInfo(currentDir);
-    const sessionId = hookData.session_id;
-    const costInfo = await this.getCostInfo(sessionId);
-    const colors = this.colors[style];
-    let statusline = "";
-    statusline += this.renderSegment(
-      colors.modeBg,
-      colors.modeFg,
-      dirName,
-      gitInfo ? colors.sessionBg : colors.dailyBg
+      if (currentDir.includes(projectDir)) {
+        return `${projectName}/${currentDirName}`;
+      }
+      return currentDirName;
+    }
+    return currentDir.split("/").pop() || "root";
+  }
+  formatUsageDisplay(cost, tokens, tokenBreakdown, type) {
+    switch (type) {
+      case "cost":
+        return formatCost(cost);
+      case "tokens":
+        return formatTokens(tokens);
+      case "both":
+        return `${formatCost(cost)} (${formatTokens(tokens)})`;
+      case "breakdown":
+        return formatTokenBreakdown(tokenBreakdown);
+      default:
+        return formatCost(cost);
+    }
+  }
+  formatUsageWithBudget(cost, tokens, tokenBreakdown, type, budget, warningThreshold = 80) {
+    const baseDisplay = this.formatUsageDisplay(
+      cost,
+      tokens,
+      tokenBreakdown,
+      type
     );
-    if (gitInfo) {
-      let gitStatusIcon = this.symbols.git_clean;
-      if (gitInfo.status === "conflicts") {
-        gitStatusIcon = this.symbols.git_conflicts;
-      } else if (gitInfo.status === "dirty") {
-        gitStatusIcon = this.symbols.git_dirty;
+    if (budget && budget > 0 && cost !== null) {
+      const budgetStatus = getBudgetStatus(cost, budget, warningThreshold);
+      return baseDisplay + budgetStatus.displayText;
+    }
+    return baseDisplay;
+  }
+  formatSessionBlockInfo(blockInfo, type = "cost") {
+    if (!blockInfo.isActive) {
+      return "No active block";
+    }
+    const timeStr = formatTimeRemaining(blockInfo.timeRemaining);
+    if (type === "tokens") {
+      const tokensStr = formatTokens(blockInfo.tokens);
+      let result = `${tokensStr} (${timeStr} left)`;
+      if (blockInfo.tokenBurnRate !== null && blockInfo.tokenBurnRate > 0) {
+        const burnRateStr = `${formatTokens(blockInfo.tokenBurnRate)}/hr`;
+        result += ` ${burnRateStr}`;
       }
-      let branchText = `${this.symbols.branch} ${gitInfo.branch} ${gitStatusIcon}`;
-      if (gitInfo.ahead > 0 && gitInfo.behind > 0) {
-        branchText += ` ${this.symbols.git_ahead}${gitInfo.ahead}${this.symbols.git_behind}${gitInfo.behind}`;
-      } else if (gitInfo.ahead > 0) {
-        branchText += ` ${this.symbols.git_ahead}${gitInfo.ahead}`;
-      } else if (gitInfo.behind > 0) {
-        branchText += ` ${this.symbols.git_behind}${gitInfo.behind}`;
+      return result;
+    } else {
+      const costStr = formatCost(blockInfo.cost);
+      let result = `${costStr} (${timeStr} left)`;
+      if (blockInfo.burnRate !== null && blockInfo.burnRate > 0) {
+        const burnRateStr = `${formatCost(blockInfo.burnRate)}/hr`;
+        result += ` ${burnRateStr}`;
       }
-      statusline += this.renderSegment(
-        colors.sessionBg,
-        colors.sessionFg,
-        branchText,
-        colors.dailyBg
-      );
+      return result;
     }
-    statusline += this.renderSegment(
-      colors.dailyBg,
-      colors.dailyFg,
-      `${this.symbols.model} ${modelName}`,
-      colors.blockBg
-    );
-    statusline += this.renderSegment(
-      colors.blockBg,
-      colors.blockFg,
-      `${this.symbols.session_cost} ${this.formatCost(costInfo.sessionCost)}`,
-      colors.burnLowBg
+  }
+};
+
+// src/powerline.ts
+var PowerlineRenderer = class {
+  constructor(config) {
+    this.config = config;
+    this.symbols = this.initializeSymbols();
+    this.usageProvider = new UsageProvider();
+    this.gitService = new GitService();
+    this.tmuxService = new TmuxService();
+    this.segmentRenderer = new SegmentRenderer(config, this.symbols);
+  }
+  symbols;
+  usageProvider;
+  gitService;
+  tmuxService;
+  segmentRenderer;
+  async generateStatusline(hookData) {
+    const usageInfo = await this.usageProvider.getUsageInfo(
+      hookData.session_id
     );
-    statusline += this.renderSegment(
-      colors.burnLowBg,
-      colors.burnFg,
-      `${this.symbols.daily_cost} ${this.formatCost(costInfo.dailyCost)}`
+    let sessionBlockInfo = null;
+    if (this.needsSessionBlock()) {
+      sessionBlockInfo = await this.usageProvider.getSessionBlockInfo();
+    }
+    const lines = this.config.display.lines.map(
+      (lineConfig) => this.renderLine(lineConfig, hookData, usageInfo, sessionBlockInfo)
+    ).filter((line) => line.length > 0);
+    return lines.join("\n");
+  }
+  needsSessionBlock() {
+    return this.config.display.lines.some(
+      (line) => line.segments.block?.enabled
     );
-    return statusline;
+  }
+  renderLine(lineConfig, hookData, usageInfo, sessionBlockInfo) {
+    const colors = this.getThemeColors();
+    const currentDir = hookData.workspace?.current_dir || hookData.cwd || "/";
+    const segments = Object.entries(lineConfig.segments).filter(([_, config]) => config?.enabled).map(([type, config]) => ({ type, config }));
+    let line = "";
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (!segment) continue;
+      const isLast = i === segments.length - 1;
+      const nextSegment = !isLast ? segments[i + 1] : null;
+      const nextBgColor = nextSegment ? this.getSegmentBgColor(nextSegment.type, colors) : "";
+      const segmentData = this.renderSegment(
+        segment,
+        hookData,
+        usageInfo,
+        sessionBlockInfo,
+        colors,
+        currentDir
+      );
+      if (segmentData) {
+        line += this.formatSegment(
+          segmentData.bgColor,
+          segmentData.fgColor,
+          segmentData.text,
+          isLast ? void 0 : nextBgColor
+        );
+      }
+    }
+    return line;
+  }
+  renderSegment(segment, hookData, usageInfo, sessionBlockInfo, colors, currentDir) {
+    switch (segment.type) {
+      case "directory":
+        return this.segmentRenderer.renderDirectory(hookData, colors);
+      case "git":
+        const showSha = segment.config?.showSha || false;
+        const gitInfo = this.gitService.getGitInfo(currentDir, showSha);
+        return gitInfo ? this.segmentRenderer.renderGit(gitInfo, colors, showSha) : null;
+      case "model":
+        return this.segmentRenderer.renderModel(hookData, colors);
+      case "session":
+        const usageType = segment.config?.type || "cost";
+        return this.segmentRenderer.renderSession(usageInfo, colors, usageType);
+      case "today":
+        const todayType = segment.config?.type || "cost";
+        return this.segmentRenderer.renderToday(usageInfo, colors, todayType);
+      case "block":
+        const blockType = segment.config?.type || "cost";
+        return this.segmentRenderer.renderBlock(
+          sessionBlockInfo,
+          colors,
+          blockType
+        );
+      case "tmux":
+        const tmuxSessionId = this.tmuxService.getSessionId();
+        return this.segmentRenderer.renderTmux(tmuxSessionId, colors);
+      default:
+        return null;
+    }
+  }
+  initializeSymbols() {
+    return {
+      right: "\uE0B0",
+      branch: "\uE0A0",
+      model: "\u26A1",
+      git_clean: "\u2713",
+      git_dirty: "\u25CF",
+      git_conflicts: "\u26A0",
+      git_ahead: "\u2191",
+      git_behind: "\u2193",
+      session_cost: "Session",
+      daily_cost: "Today",
+      block_cost: "Block"
+    };
+  }
+  getThemeColors() {
+    const theme = this.config.theme;
+    const colorTheme = this.config.colors[theme];
+    if (!colorTheme) {
+      throw new Error(`Theme '${theme}' not found in configuration`);
+    }
+    return {
+      reset: "\x1B[0m",
+      modeBg: hexToAnsi(colorTheme.directory.bg, true),
+      modeFg: hexToAnsi(colorTheme.directory.fg, false),
+      gitBg: hexToAnsi(colorTheme.git.bg, true),
+      gitFg: hexToAnsi(colorTheme.git.fg, false),
+      sessionBg: hexToAnsi(colorTheme.session.bg, true),
+      sessionFg: hexToAnsi(colorTheme.session.fg, false),
+      todayBg: hexToAnsi(colorTheme.today.bg, true),
+      todayFg: hexToAnsi(colorTheme.today.fg, false),
+      blockBg: hexToAnsi(colorTheme.block.bg, true),
+      blockFg: hexToAnsi(colorTheme.block.fg, false),
+      burnLowBg: hexToAnsi(colorTheme.today.bg, true),
+      burnFg: hexToAnsi(colorTheme.today.fg, false),
+      tmuxBg: hexToAnsi(colorTheme.tmux.bg, true),
+      tmuxFg: hexToAnsi(colorTheme.tmux.fg, false)
+    };
+  }
+  getSegmentBgColor(segmentType, colors) {
+    switch (segmentType) {
+      case "directory":
+        return colors.modeBg;
+      case "git":
+        return colors.gitBg;
+      case "model":
+        return colors.todayBg;
+      case "session":
+        return colors.sessionBg;
+      case "today":
+        return colors.burnLowBg;
+      case "block":
+        return colors.blockBg;
+      case "tmux":
+        return colors.tmuxBg;
+      default:
+        return colors.modeBg;
+    }
+  }
+  formatSegment(bgColor, fgColor, text, nextBgColor) {
+    let output = `${bgColor}${fgColor} ${text} `;
+    if (nextBgColor) {
+      const arrowFgColor = extractBgToFg(bgColor);
+      output += `${nextBgColor}${arrowFgColor}${this.symbols.right}`;
+    } else {
+      const arrowFgColor = extractBgToFg(bgColor);
+      output += `\x1B[0m${arrowFgColor}${this.symbols.right}\x1B[0m`;
+    }
+    return output;
   }
 };
 
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  theme: "dark",
+  display: {
+    lines: [
+      {
+        segments: {
+          directory: { enabled: true },
+          git: {
+            enabled: true,
+            showSha: false
+          },
+          model: { enabled: true },
+          session: { enabled: true, type: "tokens" },
+          today: { enabled: true, type: "both" },
+          block: { enabled: false, type: "cost" },
+          tmux: { enabled: false }
+        }
+      }
+    ]
+  },
+  colors: {
+    light: {
+      directory: { bg: "#ff6b47", fg: "#ffffff" },
+      git: { bg: "#4fb3d9", fg: "#ffffff" },
+      model: { bg: "#87ceeb", fg: "#000000" },
+      session: { bg: "#da70d6", fg: "#ffffff" },
+      today: { bg: "#90ee90", fg: "#ffffff" },
+      block: { bg: "#ff8c00", fg: "#ffffff" },
+      tmux: { bg: "#32cd32", fg: "#ffffff" }
+    },
+    dark: {
+      directory: { bg: "#8b4513", fg: "#ffffff" },
+      git: { bg: "#404040", fg: "#ffffff" },
+      model: { bg: "#2d2d2d", fg: "#ffffff" },
+      session: { bg: "#202020", fg: "#00ffff" },
+      today: { bg: "#1c1c1c", fg: "#ffffff" },
+      block: { bg: "#8b4500", fg: "#ffffff" },
+      tmux: { bg: "#2f4f2f", fg: "#90ee90" }
+    },
+    custom: {
+      directory: { bg: "#ff6600", fg: "#ffffff" },
+      git: { bg: "#0066cc", fg: "#ffffff" },
+      model: { bg: "#9900cc", fg: "#ffffff" },
+      session: { bg: "#cc0099", fg: "#ffffff" },
+      today: { bg: "#00cc66", fg: "#000000" },
+      block: { bg: "#cc6600", fg: "#ffffff" },
+      tmux: { bg: "#228b22", fg: "#ffffff" }
+    }
+  },
+  budget: {
+    session: {
+      warningThreshold: 80
+    },
+    today: {
+      amount: 50,
+      warningThreshold: 80
+    }
+  }
+};
+
+// src/config/loader.ts
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (source[key] !== void 0) {
+      if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
+        result[key] = deepMerge(result[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+function findConfigFile(customPath, projectDir) {
+  if (customPath) {
+    return fs.existsSync(customPath) ? customPath : null;
+  }
+  const locations = [
+    ...projectDir ? [path.join(projectDir, ".claude-powerline.json")] : [],
+    path.join(process.cwd(), ".claude-powerline.json"),
+    path.join(os.homedir(), ".claude", "claude-powerline.json"),
+    path.join(os.homedir(), ".config", "claude-powerline", "config.json")
+  ];
+  return locations.find(fs.existsSync) || null;
+}
+function loadConfigFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(
+      `Failed to load config file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function loadEnvConfig() {
+  const config = {};
+  if (process.env.CLAUDE_POWERLINE_THEME) {
+    config.theme = process.env.CLAUDE_POWERLINE_THEME;
+  }
+  if (process.env.CLAUDE_POWERLINE_USAGE_TYPE) {
+    const usageType = process.env.CLAUDE_POWERLINE_USAGE_TYPE;
+    config.display = config.display || { lines: [] };
+    if (config.display.lines.length === 0) {
+      config.display.lines = [{ segments: {} }];
+    }
+    config.display.lines.forEach((line) => {
+      if (line.segments.session) {
+        line.segments.session.type = usageType;
+      }
+      if (line.segments.today) {
+        line.segments.today.type = usageType;
+      }
+      if (line.segments.block) {
+        line.segments.block.type = usageType === "breakdown" || usageType === "both" ? "cost" : usageType;
+      }
+    });
+  }
+  return config;
+}
+function getConfigPathFromEnv() {
+  return process.env.CLAUDE_POWERLINE_CONFIG;
+}
+function parseCLIOverrides(args) {
+  const config = {};
+  const themeIndex = args.findIndex((arg) => arg.startsWith("--theme="));
+  if (themeIndex !== -1) {
+    const theme = args[themeIndex]?.split("=")[1];
+    if (theme) {
+      config.theme = theme;
+    }
+  }
+  const dailyBudgetIndex = args.findIndex(
+    (arg) => arg.startsWith("--daily-budget=")
+  );
+  if (dailyBudgetIndex !== -1) {
+    const dailyBudget = parseFloat(args[dailyBudgetIndex]?.split("=")[1] || "");
+    if (!isNaN(dailyBudget) && dailyBudget > 0) {
+      config.budget = {
+        ...config.budget,
+        today: {
+          ...DEFAULT_CONFIG.budget?.today,
+          amount: dailyBudget
+        }
+      };
+    }
+  }
+  const sessionBudgetIndex = args.findIndex(
+    (arg) => arg.startsWith("--session-budget=")
+  );
+  if (sessionBudgetIndex !== -1) {
+    const sessionBudget = parseFloat(
+      args[sessionBudgetIndex]?.split("=")[1] || ""
+    );
+    if (!isNaN(sessionBudget) && sessionBudget > 0) {
+      config.budget = {
+        ...config.budget,
+        session: {
+          ...DEFAULT_CONFIG.budget?.session,
+          amount: sessionBudget
+        }
+      };
+    }
+  }
+  return config;
+}
+function loadConfig(options = {}) {
+  const {
+    configPath,
+    ignoreEnvVars = false,
+    cliOverrides = {},
+    projectDir
+  } = options;
+  let config = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  const configFile = findConfigFile(configPath, projectDir);
+  if (configFile) {
+    try {
+      const fileConfig = loadConfigFile(configFile);
+      config = deepMerge(config, fileConfig);
+    } catch (err) {
+      console.warn(
+        `Warning: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  if (!ignoreEnvVars) {
+    const envConfig = loadEnvConfig();
+    config = deepMerge(config, envConfig);
+  }
+  config = deepMerge(config, cliOverrides);
+  return config;
+}
+function loadConfigFromCLI(args = process.argv, projectDir) {
+  const configPathIndex = args.findIndex((arg) => arg.startsWith("--config="));
+  const configPath = configPathIndex !== -1 ? args[configPathIndex]?.split("=")[1] : getConfigPathFromEnv();
+  const cliOverrides = parseCLIOverrides(args);
+  return loadConfig({ configPath, cliOverrides, projectDir });
+}
+function getDefaultConfigJSON() {
+  return JSON.stringify(DEFAULT_CONFIG, null, 2);
+}
+
 // src/index.ts
 async function installFonts() {
   try {
-    const platform = os.platform();
+    const platform = os2.platform();
     let fontDir;
     if (platform === "darwin") {
-      fontDir = path.join(os.homedir(), "Library", "Fonts");
+      fontDir = path2.join(os2.homedir(), "Library", "Fonts");
     } else if (platform === "linux") {
-      fontDir = path.join(os.homedir(), ".local", "share", "fonts");
+      fontDir = path2.join(os2.homedir(), ".local", "share", "fonts");
     } else if (platform === "win32") {
-      fontDir = path.join(
-        os.homedir(),
+      fontDir = path2.join(
+        os2.homedir(),
         "AppData",
         "Local",
         "Microsoft",
@@ -268,29 +904,29 @@ async function installFonts() {
       console.log("Unsupported platform for font installation");
       return;
     }
-    if (!fs.existsSync(fontDir)) {
-      fs.mkdirSync(fontDir, { recursive: true });
+    if (!fs2.existsSync(fontDir)) {
+      fs2.mkdirSync(fontDir, { recursive: true });
     }
     console.log("\u{1F4E6} Installing Powerline Fonts...");
     console.log("Downloading from https://github.com/powerline/fonts");
-    const tempDir = path.join(os.tmpdir(), "powerline-fonts");
+    const tempDir = path2.join(os2.tmpdir(), "powerline-fonts");
     try {
-      if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
+      if (fs2.existsSync(tempDir)) {
+        fs2.rmSync(tempDir, { recursive: true, force: true });
       }
       console.log("Cloning powerline fonts repository...");
-      execSync2(
+      execSync3(
         "git clone --depth=1 https://github.com/powerline/fonts.git powerline-fonts",
         {
           stdio: "inherit",
-          cwd: os.tmpdir()
+          cwd: os2.tmpdir()
         }
       );
       console.log("Installing fonts...");
-      const installScript = path.join(tempDir, "install.sh");
-      if (fs.existsSync(installScript)) {
-        fs.chmodSync(installScript, 493);
-        execSync2("./install.sh", { stdio: "inherit", cwd: tempDir });
+      const installScript = path2.join(tempDir, "install.sh");
+      if (fs2.existsSync(installScript)) {
+        fs2.chmodSync(installScript, 493);
+        execSync3("./install.sh", { stdio: "inherit", cwd: tempDir });
       } else {
         throw new Error(
           "Install script not found in powerline fonts repository"
@@ -304,8 +940,8 @@ async function installFonts() {
         "Popular choices: Source Code Pro Powerline, DejaVu Sans Mono Powerline, Ubuntu Mono Powerline"
       );
     } finally {
-      if (fs.existsSync(tempDir)) {
-        fs.rmSync(tempDir, { recursive: true, force: true });
+      if (fs2.existsSync(tempDir)) {
+        fs2.rmSync(tempDir, { recursive: true, force: true });
       }
     }
   } catch (error) {
@@ -320,12 +956,16 @@ async function installFonts() {
 }
 async function main() {
   try {
-    const style = process.argv.includes("--dark") ? "dark" : "colors";
-    const showHelp = process.argv.includes("--help") || process.argv.includes("-h");
-    const installFontsFlag = process.argv.includes("--install-fonts");
+    const showHelp = process2.argv.includes("--help") || process2.argv.includes("-h");
+    const installFontsFlag = process2.argv.includes("--install-fonts");
+    const printDefaultConfig = process2.argv.includes("--print-default-config");
     if (installFontsFlag) {
       await installFonts();
-      process.exit(0);
+      process2.exit(0);
+    }
+    if (printDefaultConfig) {
+      console.log(getDefaultConfigJSON());
+      process2.exit(0);
     }
     if (showHelp) {
       console.log(`
@@ -334,9 +974,26 @@ claude-powerline - Beautiful powerline statusline for Claude Code
 Usage: claude-powerline [options]
 
 Options:
-  --dark              Use dark color scheme
-  --install-fonts     Install powerline fonts to system
-  -h, --help          Show this help
+  --theme=THEME            Set theme: light, dark, custom
+  --usage=TYPE             Usage display: cost, tokens, both, breakdown
+  --session-budget=AMOUNT  Set session budget for percentage tracking
+  --daily-budget=AMOUNT    Set daily budget for percentage tracking
+  --config=PATH            Use custom config file path
+  --install-fonts          Install powerline fonts to system
+  --print-default-config   Print default configuration template
+  -h, --help               Show this help
+
+Configuration:
+  Config files are loaded in this order (highest priority first):
+  1. CLI arguments (--theme, --usage, --config)
+  2. Environment variables (CLAUDE_POWERLINE_THEME, CLAUDE_POWERLINE_USAGE_TYPE, CLAUDE_POWERLINE_CONFIG)
+  3. ./.claude-powerline.json (project)
+  4. ~/.claude/claude-powerline.json (user)
+  5. ~/.config/claude-powerline/config.json (XDG)
+
+Creating a config file:
+  claude-powerline --print-default-config > ~/.claude/claude-powerline.json
+  claude-powerline --print-default-config > .claude-powerline.json
 
 Usage in Claude Code settings.json:
 {
@@ -347,7 +1004,7 @@ Usage in Claude Code settings.json:
   }
 }
 `);
-      process.exit(0);
+      process2.exit(0);
     }
     const stdin = await getStdin();
     if (stdin.length === 0) {
@@ -358,20 +1015,18 @@ claude-powerline - Beautiful powerline statusline for Claude Code
 Usage: claude-powerline [options]
 
 Options:
-  --dark              Use dark color scheme
-  --install-fonts     Install powerline fonts to system
-  -h, --help          Show this help
+  --theme=THEME            Set theme: light, dark, custom
+  --usage=TYPE             Usage display: cost, tokens, both, breakdown
+  --session-budget=AMOUNT  Set session budget for percentage tracking
+  --daily-budget=AMOUNT    Set daily budget for percentage tracking
+  --config=PATH            Use custom config file path
+  --install-fonts          Install powerline fonts to system
+  --print-default-config   Print default configuration template
+  -h, --help               Show this help
 
-Usage in Claude Code settings.json:
-{
-  "statusLine": {
-    "type": "command",
-    "command": "claude-powerline",
-    "padding": 0
-  }
-}
+Run 'claude-powerline --print-default-config' to see configuration options.
 `);
-      process.exit(1);
+      process2.exit(1);
     }
     let hookData;
     try {
@@ -381,15 +1036,17 @@ Usage in Claude Code settings.json:
         "Error: Invalid JSON input:",
         error instanceof Error ? error.message : String(error)
       );
-      process.exit(1);
+      process2.exit(1);
     }
-    const renderer = new PowerlineRenderer();
-    const statusline = await renderer.generateStatusline(hookData, style);
+    const projectDir = hookData.workspace?.project_dir;
+    const config = loadConfigFromCLI(process2.argv, projectDir);
+    const renderer = new PowerlineRenderer(config);
+    const statusline = await renderer.generateStatusline(hookData);
     console.log(statusline);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     console.error("Error generating statusline:", errorMessage);
-    process.exit(1);
+    process2.exit(1);
   }
 }
 main();