@owloops/claude-powerline 1.24.3 → 1.25.0

package/src/tui/types.ts

@@ -0,0 +1,181 @@
+import type { UsageInfo } from "../segments/session";
+import type { BlockInfo } from "../segments/block";
+import type { TodayInfo } from "../segments/today";
+import type { ContextInfo } from "../segments/context";
+import type { MetricsInfo } from "../segments/metrics";
+import type { GitInfo } from "../segments/git";
+import type { ClaudeHookData } from "../utils/claude";
+import type { PowerlineColors } from "../themes";
+import type { PowerlineConfig } from "../config/loader";
+
+import type { SYMBOLS, TEXT_SYMBOLS } from "../utils/constants";
+
+export interface BoxChars {
+  readonly topLeft: string;
+  readonly topRight: string;
+  readonly bottomLeft: string;
+  readonly bottomRight: string;
+  readonly horizontal: string;
+  readonly vertical: string;
+  readonly teeLeft: string;
+  readonly teeRight: string;
+}
+
+export interface TuiData {
+  hookData: ClaudeHookData;
+  usageInfo: UsageInfo | null;
+  blockInfo: BlockInfo | null;
+  todayInfo: TodayInfo | null;
+  contextInfo: ContextInfo | null;
+  metricsInfo: MetricsInfo | null;
+  gitInfo: GitInfo | null;
+  tmuxSessionId: string | null;
+  colors: PowerlineColors;
+}
+
+export type SymbolSet = typeof SYMBOLS | typeof TEXT_SYMBOLS;
+
+export type LayoutMode = "wide" | "medium" | "narrow";
+
+const SEGMENT_NAME_LIST = [
+  "context",
+  "block",
+  "session",
+  "today",
+  "weekly",
+  "git",
+  "dir",
+  "model",
+  "version",
+  "tmux",
+  "metrics",
+  "activity",
+  "env",
+] as const;
+
+export type SegmentName = (typeof SEGMENT_NAME_LIST)[number];
+
+export const VALID_SEGMENT_NAMES: ReadonlySet<string> = new Set<SegmentName>(
+  SEGMENT_NAME_LIST,
+);
+
+export const SEGMENT_PARTS: Record<SegmentName, readonly string[]> = {
+  session: ["icon", "label", "cost", "tokens", "budget"],
+  block: ["icon", "label", "value", "time", "budget", "bar"],
+  today: ["icon", "cost", "label", "budget"],
+  weekly: ["icon", "label", "pct", "time", "bar"],
+  git: [
+    "icon",
+    "info",
+    "branch",
+    "status",
+    "ahead",
+    "behind",
+    "working",
+    "head",
+  ],
+  context: ["icon", "label", "bar", "pct", "tokens"],
+  metrics: [
+    "response",
+    "responseIcon",
+    "responseVal",
+    "lastResponse",
+    "lastResponseIcon",
+    "lastResponseVal",
+    "added",
+    "addedIcon",
+    "addedVal",
+    "removed",
+    "removedIcon",
+    "removedVal",
+  ],
+  activity: [
+    "icon",
+    "duration",
+    "durationIcon",
+    "durationVal",
+    "messages",
+    "messagesIcon",
+    "messagesVal",
+  ],
+  model: ["icon", "value"],
+  version: ["icon", "value"],
+  tmux: ["label", "value"],
+  dir: ["icon", "value"],
+  env: ["prefix", "value"],
+} as const;
+
+export function isValidSegmentRef(name: string): boolean {
+  if (name === "." || name === "---") return true;
+  if (VALID_SEGMENT_NAMES.has(name)) return true;
+  const dotIdx = name.indexOf(".");
+  if (dotIdx === -1) return false;
+  const seg = name.slice(0, dotIdx);
+  const part = name.slice(dotIdx + 1);
+  if (!seg || !part) return false;
+  const parts = SEGMENT_PARTS[seg as SegmentName];
+  return parts ? parts.includes(part) : false;
+}
+
+export type AlignValue = "left" | "center" | "right";
+
+export interface GridCell {
+  segment: string; // segment name, "." for empty, "---" for divider
+  spanStart: boolean; // true if this is the first cell of a span
+  spanSize: number; // number of columns this cell spans (1 if no span)
+}
+
+export interface TuiGridBreakpoint {
+  minWidth: number;
+  areas: string[];
+  columns: string[];
+  align?: AlignValue[];
+}
+
+export type JustifyValue = "start" | "between";
+
+export interface SegmentTemplate {
+  items: string[];
+  gap?: number;
+  justify?: JustifyValue;
+}
+
+export interface TuiTitleConfig {
+  left?: string;
+  right?: string;
+}
+
+export interface TuiFooterConfig {
+  left?: string;
+  right?: string;
+}
+
+export interface TuiGridConfig {
+  terminalWidth?: number;
+  widthReserve?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  fitContent?: boolean;
+  padding?: { horizontal?: number };
+  segments?: Record<string, SegmentTemplate>;
+  separator?: {
+    column?: string;
+    divider?: string;
+  };
+  box?: string | Partial<BoxChars>;
+  title?: TuiTitleConfig;
+  footer?: TuiFooterConfig;
+  breakpoints: TuiGridBreakpoint[];
+}
+
+export interface RenderCtx {
+  lines: string[];
+  data: TuiData;
+  box: BoxChars;
+  contentWidth: number;
+  innerWidth: number;
+  sym: SymbolSet;
+  config: PowerlineConfig;
+  reset: string;
+  colors: PowerlineColors;
+}

