@owloops/claude-powerline 1.24.4 → 1.25.1

package/src/segments/session.ts

@@ -0,0 +1,207 @@
+import { debug } from "../utils/logger";
+import { PricingService } from "./pricing";
+import {
+  findTranscriptFile,
+  findAgentTranscripts,
+  parseJsonlFile,
+  type ParsedEntry,
+  type ClaudeHookData,
+} from "../utils/claude";
+import { dirname } from "node:path";
+
+export interface SessionUsageEntry {
+  timestamp: string;
+  message: {
+    usage: {
+      input_tokens: number;
+      output_tokens: number;
+      cache_creation_input_tokens?: number;
+      cache_read_input_tokens?: number;
+    };
+  };
+  costUSD?: number;
+}
+
+export interface SessionUsage {
+  totalCost: number;
+  entries: SessionUsageEntry[];
+}
+
+export interface TokenBreakdown {
+  input: number;
+  output: number;
+  cacheCreation: number;
+  cacheRead: number;
+}
+
+export interface SessionInfo {
+  cost: number | null;
+  calculatedCost: number | null;
+  officialCost: number | null;
+  tokens: number | null;
+  tokenBreakdown: TokenBreakdown | null;
+}
+
+export interface UsageInfo {
+  session: SessionInfo;
+}
+
+function convertToSessionEntry(entry: ParsedEntry): SessionUsageEntry {
+  return {
+    timestamp: entry.timestamp.toISOString(),
+    message: {
+      usage: {
+        input_tokens: entry.message?.usage?.input_tokens || 0,
+        output_tokens: entry.message?.usage?.output_tokens || 0,
+        cache_creation_input_tokens:
+          entry.message?.usage?.cache_creation_input_tokens,
+        cache_read_input_tokens: entry.message?.usage?.cache_read_input_tokens,
+      },
+    },
+    costUSD: entry.costUSD,
+  };
+}
+
+export class SessionProvider {
+  async getSessionUsage(sessionId: string): Promise<SessionUsage | null> {
+    try {
+      const transcriptPath = await findTranscriptFile(sessionId);
+      if (!transcriptPath) {
+        debug(`No transcript found for session: ${sessionId}`);
+        return null;
+      }
+
+      debug(`Found transcript at: ${transcriptPath}`);
+
+      const parsedEntries = await parseJsonlFile(transcriptPath);
+      const projectPath = dirname(transcriptPath);
+      const agentTranscripts = await findAgentTranscripts(
+        sessionId,
+        projectPath,
+      );
+
+      debug(`Found ${agentTranscripts.length} agent transcripts for session`);
+
+      for (const agentPath of agentTranscripts) {
+        const agentEntries = await parseJsonlFile(agentPath);
+        parsedEntries.push(...agentEntries);
+      }
+
+      if (parsedEntries.length === 0) {
+        return { totalCost: 0, entries: [] };
+      }
+
+      const entries: SessionUsageEntry[] = [];
+      let totalCost = 0;
+
+      for (const entry of parsedEntries) {
+        if (entry.message?.usage) {
+          const sessionEntry = convertToSessionEntry(entry);
+
+          if (sessionEntry.costUSD !== undefined) {
+            totalCost += sessionEntry.costUSD;
+          } else {
+            const cost = await PricingService.calculateCostForEntry(entry.raw);
+            sessionEntry.costUSD = cost;
+            totalCost += cost;
+          }
+
+          entries.push(sessionEntry);
+        }
+      }
+
+      debug(
+        `Parsed ${entries.length} usage entries, total cost: $${totalCost.toFixed(4)}`,
+      );
+      return { totalCost, entries };
+    } catch (error) {
+      debug(`Error reading session usage for ${sessionId}:`, error);
+      return null;
+    }
+  }
+
+  calculateTokenBreakdown(entries: SessionUsageEntry[]): TokenBreakdown {
+    return entries.reduce(
+      (breakdown, entry) => ({
+        input: breakdown.input + (entry.message.usage.input_tokens || 0),
+        output: breakdown.output + (entry.message.usage.output_tokens || 0),
+        cacheCreation:
+          breakdown.cacheCreation +
+          (entry.message.usage.cache_creation_input_tokens || 0),
+        cacheRead:
+          breakdown.cacheRead +
+          (entry.message.usage.cache_read_input_tokens || 0),
+      }),
+      { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 },
+    );
+  }
+
+  async getSessionInfo(
+    sessionId: string,
+    hookData?: ClaudeHookData,
+  ): Promise<SessionInfo> {
+    const sessionUsage = await this.getSessionUsage(sessionId);
+
+    if (!sessionUsage || sessionUsage.entries.length === 0) {
+      return {
+        cost: null,
+        calculatedCost: null,
+        officialCost: null,
+        tokens: null,
+        tokenBreakdown: null,
+      };
+    }
+
+    const tokenBreakdown = this.calculateTokenBreakdown(sessionUsage.entries);
+    const totalTokens =
+      tokenBreakdown.input +
+      tokenBreakdown.output +
+      tokenBreakdown.cacheCreation +
+      tokenBreakdown.cacheRead;
+
+    const calculatedCost = sessionUsage.totalCost;
+    const hookDataCost = hookData?.cost?.total_cost_usd ?? null;
+    const cost = calculatedCost ?? hookDataCost;
+
+    return {
+      cost,
+      calculatedCost,
+      officialCost: hookDataCost,
+      tokens: totalTokens,
+      tokenBreakdown,
+    };
+  }
+}
+
+export class UsageProvider {
+  private sessionProvider = new SessionProvider();
+
+  async getUsageInfo(
+    sessionId: string,
+    hookData?: ClaudeHookData,
+  ): Promise<UsageInfo> {
+    try {
+      debug(`Starting usage info retrieval for session: ${sessionId}`);
+
+      const sessionInfo = await this.sessionProvider.getSessionInfo(
+        sessionId,
+        hookData,
+      );
+
+      return {
+        session: sessionInfo,
+      };
+    } catch (error) {
+      debug(`Error getting usage info for session ${sessionId}:`, error);
+      return {
+        session: {
+          cost: null,
+          calculatedCost: null,
+          officialCost: null,
+          tokens: null,
+          tokenBreakdown: null,
+        },
+      };
+    }
+  }
+}

