@owloops/claude-powerline 1.5.1 → 1.5.3

package/README.md

@@ -52,9 +52,9 @@
 
 - **Vim-style powerline** with proper arrows and segments
 - **Real-time session tracking** with costs and tokens
-- **Billing window tracking** with 5-hour block usage
+- **Billing window tracking** with 5-hour blocks and burn rates
 - **Daily usage monitoring** with budget alerts
-- **Performance metrics** with response times and burn rates
+- **Performance metrics** with response times
 - **Context monitoring** showing tokens used and auto-compact threshold
 - **Git integration** with branch, status, ahead/behind counts
 
@@ -222,7 +222,7 @@ Configuration priority (top overrides bottom):
         "segments": {
           "directory": { 
             "enabled": true,
-            "useBasename": false
+            "showBasename": false
           },
           "git": { 
             "enabled": true, 
@@ -237,7 +237,7 @@ Configuration priority (top overrides bottom):
           },
           "model": { "enabled": true },
           "session": { "enabled": true, "type": "tokens" },
-          "block": { "enabled": true, "type": "cost" },
+          "block": { "enabled": true, "type": "cost", "burnType": "cost" },
           "today": { "enabled": true, "type": "cost" },
           "context": { "enabled": true },
           "tmux": { "enabled": true },
@@ -246,9 +246,7 @@ Configuration priority (top overrides bottom):
             "showResponseTime": true,
             "showLastResponseTime": false,
             "showDuration": true,
-            "showMessageCount": true,
-            "showCostBurnRate": false,
-            "showTokenBurnRate": false
+            "showMessageCount": true
           }
         }
       }
@@ -259,7 +257,7 @@ Configuration priority (top overrides bottom):
 
 ### Segment Details
 
-- **directory**: Current working directory name (supports `useBasename` option)
+- **directory**: Current working directory name (supports `showBasename` option)
 - **git**: Branch, status, and extensive repository information (see Git Configuration below)
 - **model**: Current Claude model being used
 - **session**: Token usage and costs for current session
@@ -274,7 +272,7 @@ Configuration priority (top overrides bottom):
 ```json
 "directory": {
   "enabled": true,
-  "useBasename": false  // Show only folder name instead of full path
+  "showBasename": false  // Show only folder name instead of full path
 }
 ```
 
@@ -315,9 +313,7 @@ The metrics segment displays performance analytics from your Claude sessions:
   "showResponseTime": true,      // Average response time (`⧖ 3.2s`)
   "showLastResponseTime": false, // Last response time (`Δ 2.8s`)
   "showDuration": true,          // Session duration (`⧗ 28m`)