package/src/utils/budget.ts

@@ -0,0 +1,47 @@
+export interface BudgetStatus {
+  percentage: number | null;
+  isWarning: boolean;
+  displayText: string;
+}
+
+export function calculateBudgetPercentage(
+  cost: number,
+  budget: number | undefined,
+): number | null {
+  if (!budget || budget <= 0 || cost < 0) return null;
+  return Math.min(100, (cost / budget) * 100);
+}
+
+export function getBudgetStatus(
+  cost: number,
+  budget: number | undefined,
+  warningThreshold = 80,
+): BudgetStatus {
+  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,
+  };
+}

package/src/utils/cache.ts

@@ -0,0 +1,247 @@
+import fs from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { debug } from "./logger";
+import {
+  getClaudePaths,
+  findProjectPaths,
+  getFileModificationDate,
+} from "./claude";
+
+interface ErrnoError extends Error {
+  code?: string;
+}
+
+export interface CacheEntry<T> {
+  data: T;
+  timestamp: number;
+}
+
+export class CacheManager {
+  private static readonly CACHE_DIR = path.join(
+    homedir(),
+    ".claude",
+    "powerline",
+  );
+  private static readonly USAGE_CACHE_DIR = path.join(this.CACHE_DIR, "usage");
+  private static readonly LOCKS_DIR = path.join(this.CACHE_DIR, "locks");
+
+  private static isLocked(name: string): boolean {
+    const lockFile = path.join(this.LOCKS_DIR, name);
+    if (!fs.existsSync(lockFile)) {
+      return false;
+    }
+
+    try {
+      const lockContent = fs.readFileSync(lockFile, "utf-8");
+      const pid = parseInt(lockContent.trim(), 10);
+
+      if (isNaN(pid)) {
+        debug(`Invalid PID in lock file ${name}, removing stale lock`);
+        fs.unlinkSync(lockFile);
+        return false;
+      }
+
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        if ((error as ErrnoError).code === "ESRCH") {
+          debug(`Removing stale lock file ${name} for dead process ${pid}`);
+          fs.unlinkSync(lockFile);
+          return false;
+        }
+        debug(`Error checking process ${pid} for lock ${name}:`, error);
+        return true;
+      }
+    } catch (error) {
+      debug(`Error reading lock file ${name}:`, error);
+      return true;
+    }
+  }
+
+  private static async acquireLock(
+    name: string,
+    timeout = 5000,
+  ): Promise<boolean> {
+    const RETRY_DELAY_MS = 50;
+    const FILE_CREATE_FLAG = "wx";
+
+    await this.ensureCacheDirectories();
+    const lockFile = path.join(this.LOCKS_DIR, name);
+    const startTime = Date.now();
+    const lockContent = String(process.pid);
+
+    while (Date.now() - startTime < timeout) {
+      try {
+        await fs.promises.writeFile(lockFile, lockContent, {
+          flag: FILE_CREATE_FLAG,
+        });
+        debug(`Lock acquired for ${name}`);
+        return true;
+      } catch (error) {
+        if ((error as ErrnoError).code === "EEXIST") {
+          await setTimeout(RETRY_DELAY_MS);
+        } else {
+          throw error;
+        }
+      }
+    }
+    debug(`Failed to acquire lock for ${name} within ${timeout}ms`);
+    return false;
+  }
+
+  private static async releaseLock(name: string): Promise<void> {
+    const lockFile = path.join(this.LOCKS_DIR, name);
+    try {
+      await fs.promises.unlink(lockFile);
+      debug(`Lock released for ${name}`);
+    } catch (error) {
+      if ((error as ErrnoError).code !== "ENOENT") {
+        debug(`Error releasing lock for ${name}:`, error);
+      }
+    }
+  }
+
+  static async ensureCacheDirectories(): Promise<void> {
+    try {
+      await Promise.all([
+        fs.promises.mkdir(this.CACHE_DIR, { recursive: true }),
+        fs.promises.mkdir(this.USAGE_CACHE_DIR, { recursive: true }),
+        fs.promises.mkdir(this.LOCKS_DIR, { recursive: true }),
+      ]);
+    } catch (error) {
+      debug("Failed to create cache directories:", error);
+    }
+  }
+
+  static createProjectHash(projectPath: string): string {
+    return createHash("md5").update(projectPath).digest("hex").substring(0, 8);
+  }
+
+  static async getUsageCache(
+    cacheType: "today" | "block" | "pricing",
+    latestMtime?: number,
+  ): Promise<unknown> {
+    const MAX_RETRIES = 3;
+    const RETRY_DELAY_MS = 75;
+    const FILE_ENCODING = "utf-8";
+
+    await this.ensureCacheDirectories();
+    const cachePath = path.join(this.USAGE_CACHE_DIR, `${cacheType}.json`);
+    const lockName = `${cacheType}.usage.lock`;
+
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      const isCurrentlyLocked = this.isLocked(lockName);
+      if (isCurrentlyLocked) {
+        debug(`Cache for ${cacheType} is locked, waiting...`);
+        await setTimeout(RETRY_DELAY_MS);
+        continue;
+      }
+
+      try {
+        const content = await fs.promises.readFile(cachePath, FILE_ENCODING);
+        const cached: CacheEntry<unknown> = JSON.parse(content);
+        const cacheIsValid = !latestMtime || cached.timestamp >= latestMtime;
+
+        if (cacheIsValid) {
+          debug(`[CACHE-HIT] ${cacheType} disk cache: found`);
+          return this.deserializeDates(cached.data);
+        } else {
+          debug(
+            `${cacheType} cache outdated: cache=${cached.timestamp}, latest=${latestMtime}`,
+          );
+          return null;
+        }
+      } catch (error) {
+        if ((error as ErrnoError).code === "ENOENT") {
+          debug(`No shared ${cacheType} usage cache found`);
+          return null;
+        }
+        const attemptNumber = attempt + 1;
+        debug(
+          `Attempt ${attemptNumber} failed to read ${cacheType} cache: ${(error as Error).message}. Retrying...`,
+        );
+        await setTimeout(RETRY_DELAY_MS);
+      }
+    }
+
+    debug(`Failed to read ${cacheType} cache after ${MAX_RETRIES} attempts.`);
+    return null;
+  }
+
+  private static deserializeDates(data: unknown): unknown {
+    if (Array.isArray(data)) {
+      return data.map((entry) => ({
+        ...entry,
+        timestamp: new Date(entry.timestamp),
+      }));
+    }
+    return data;
+  }
+
+  static async setUsageCache(
+    cacheType: "today" | "block" | "pricing",
+    data: unknown,
+    latestMtime?: number,
+  ): Promise<void> {
+    const lockName = `${cacheType}.usage.lock`;
+    const lockAcquired = await this.acquireLock(lockName);
+    if (!lockAcquired) {
+      debug(`Could not acquire lock to set usage cache for ${cacheType}`);
+      return;
+    }
+
+    try {
+      await this.ensureCacheDirectories();
+      const cachePath = path.join(this.USAGE_CACHE_DIR, `${cacheType}.json`);
+      const cacheTimestamp = latestMtime || Date.now();
+      const cacheEntry: CacheEntry<unknown> = {
+        data,
+        timestamp: cacheTimestamp,
+      };
+      const cacheContent = JSON.stringify(cacheEntry);
+
+      await fs.promises.writeFile(cachePath, cacheContent, "utf-8");
+      debug(`[CACHE-SET] ${cacheType} disk cache stored`);
+    } catch (error) {
+      debug(`Failed to save ${cacheType} usage cache:`, error);
+    } finally {
+      await this.releaseLock(lockName);
+    }
+  }
+
+  static async getLatestTranscriptMtime(): Promise<number> {
+    try {
+      const claudePaths = getClaudePaths();
+      const projectPaths = await findProjectPaths(claudePaths);
+
+      let latestMtime = 0;
+
+      for (const projectPath of projectPaths) {
+        try {
+          const files = await fs.promises.readdir(projectPath);
+          const jsonlFiles = files.filter((file) => file.endsWith(".jsonl"));
+
+          for (const file of jsonlFiles) {
+            const filePath = path.join(projectPath, file);
+            const mtime = await getFileModificationDate(filePath);
+            if (mtime && mtime.getTime() > latestMtime) {
+              latestMtime = mtime.getTime();
+            }
+          }
+        } catch (error) {
+          debug(`Failed to read project directory ${projectPath}:`, error);
+          continue;
+        }
+      }
+
+      return latestMtime;
+    } catch (error) {
+      debug("Failed to get latest transcript mtime:", error);
+      return Date.now();
+    }
+  }
+}