package/src/segments/tmux.ts

@@ -0,0 +1,35 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { debug } from "../utils/logger";
+
+const execAsync = promisify(exec);
+
+export class TmuxService {
+  async getSessionId(): Promise<string | null> {
+    try {
+      if (!process.env.TMUX_PANE) {
+        debug(`TMUX_PANE not set, not in tmux session`);
+        return null;
+      }
+
+      debug(`Getting tmux session ID, TMUX_PANE: ${process.env.TMUX_PANE}`);
+
+      const result = await execAsync("tmux display-message -p '#S'", {
+        encoding: "utf8",
+        timeout: 1000,
+      });
+      const sessionId = result.stdout.trim();
+
+      debug(`Tmux session ID: ${sessionId || "empty"}`);
+
+      return sessionId || null;
+    } catch (error) {
+      debug(`Error getting tmux session ID:`, error);
+      return null;
+    }
+  }
+
+  isInTmux(): boolean {
+    return !!process.env.TMUX_PANE;
+  }
+}

package/src/segments/today.ts

@@ -0,0 +1,191 @@
+import type { ParsedEntry } from "../utils/claude";
+import type { TokenBreakdown } from "./session";
+
+import { debug } from "../utils/logger";
+import { PricingService } from "./pricing";
+import { CacheManager } from "../utils/cache";
+import { loadEntriesFromProjects } from "../utils/claude";
+
+export interface TodayUsageEntry {
+  timestamp: Date;
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
+  };
+  costUSD: number;
+  model: string;
+}
+
+export interface TodayInfo {
+  cost: number | null;
+  tokens: number | null;
+  tokenBreakdown: TokenBreakdown | null;
+  date: string;
+}
+
+function formatDate(date: Date): string {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+
+function getTotalTokens(usage: TodayUsageEntry["usage"]): number {
+  return (
+    usage.inputTokens +
+    usage.outputTokens +
+    usage.cacheCreationInputTokens +
+    usage.cacheReadInputTokens
+  );
+}
+
+function convertToTodayEntry(entry: ParsedEntry): TodayUsageEntry {
+  return {
+    timestamp: entry.timestamp,
+    usage: {
+      inputTokens: entry.message?.usage?.input_tokens || 0,
+      outputTokens: entry.message?.usage?.output_tokens || 0,
+      cacheCreationInputTokens:
+        entry.message?.usage?.cache_creation_input_tokens || 0,
+      cacheReadInputTokens: entry.message?.usage?.cache_read_input_tokens || 0,
+    },
+    costUSD: entry.costUSD || 0,
+    model: entry.message?.model || "unknown",
+  };
+}
+
+export class TodayProvider {
+  private async loadTodayEntries(): Promise<TodayUsageEntry[]> {
+    const today = new Date();
+    const todayDateString = formatDate(today);
+
+    debug(`Today segment: Loading entries for date ${todayDateString}`);
+
+    const latestMtime = await CacheManager.getLatestTranscriptMtime();
+
+    const sharedCached = (await CacheManager.getUsageCache(
+      "today",
+      latestMtime,
+    )) as TodayUsageEntry[] | null;
+    if (sharedCached) {
+      debug("Using shared today usage cache");
+      return sharedCached;
+    }
+
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    yesterday.setHours(0, 0, 0, 0);
+
+    const fileFilter = (_filePath: string, modTime: Date): boolean => {
+      return modTime >= yesterday;
+    };
+
+    const todayMidnight = new Date();
+    todayMidnight.setHours(0, 0, 0, 0);
+
+    const timeFilter = (entry: ParsedEntry): boolean => {
+      return entry.timestamp >= todayMidnight;
+    };
+
+    const parsedEntries = await loadEntriesFromProjects(
+      timeFilter,
+      fileFilter,
+      true,
+    );
+    const todayEntries: TodayUsageEntry[] = [];
+
+    let entriesFound = 0;
+
+    for (const entry of parsedEntries) {
+      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(
+            entry.raw,
+          );
+        }
+
+        todayEntries.push(todayEntry);
+        entriesFound++;
+      }
+    }
+
+    debug(
+      `Today segment: Found ${entriesFound} entries for today (${todayDateString})`,
+    );
+
+    await CacheManager.setUsageCache("today", todayEntries, latestMtime);
+
+    return todayEntries;
+  }
+
+  private async getTodayEntries(): Promise<TodayUsageEntry[]> {
+    try {
+      return await this.loadTodayEntries();
+    } catch (error) {
+      debug("Error loading today's entries:", error);
+      return [];
+    }
+  }
+
+  async getTodayInfo(): Promise<TodayInfo> {
+    try {
+      const entries = await this.getTodayEntries();
+
+      if (entries.length === 0) {
+        return {
+          cost: null,
+          tokens: null,
+          tokenBreakdown: null,
+          date: formatDate(new Date()),
+        };
+      }
+
+      const totalCost = entries.reduce((sum, entry) => sum + entry.costUSD, 0);
+      const totalTokens = entries.reduce(
+        (sum, entry) => sum + getTotalTokens(entry.usage),
+        0,
+      );
+
+      const tokenBreakdown = entries.reduce(
+        (breakdown, entry) => ({
+          input: breakdown.input + entry.usage.inputTokens,
+          output: breakdown.output + entry.usage.outputTokens,
+          cacheCreation:
+            breakdown.cacheCreation + entry.usage.cacheCreationInputTokens,
+          cacheRead: breakdown.cacheRead + entry.usage.cacheReadInputTokens,
+        }),
+        {
+          input: 0,
+          output: 0,
+          cacheCreation: 0,
+          cacheRead: 0,
+        },
+      );
+
+      debug(
+        `Today segment: $${totalCost.toFixed(2)}, ${totalTokens} tokens total`,
+      );
+
+      return {
+        cost: totalCost,
+        tokens: totalTokens,
+        tokenBreakdown,
+        date: formatDate(new Date()),
+      };
+    } catch (error) {
+      debug("Error getting today's info:", error);
+      return {
+        cost: null,
+        tokens: null,
+        tokenBreakdown: null,
+        date: formatDate(new Date()),
+      };
+    }
+  }
+}