-  "showMessageCount": true,      // User message count (`⟐ 93`)
-  "showCostBurnRate": false,     // Cost per hour (`⟢ $1.20/h`)
-  "showTokenBurnRate": false     // Tokens per hour (`⟢ 450K/h`)
+  "showMessageCount": true       // User message count (`⟐ 93`)
 }
 ```
 
@@ -327,8 +323,6 @@ The metrics segment displays performance analytics from your Claude sessions:
 - `showLastResponseTime`: Time for the last response (shows `0.0s` while waiting)
 - `showDuration`: Total time since session started
 - `showMessageCount`: Number of user messages sent
-- `showCostBurnRate`: Spending rate per hour
-- `showTokenBurnRate`: Token consumption rate per hour
 
 ![Metrics Segment Example](images/claude-powerline-metrics.png)
 
@@ -369,6 +363,19 @@ The powerline includes three complementary usage segments:
 
 - `cost`: Show cost + time (`$0.05 (2h 30m left)`)
 - `tokens`: Show tokens + time (`1.2K tokens (2h 30m left)`)
+- `both`: Show both cost and tokens + time
+- `time`: Show only time remaining
+
+**Block burn rates** (configured with `burnType`):
+
+```json
+"block": { "enabled": true, "type": "cost", "burnType": "cost" }
+```
+
+- `cost`: Show cost burn rate (`$0.05 | $1.20/h (2h 30m left)`)
+- `tokens`: Show token burn rate (`1.2K | 450K/h (2h 30m left)`)  
+- `both`: Show both burn rates
+- `none`: Hide burn rates
 
 **Budget Configuration:**
 
@@ -415,7 +422,7 @@ To prevent segment cutoff, configure multiple lines:
       {
         "segments": {
           "session": { "enabled": true, "type": "tokens" },
-          "block": { "enabled": true, "type": "cost" },
+          "block": { "enabled": true, "type": "cost", "burnType": "cost" },
           "today": { "enabled": true, "type": "cost" },
           "context": { "enabled": true },
           "tmux": { "enabled": false },

package/dist/index.js

@@ -858,6 +858,14 @@ async function getFileModificationDate(filePath) {
     return null;
   }
 }
+function createUniqueHash(entry) {
+  const messageId = entry.message?.id || (typeof entry.raw.message === "object" && entry.raw.message !== null && "id" in entry.raw.message ? entry.raw.message.id : void 0);
+  const requestId = "requestId" in entry.raw ? entry.raw.requestId : void 0;
+  if (!messageId || !requestId) {
+    return null;
+  }
+  return `${messageId}:${requestId}`;
+}
 async function parseJsonlFile(filePath) {
   try {
     const content = await readFile(filePath, "utf-8");
@@ -890,6 +898,7 @@ async function loadEntriesFromProjects(timeFilter, fileFilter, sortFiles = false
   const entries = [];
   const claudePaths = getClaudePaths();
   const projectPaths = await findProjectPaths(claudePaths);
+  const processedHashes = /* @__PURE__ */ new Set();
   const allFiles = [];
   for (const projectPath of projectPaths) {
     try {
@@ -922,6 +931,14 @@ async function loadEntriesFromProjects(timeFilter, fileFilter, sortFiles = false
   for (const filePath of allFiles) {
     const fileEntries = await parseJsonlFile(filePath);
     for (const entry of fileEntries) {
+      const uniqueHash = createUniqueHash(entry);
+      if (uniqueHash && processedHashes.has(uniqueHash)) {
+        debug(`Skipping duplicate entry: ${uniqueHash}`);
+        continue;
+      }
+      if (uniqueHash) {
+        processedHashes.add(uniqueHash);
+      }
       if (!timeFilter || timeFilter(entry)) {
         entries.push(entry);
       }
@@ -1612,7 +1629,7 @@ var SegmentRenderer = class {
       fgColor: colors.contextFg
     };
   }
-  renderMetrics(metricsInfo, colors, config) {
+  renderMetrics(metricsInfo, colors, _blockInfo, config) {
     if (!metricsInfo) {
       return {
         text: `${this.symbols.metrics_response} new`,
@@ -1638,14 +1655,6 @@ var SegmentRenderer = class {
         `${this.symbols.metrics_messages} ${metricsInfo.messageCount}`
       );
     }
-    if (config?.showCostBurnRate && metricsInfo.costBurnRate !== null) {
-      const burnRate = metricsInfo.costBurnRate < 1 ? `${(metricsInfo.costBurnRate * 100).toFixed(0)}\xA2/h` : `$${metricsInfo.costBurnRate.toFixed(2)}/h`;
-      parts.push(`${this.symbols.metrics_burn} ${burnRate}`);
-    }
-    if (config?.showTokenBurnRate && metricsInfo.tokenBurnRate !== null) {
-      const tokenRate = formatTokens(Math.round(metricsInfo.tokenBurnRate));
-      parts.push(`${this.symbols.metrics_burn} ${tokenRate}/h`);
-    }
     if (parts.length === 0) {
       return {
         text: `${this.symbols.metrics_response} active`,
@@ -1659,25 +1668,57 @@ var SegmentRenderer = class {
       fgColor: colors.metricsFg
     };
   }
-  renderBlock(blockInfo, colors, type = "cost") {
+  renderBlock(blockInfo, colors, config) {
     let displayText;
     if (blockInfo.cost === null && blockInfo.tokens === null) {
       displayText = "No active block";
     } else {
+      const type = config?.type || "cost";
+      const burnType = config?.burnType;
       const timeStr = blockInfo.timeRemaining !== null ? (() => {
         const hours = Math.floor(blockInfo.timeRemaining / 60);
         const minutes = blockInfo.timeRemaining % 60;
         return hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
       })() : null;
+      let mainContent;
       switch (type) {
         case "cost":
-          displayText = timeStr ? `${formatCost(blockInfo.cost)} (${timeStr} left)` : formatCost(blockInfo.cost);
+          mainContent = formatCost(blockInfo.cost);
           break;
         case "tokens":
-          displayText = timeStr ? `${formatTokens(blockInfo.tokens)} (${timeStr} left)` : formatTokens(blockInfo.tokens);
+          mainContent = formatTokens(blockInfo.tokens);
+          break;
+        case "both":
+          mainContent = `${formatCost(blockInfo.cost)} / ${formatTokens(blockInfo.tokens)}`;
+          break;
+        case "time":
+          mainContent = timeStr || "N/A";
           break;
         default:
-          displayText = timeStr ? `${formatCost(blockInfo.cost)} (${timeStr} left)` : formatCost(blockInfo.cost);
+          mainContent = formatCost(blockInfo.cost);
+      }
+      let burnContent = "";
+      if (burnType && burnType !== "none") {
+        switch (burnType) {
+          case "cost":
+            const costBurnRate = blockInfo.burnRate !== null ? blockInfo.burnRate < 1 ? `${(blockInfo.burnRate * 100).toFixed(0)}\xA2/h` : `$${blockInfo.burnRate.toFixed(2)}/h` : "N/A";
+            burnContent = ` | ${costBurnRate}`;
+            break;
+          case "tokens":
+            const tokenBurnRate = blockInfo.tokenBurnRate !== null ? `${formatTokens(Math.round(blockInfo.tokenBurnRate))}/h` : "N/A";
+            burnContent = ` | ${tokenBurnRate}`;
+            break;
+          case "both":
+            const costBurn = blockInfo.burnRate !== null ? blockInfo.burnRate < 1 ? `${(blockInfo.burnRate * 100).toFixed(0)}\xA2/h` : `$${blockInfo.burnRate.toFixed(2)}/h` : "N/A";
+            const tokenBurn = blockInfo.tokenBurnRate !== null ? `${formatTokens(Math.round(blockInfo.tokenBurnRate))}/h` : "N/A";
+            burnContent = ` | ${costBurn} / ${tokenBurn}`;
+            break;
+        }
+      }
+      if (type === "time") {
+        displayText = mainContent;
+      } else {
+        displayText = timeStr ? `${mainContent}${burnContent} (${timeStr} left)` : `${mainContent}${burnContent}`;
       }
     }
     return {
@@ -1770,73 +1811,185 @@ function convertToUsageEntry(entry) {
   };
 }
 var BlockProvider = class {
-  async loadUsageEntries() {
-    const now = /* @__PURE__ */ new Date();
-    const hoursSinceMidnight = now.getHours();
-    const blockNumber = Math.floor(hoursSinceMidnight / 5);
-    const blockStart = /* @__PURE__ */ new Date();
-    blockStart.setHours(blockNumber * 5, 0, 0, 0);
-    const blockEnd = /* @__PURE__ */ new Date();
-    blockEnd.setHours((blockNumber + 1) * 5, 0, 0, 0);
-    debug(
-      `Block segment: Current block ${blockNumber} (${blockStart.toLocaleString()} - ${blockEnd.toLocaleString()})`
+  sessionDurationHours = 5;
+  floorToHour(timestamp) {
+    const floored = new Date(timestamp);
+    floored.setUTCMinutes(0, 0, 0);
+    return floored;
+  }
+  identifySessionBlocks(entries) {
+    if (entries.length === 0) return [];
+    const sessionDurationMs = this.sessionDurationHours * 60 * 60 * 1e3;
+    const blocks = [];
+    const sortedEntries = [...entries].sort(
+      (a, b) => a.timestamp.getTime() - b.timestamp.getTime()
     );
+    let currentBlockStart = null;
+    let currentBlockEntries = [];
+    for (const entry of sortedEntries) {
+      const entryTime = entry.timestamp;
+      if (currentBlockStart == null) {
+        currentBlockStart = this.floorToHour(entryTime);
+        currentBlockEntries = [entry];
+      } else {
+        const timeSinceBlockStart = entryTime.getTime() - currentBlockStart.getTime();
+        const lastEntry = currentBlockEntries[currentBlockEntries.length - 1];
+        if (lastEntry == null) {
+          continue;
+        }
+        const lastEntryTime = lastEntry.timestamp;
+        const timeSinceLastEntry = entryTime.getTime() - lastEntryTime.getTime();
+        if (timeSinceBlockStart > sessionDurationMs || timeSinceLastEntry > sessionDurationMs) {
+          blocks.push(currentBlockEntries);
+          currentBlockStart = this.floorToHour(entryTime);
+          currentBlockEntries = [entry];
+        } else {
+          currentBlockEntries.push(entry);
+        }
+      }
+    }
+    if (currentBlockStart != null && currentBlockEntries.length > 0) {
+      blocks.push(currentBlockEntries);
+    }
+    return blocks;
+  }
+  createBlockInfo(startTime, entries) {
+    const now = /* @__PURE__ */ new Date();
+    const sessionDurationMs = this.sessionDurationHours * 60 * 60 * 1e3;
+    const endTime = new Date(startTime.getTime() + sessionDurationMs);
+    const lastEntry = entries[entries.length - 1];
+    const actualEndTime = lastEntry != null ? lastEntry.timestamp : startTime;
+    const isActive = now.getTime() - actualEndTime.getTime() < sessionDurationMs && now < endTime;
+    return { block: entries, isActive };
+  }
+  findActiveBlock(blocks) {
+    for (let i = blocks.length - 1; i >= 0; i--) {
+      const block = blocks[i];
+      if (!block || block.length === 0) continue;
+      const firstEntry = block[0];
+      if (!firstEntry) continue;
+      const blockStartTime = this.floorToHour(firstEntry.timestamp);
+      const blockInfo = this.createBlockInfo(blockStartTime, block);
+      if (blockInfo.isActive) {
+        return blockInfo.block;
+      }
+    }
+    return null;
+  }
+  async loadUsageEntries() {
+    debug(`Block segment: Loading entries for dynamic session blocks`);
+    const dayAgo = /* @__PURE__ */ new Date();
+    dayAgo.setDate(dayAgo.getDate() - 1);
     const fileFilter = (_filePath, modTime) => {
-      return modTime >= blockStart;
+      return modTime >= dayAgo;
     };
     const parsedEntries = await loadEntriesFromProjects(
       void 0,
       fileFilter,
       true
     );
-    const usageEntries = [];
-    let entriesInBlock = 0;
+    const allUsageEntries = [];
     for (const entry of parsedEntries) {
-      if (entry.message?.usage && entry.timestamp >= blockStart && entry.timestamp < blockEnd) {
+      if (entry.message?.usage) {
         const usageEntry = convertToUsageEntry(entry);
         if (!usageEntry.costUSD && entry.raw) {
           usageEntry.costUSD = await PricingService.calculateCostForEntry(
             entry.raw
           );
         }
-        usageEntries.push(usageEntry);
-        entriesInBlock++;
+        allUsageEntries.push(usageEntry);
+      }
+    }
+    const sessionBlocks = this.identifySessionBlocks(allUsageEntries);
+    debug(`Block segment: Found ${sessionBlocks.length} session blocks`);
+    const activeBlock = this.findActiveBlock(sessionBlocks);
+    if (activeBlock && activeBlock.length > 0) {
+      debug(
+        `Block segment: Found active block with ${activeBlock.length} entries`
+      );
+      const blockStart = activeBlock[0];
+      const blockEnd = activeBlock[activeBlock.length - 1];
+      if (blockStart && blockEnd) {
+        debug(
+          `Block segment: Active block from ${blockStart.timestamp.toISOString()} to ${blockEnd.timestamp.toISOString()}`
+        );
       }
+      return activeBlock;
+    } else {
+      debug(`Block segment: No active block found`);
+      return [];
     }
-    debug(`Block segment: Found ${entriesInBlock} entries in current block`);
-    return usageEntries;
   }
   async getActiveBlockInfo() {
     try {
       const entries = await this.loadUsageEntries();
       if (entries.length === 0) {
         debug("Block segment: No entries in current block");
-        return { cost: null, tokens: null, timeRemaining: null };
+        return {
+          cost: null,
+          tokens: null,
+          timeRemaining: null,
+          burnRate: null,
+          tokenBurnRate: null
+        };
       }
       const totalCost = entries.reduce((sum, entry) => sum + entry.costUSD, 0);
       const totalTokens = entries.reduce((sum, entry) => {
         return sum + entry.usage.inputTokens + entry.usage.outputTokens + entry.usage.cacheCreationInputTokens + entry.usage.cacheReadInputTokens;
       }, 0);
       const now = /* @__PURE__ */ new Date();
-      const hoursSinceMidnight = now.getHours();
-      const blockNumber = Math.floor(hoursSinceMidnight / 5);
-      const blockEnd = /* @__PURE__ */ new Date();
-      blockEnd.setHours((blockNumber + 1) * 5, 0, 0, 0);
-      const timeRemaining = Math.max(
-        0,
-        Math.round((blockEnd.getTime() - now.getTime()) / (1e3 * 60))
-      );
+      let timeRemaining = null;
+      if (entries.length > 0) {
+        const firstEntry = entries[0];
+        if (firstEntry) {
+          const sessionDurationMs = this.sessionDurationHours * 60 * 60 * 1e3;
+          const blockStartTime = this.floorToHour(firstEntry.timestamp);
+          const sessionEndTime = new Date(
+            blockStartTime.getTime() + sessionDurationMs
+          );
+          timeRemaining = Math.max(
+            0,
+            Math.round((sessionEndTime.getTime() - now.getTime()) / (1e3 * 60))
+          );
+        }
+      }
+      let burnRate = null;
+      let tokenBurnRate = null;
+      if (entries.length >= 1 && (totalCost > 0 || totalTokens > 0)) {
+        const timestamps = entries.map((entry) => entry.timestamp).sort((a, b) => a.getTime() - b.getTime());
+        const firstEntry = timestamps[0];
+        const lastEntry = timestamps[timestamps.length - 1];
+        if (firstEntry && lastEntry) {
+          const durationMinutes = (lastEntry.getTime() - firstEntry.getTime()) / (1e3 * 60);
+          if (durationMinutes > 0) {
+            if (totalCost > 0) {
+              burnRate = totalCost / durationMinutes * 60;
+            }
+            if (totalTokens > 0) {
+              tokenBurnRate = totalTokens / durationMinutes * 60;
+            }
+          }
+        }
+      }
       debug(
-        `Block segment: $${totalCost.toFixed(2)}, ${totalTokens} tokens, ${timeRemaining}m remaining`
+        `Block segment: $${totalCost.toFixed(2)}, ${totalTokens} tokens, ${timeRemaining}m remaining, burn rate: ${burnRate ? "$" + burnRate.toFixed(2) + "/hr" : "N/A"}`
       );
       return {
         cost: totalCost,
         tokens: totalTokens,
-        timeRemaining
+        timeRemaining,
+        burnRate,
+        tokenBurnRate
       };
     } catch (error) {
       debug("Error getting active block info:", error);
-      return { cost: null, tokens: null, timeRemaining: null };
+      return {
+        cost: null,
+        tokens: null,
+        timeRemaining: null,
+        burnRate: null,
+        tokenBurnRate: null
+      };
     }
   }
 };
@@ -1848,10 +2001,6 @@ function formatDate(date) {
   const day = String(date.getDate()).padStart(2, "0");
   return `${year}-${month}-${day}`;
 }
-function isToday(date) {
-  const today = /* @__PURE__ */ new Date();
-  return formatDate(date) === formatDate(today);
-}
 function getTotalTokens(usage) {
   return usage.inputTokens + usage.outputTokens + usage.cacheCreationInputTokens + usage.cacheReadInputTokens;
 }
@@ -1872,13 +2021,13 @@ var TodayProvider = class {
   cache = /* @__PURE__ */ new Map();
   CACHE_TTL = 3e5;
   async loadTodayEntries() {
-    const todayStart = /* @__PURE__ */ new Date();
-    todayStart.setHours(0, 0, 0, 0);
-    debug(
-      `Today segment: Loading entries since ${todayStart.toLocaleString()}`
-    );
+    const today = /* @__PURE__ */ new Date();
+    const todayDateString = formatDate(today);
+    debug(`Today segment: Loading entries for date ${todayDateString}`);
+    const weekAgo = /* @__PURE__ */ new Date();
+    weekAgo.setDate(weekAgo.getDate() - 7);
     const fileFilter = (_filePath, modTime) => {
-      return modTime >= todayStart;
+      return modTime >= weekAgo;
     };
     const parsedEntries = await loadEntriesFromProjects(
       void 0,
@@ -1888,11 +2037,8 @@ var TodayProvider = class {
     const todayEntries = [];
     let entriesFound = 0;
     for (const entry of parsedEntries) {
-      if (entry.timestamp < todayStart) {
-        debug(`Today segment: Early exit at ${entry.timestamp.toISOString()}`);
-        break;
-      }
-      if (entry.message?.usage && isToday(entry.timestamp)) {
+      const entryDateString = formatDate(entry.timestamp);
+      if (entryDateString === todayDateString && entry.message?.usage) {
         const todayEntry = convertToTodayEntry(entry);
         if (!todayEntry.costUSD && entry.raw) {
           todayEntry.costUSD = await PricingService.calculateCostForEntry(
@@ -1903,7 +2049,9 @@ var TodayProvider = class {
         entriesFound++;
       }
     }
-    debug(`Today segment: Found ${entriesFound} entries for today`);
+    debug(
+      `Today segment: Found ${entriesFound} entries for today (${todayDateString})`
+    );
     return todayEntries;
   }
   async getTodayEntries() {
@@ -2131,12 +2279,13 @@ var PowerlineRenderer = class {
         return this.segmentRenderer.renderMetrics(
           metricsInfo,
           colors,
+          blockInfo,
           metricsConfig
         );
       case "block":
         if (!blockInfo) return null;
-        const blockType = segment.config?.type || "cost";
-        return this.segmentRenderer.renderBlock(blockInfo, colors, blockType);
+        const blockConfig = segment.config;
+        return this.segmentRenderer.renderBlock(blockInfo, colors, blockConfig);
       case "today":
         if (!todayInfo) return null;
         const todayType = segment.config?.type || "cost";
@@ -2282,7 +2431,7 @@ var DEFAULT_CONFIG = {
           model: { enabled: true },
           session: { enabled: true, type: "tokens" },
           today: { enabled: false, type: "cost" },
-          block: { enabled: true, type: "cost" },
+          block: { enabled: true, type: "cost", burnType: "cost" },
           tmux: { enabled: false },
           context: { enabled: true },
           metrics: {
@@ -2290,9 +2439,7 @@ var DEFAULT_CONFIG = {
             showResponseTime: true,
             showLastResponseTime: false,
             showDuration: true,
-            showMessageCount: true,
-            showCostBurnRate: false,
-            showTokenBurnRate: false
+            showMessageCount: true
           }
         }
       }