package/src/themes/dark.ts

@@ -0,0 +1,52 @@
+import type { ColorTheme } from "./index";
+
+export const darkTheme: ColorTheme = {
+  directory: { bg: "#8b4513", fg: "#ffffff" },
+  git: { bg: "#404040", fg: "#ffffff" },
+  model: { bg: "#2d2d2d", fg: "#ffffff" },
+  session: { bg: "#202020", fg: "#00ffff" },
+  block: { bg: "#2a2a2a", fg: "#87ceeb" },
+  today: { bg: "#1a1a1a", fg: "#98fb98" },
+  tmux: { bg: "#2f4f2f", fg: "#90ee90" },
+  context: { bg: "#4a5568", fg: "#cbd5e0" },
+  contextWarning: { bg: "#92400e", fg: "#fbbf24" },
+  contextCritical: { bg: "#991b1b", fg: "#fca5a5" },
+  metrics: { bg: "#374151", fg: "#d1d5db" },
+  version: { bg: "#3a3a4a", fg: "#b8b8d0" },
+  env: { bg: "#2d2d3d", fg: "#d0a0d0" },
+  weekly: { bg: "#2a2a3a", fg: "#a0c4e8" },
+};
+
+export const darkAnsi256Theme: ColorTheme = {
+  directory: { bg: "#af5f00", fg: "#ffffff" },
+  git: { bg: "#444444", fg: "#ffffff" },
+  model: { bg: "#3a3a3a", fg: "#ffffff" },
+  session: { bg: "#262626", fg: "#00ffff" },
+  block: { bg: "#303030", fg: "#87ceeb" },
+  today: { bg: "#1c1c1c", fg: "#87ff87" },
+  tmux: { bg: "#444444", fg: "#87ff87" },
+  context: { bg: "#585858", fg: "#d0d0d0" },
+  contextWarning: { bg: "#af5f00", fg: "#ffaf00" },
+  contextCritical: { bg: "#870000", fg: "#ff8787" },
+  metrics: { bg: "#4e4e4e", fg: "#d0d0d0" },
+  version: { bg: "#444444", fg: "#d7afff" },
+  env: { bg: "#3a3a3a", fg: "#d787d7" },
+  weekly: { bg: "#303030", fg: "#87afd7" },
+};
+
+export const darkAnsiTheme: ColorTheme = {
+  directory: { bg: "#d75f00", fg: "#ffffff" },
+  git: { bg: "#585858", fg: "#ffffff" },
+  model: { bg: "#444444", fg: "#ffffff" },
+  session: { bg: "#303030", fg: "#00ffff" },
+  block: { bg: "#3a3a3a", fg: "#5fafff" },
+  today: { bg: "#262626", fg: "#00ff00" },
+  tmux: { bg: "#585858", fg: "#00ff00" },
+  context: { bg: "#808080", fg: "#ffffff" },
+  contextWarning: { bg: "#d75f00", fg: "#ffff00" },
+  contextCritical: { bg: "#af0000", fg: "#ff0000" },
+  metrics: { bg: "#666666", fg: "#ffffff" },
+  version: { bg: "#585858", fg: "#af87ff" },
+  env: { bg: "#444444", fg: "#ff87ff" },
+  weekly: { bg: "#3a3a3a", fg: "#5fafff" },
+};

package/src/themes/gruvbox.ts

@@ -0,0 +1,52 @@
+import type { ColorTheme } from "./index";
+
+export const gruvboxTheme: ColorTheme = {
+  directory: { bg: "#504945", fg: "#ebdbb2" },
+  git: { bg: "#3c3836", fg: "#b8bb26" },
+  model: { bg: "#665c54", fg: "#83a598" },
+  session: { bg: "#282828", fg: "#8ec07c" },
+  block: { bg: "#3c3836", fg: "#83a598" },
+  today: { bg: "#282828", fg: "#fabd2f" },
+  tmux: { bg: "#282828", fg: "#fe8019" },
+  context: { bg: "#458588", fg: "#ebdbb2" },
+  contextWarning: { bg: "#d79921", fg: "#282828" },
+  contextCritical: { bg: "#cc241d", fg: "#ebdbb2" },
+  metrics: { bg: "#d3869b", fg: "#282828" },
+  version: { bg: "#504945", fg: "#8ec07c" },
+  env: { bg: "#3c3836", fg: "#d3869b" },
+  weekly: { bg: "#3c3836", fg: "#8ec07c" },
+};
+
+export const gruvboxAnsi256Theme: ColorTheme = {
+  directory: { bg: "#585858", fg: "#ffffaf" },
+  git: { bg: "#444444", fg: "#afaf00" },
+  model: { bg: "#6c6c6c", fg: "#87afaf" },
+  session: { bg: "#303030", fg: "#87af87" },
+  block: { bg: "#444444", fg: "#87afaf" },
+  today: { bg: "#303030", fg: "#ffaf00" },
+  tmux: { bg: "#303030", fg: "#ff8700" },
+  context: { bg: "#5f8787", fg: "#ffffaf" },
+  contextWarning: { bg: "#d7af00", fg: "#303030" },
+  contextCritical: { bg: "#d70000", fg: "#ffffaf" },
+  metrics: { bg: "#d787af", fg: "#303030" },
+  version: { bg: "#585858", fg: "#87af87" },
+  env: { bg: "#444444", fg: "#d787af" },
+  weekly: { bg: "#444444", fg: "#87af87" },
+};
+
+export const gruvboxAnsiTheme: ColorTheme = {
+  directory: { bg: "#808080", fg: "#ffff00" },
+  git: { bg: "#585858", fg: "#00ff00" },
+  model: { bg: "#808080", fg: "#00afff" },
+  session: { bg: "#444444", fg: "#00d787" },
+  block: { bg: "#585858", fg: "#00afff" },
+  today: { bg: "#444444", fg: "#ffaf00" },
+  tmux: { bg: "#444444", fg: "#ff8700" },
+  context: { bg: "#008787", fg: "#ffffff" },
+  contextWarning: { bg: "#d7af00", fg: "#000000" },
+  contextCritical: { bg: "#d70000", fg: "#ffffff" },
+  metrics: { bg: "#ff87af", fg: "#444444" },
+  version: { bg: "#808080", fg: "#00d787" },
+  env: { bg: "#585858", fg: "#ff87af" },
+  weekly: { bg: "#585858", fg: "#00d787" },
+};

package/src/themes/index.ts

@@ -0,0 +1,131 @@
+import { darkTheme, darkAnsi256Theme, darkAnsiTheme } from "./dark";
+import { lightTheme, lightAnsi256Theme, lightAnsiTheme } from "./light";
+import { nordTheme, nordAnsi256Theme, nordAnsiTheme } from "./nord";
+import {
+  tokyoNightTheme,
+  tokyoNightAnsi256Theme,
+  tokyoNightAnsiTheme,
+} from "./tokyo-night";
+import {
+  rosePineTheme,
+  rosePineAnsi256Theme,
+  rosePineAnsiTheme,
+} from "./rose-pine";
+import { gruvboxTheme, gruvboxAnsi256Theme, gruvboxAnsiTheme } from "./gruvbox";
+
+export interface SegmentColor {
+  bg: string;
+  fg: string;
+}
+
+export interface ColorTheme {
+  directory: SegmentColor;
+  git: SegmentColor;
+  model: SegmentColor;
+  session: SegmentColor;
+  block: SegmentColor;
+  today: SegmentColor;
+  tmux: SegmentColor;
+  context: SegmentColor;
+  contextWarning: SegmentColor;
+  contextCritical: SegmentColor;
+  metrics: SegmentColor;
+  version: SegmentColor;
+  env: SegmentColor;
+  weekly: SegmentColor;
+}
+
+export interface PowerlineColors {
+  reset: string;
+  modeBg: string;
+  modeFg: string;
+  gitBg: string;
+  gitFg: string;
+  modelBg: string;
+  modelFg: string;
+  sessionBg: string;
+  sessionFg: string;
+  blockBg: string;
+  blockFg: string;
+  todayBg: string;
+  todayFg: string;
+  tmuxBg: string;
+  tmuxFg: string;
+  contextBg: string;
+  contextFg: string;
+  contextWarningBg: string;
+  contextWarningFg: string;
+  contextCriticalBg: string;
+  contextCriticalFg: string;
+  metricsBg: string;
+  metricsFg: string;
+  versionBg: string;
+  versionFg: string;
+  envBg: string;
+  envFg: string;
+  weeklyBg: string;
+  weeklyFg: string;
+  partFg: Record<string, string>;
+}
+
+export const BUILT_IN_THEMES: Record<string, ColorTheme> = {
+  dark: darkTheme,
+  "dark-ansi256": darkAnsi256Theme,
+  "dark-ansi": darkAnsiTheme,
+  light: lightTheme,
+  "light-ansi256": lightAnsi256Theme,
+  "light-ansi": lightAnsiTheme,
+  nord: nordTheme,
+  "nord-ansi256": nordAnsi256Theme,
+  "nord-ansi": nordAnsiTheme,
+  "tokyo-night": tokyoNightTheme,
+  "tokyo-night-ansi256": tokyoNightAnsi256Theme,
+  "tokyo-night-ansi": tokyoNightAnsiTheme,
+  "rose-pine": rosePineTheme,
+  "rose-pine-ansi256": rosePineAnsi256Theme,
+  "rose-pine-ansi": rosePineAnsiTheme,
+  gruvbox: gruvboxTheme,
+  "gruvbox-ansi256": gruvboxAnsi256Theme,
+  "gruvbox-ansi": gruvboxAnsiTheme,
+};
+
+export function getTheme(
+  themeName: string,
+  colorSupport?: "none" | "ansi" | "ansi256" | "truecolor",
+): ColorTheme | null {
+  const baseTheme = BUILT_IN_THEMES[themeName];
+  if (!baseTheme) return null;
+
+  if (colorSupport === "none" || colorSupport === "ansi") {
+    const ansiVariant = BUILT_IN_THEMES[`${themeName}-ansi`];
+    if (ansiVariant) return ansiVariant;
+  }
+
+  if (colorSupport === "ansi256") {
+    const ansi256Variant = BUILT_IN_THEMES[`${themeName}-ansi256`];
+    if (ansi256Variant) return ansi256Variant;
+  }
+
+  return baseTheme;
+}
+
+export {
+  darkTheme,
+  darkAnsi256Theme,
+  darkAnsiTheme,
+  lightTheme,
+  lightAnsi256Theme,
+  lightAnsiTheme,
+  nordTheme,
+  nordAnsi256Theme,
+  nordAnsiTheme,
+  tokyoNightTheme,
+  tokyoNightAnsi256Theme,
+  tokyoNightAnsiTheme,
+  rosePineTheme,
+  rosePineAnsi256Theme,
+  rosePineAnsiTheme,
+  gruvboxTheme,
+  gruvboxAnsi256Theme,
+  gruvboxAnsiTheme,
+};