@bastra-recall/statusline 0.7.0-beta.1

package/src/segments/bastra.ts

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+/**
+ * bastra-recall statusline segment.
+ *
+ * Reads the per-session feed written by the bastra-recall MCP forwarder:
+ *   ~/.bastra/statusline/<claude-session-pid>.json
+ *
+ * Claude Code sends no session id to MCP servers (anthropics/claude-code
+ * #41836), so the feed is namespaced by the shared `claude` ancestor PID
+ * of the session's forwarder, prompt-hook, and this statusline process.
+ * We walk our own parent chain up to `claude` to find the matching feed.
+ *
+ * Best-effort: any read/parse failure yields null → segment renders
+ * nothing (never errors, never blanks).
+ */
+
+const STATUSLINE_DIR = path.join(os.homedir(), ".bastra", "statusline");
+
+export interface BastraInfo {
+  state: "idle" | "running";
+  vaultSize: number;
+  recallCount: number;
+  totalHits: number;
+  totalMs: number;
+  currentStage: string | null;
+  /** Human-readable banter phrase for the running stage; preferred over the
+   *  raw stage name when present. Null when banter is off or idle. */
+  currentMessage: string | null;
+  currentStageStartedAt: number | null;
+  currentRecallStartedAt: number | null;
+  /** Banter phrase shown in the done banner after a recall; hidden once older
+   *  than the TTL (see renderBastra). */
+  lastPhrase: string | null;
+  lastPhraseAt: number | null;
+}
+
+/** Walk parent chain up to the `claude` session process; its PID namespaces
+ *  the feed. One `ps` call + in-memory walk. Falls back to process.ppid. */
+function claudeSessionPid(): number {
+  try {
+    const out = execFileSync("ps", ["-axo", "pid=,ppid=,comm="], {
+      encoding: "utf8",
+    });
+    const procs = new Map<number, { ppid: number; comm: string }>();
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+      if (m) {
+        procs.set(parseInt(m[1]!, 10), {
+          ppid: parseInt(m[2]!, 10),
+          comm: m[3] ?? "",
+        });
+      }
+    }
+    let pid = process.ppid;
+    for (let i = 0; i < 12 && pid > 1; i++) {
+      const e = procs.get(pid);
+      if (!e) break;
+      if (e.comm.toLowerCase().includes("claude")) return pid;
+      if (e.ppid === pid) break;
+      pid = e.ppid;
+    }
+  } catch {
+    // ps unavailable — fall through to ppid
+  }
+  return process.ppid;
+}
+
+export class BastraProvider {
+  getBastraInfo(): BastraInfo | null {
+    const feed = path.join(STATUSLINE_DIR, `${claudeSessionPid()}.json`);
+    try {
+      const raw = fs.readFileSync(feed, "utf8");
+      const d = JSON.parse(raw) as Record<string, unknown>;
+      const state = d.state === "running" ? "running" : "idle";
+      return {
+        state,
+        // Prefer the daemon-maintained shared count (always current, even when
+        // this session is idle); fall back to the per-session feed value.
+        vaultSize: readSharedVaultSize() ?? numOr(d.vault_size, 0),
+        recallCount: numOr(d.recall_count, 0),
+        totalHits: numOr(d.total_hits, 0),
+        totalMs: numOr(d.total_ms, 0),
+        currentStage:
+          typeof d.current_stage === "string" ? d.current_stage : null,
+        currentMessage:
+          typeof d.current_message === "string" ? d.current_message : null,
+        currentStageStartedAt: numOrNull(d.current_stage_started_at),
+        currentRecallStartedAt: numOrNull(d.current_recall_started_at),
+        lastPhrase: typeof d.last_phrase === "string" ? d.last_phrase : null,
+        lastPhraseAt: numOrNull(d.last_phrase_at),
+      };
+    } catch {
+      return null;
+    }
+  }
+}
+
+/**
+ * Reads the daemon-maintained shared vault size (~/.bastra/statusline/vault.json).
+ * Session-independent, so it stays current even when this session is idle.
+ * Null on any failure → caller falls back to the per-session feed value.
+ */
+function readSharedVaultSize(): number | null {
+  try {
+    const raw = fs.readFileSync(path.join(STATUSLINE_DIR, "vault.json"), "utf8");
+    const v = (JSON.parse(raw) as { vault_size?: unknown }).vault_size;
+    return typeof v === "number" && Number.isFinite(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+
+function numOr(v: unknown, fallback: number): number {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+
+function numOrNull(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}

package/src/segments/block.ts

@@ -0,0 +1,31 @@
+import { debug } from "../utils/logger";
+import { minutesUntilReset } from "../utils/formatters";
+import type { ClaudeHookData } from "../utils/claude";
+
+export interface BlockInfo {
+  nativeUtilization: number;
+  timeRemaining: number;
+}
+
+export class BlockProvider {
+  async getActiveBlockInfo(
+    hookData?: ClaudeHookData,
+  ): Promise<BlockInfo | null> {
+    const fiveHour = hookData?.rate_limits?.five_hour;
+    if (!fiveHour) {
+      debug("Block segment: No native rate_limits data available");
+      return null;
+    }
+
+    const timeRemaining = minutesUntilReset(fiveHour.resets_at);
+
+    debug(
+      `Block segment: Using native rate_limits: ${fiveHour.used_percentage}%, resets in ${timeRemaining}m`,
+    );
+
+    return {
+      nativeUtilization: fiveHour.used_percentage,
+      timeRemaining,
+    };
+  }
+}

package/src/segments/cacheTimer.ts

@@ -0,0 +1,108 @@
+import { readFile, stat } from "node:fs/promises";
+import { debug } from "../utils/logger";
+import type { ClaudeHookData } from "../utils/claude";
+
+export interface CacheTimerInfo {
+  elapsedSeconds: number;
+  detectedTtlSeconds?: number;
+}
+
+interface TranscriptEntry {
+  type?: string;
+  timestamp?: string;
+  message?: {
+    role?: string;
+    type?: string;
+    usage?: {
+      cache_creation?: {
+        ephemeral_1h_input_tokens?: number;
+        ephemeral_5m_input_tokens?: number;
+      };
+    };
+  };
+}
+
+export class CacheTimerProvider {
+  async getCacheTimerInfo(
+    hookData: ClaudeHookData,
+  ): Promise<CacheTimerInfo | null> {
+    const path = hookData?.transcript_path;
+    if (!path) {
+      debug("CacheTimer: no transcript_path in hookData");
+      return null;
+    }
+
+    const lines = await this.readTranscriptLines(path);
+    const anchor =
+      (lines && this.lastUserTimestamp(lines)) ?? (await this.fileMtime(path));
+    if (anchor === null) return null;
+
+    const elapsedSeconds = Math.max(
+      0,
+      Math.floor((Date.now() - anchor) / 1000),
+    );
+    const detectedTtlSeconds = lines
+      ? (this.detectTtlSeconds(lines) ?? undefined)
+      : undefined;
+    return { elapsedSeconds, detectedTtlSeconds };
+  }
+
+  private async readTranscriptLines(path: string): Promise<string[] | null> {
+    try {
+      const content = await readFile(path, "utf-8");
+      return content.split("\n");
+    } catch (error) {
+      debug(`CacheTimer: readFile failed for ${path}: ${String(error)}`);
+      return null;
+    }
+  }
+
+  private lastUserTimestamp(lines: string[]): number | null {
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i]?.trim();
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line) as TranscriptEntry;
+        const messageType =
+          entry.type || entry.message?.role || entry.message?.type;
+        if (messageType !== "user") continue;
+        if (!entry.timestamp) continue;
+        const t = Date.parse(entry.timestamp);
+        if (Number.isNaN(t)) continue;
+        return t;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+
+  private detectTtlSeconds(lines: string[]): number | null {
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i]?.trim();
+      if (!line) continue;
+      try {
+        const entry = JSON.parse(line) as TranscriptEntry;
+        const role = entry.type || entry.message?.role || entry.message?.type;
+        if (role !== "assistant") continue;
+        const cc = entry.message?.usage?.cache_creation;
+        if (!cc) continue;
+        if ((cc.ephemeral_1h_input_tokens ?? 0) > 0) return 3600;
+        if ((cc.ephemeral_5m_input_tokens ?? 0) > 0) return 300;
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+
+  private async fileMtime(path: string): Promise<number | null> {
+    try {
+      const { mtime } = await stat(path);
+      return mtime.getTime();
+    } catch (error) {
+      debug(`CacheTimer: stat failed for ${path}: ${String(error)}`);
+      return null;
+    }
+  }
+}

package/src/segments/context.ts

@@ -0,0 +1,221 @@
+import type { ParsedEntry, ClaudeHookData } from "../utils/claude";
+import type { PowerlineConfig } from "../config/loader";
+
+import { debug } from "../utils/logger";
+import { parseJsonlFile } from "../utils/claude";
+
+export interface ContextInfo {
+  totalTokens: number;
+  percentage: number;
+  usablePercentage: number;
+  contextLeftPercentage: number;
+  maxTokens: number;
+  usableTokens: number;
+}
+
+interface ContextUsageThresholds {
+  LOW: number;
+  MEDIUM: number;
+}
+
+export class ContextProvider {
+  private readonly thresholds: ContextUsageThresholds = {
+    LOW: 50,
+    MEDIUM: 80,
+  };
+  private readonly config: PowerlineConfig;
+
+  constructor(config: PowerlineConfig) {
+    this.config = config;
+  }
+
+  getContextUsageThresholds(): ContextUsageThresholds {
+    return this.thresholds;
+  }
+
+  private getContextLimit(modelId: string): number {
+    const modelLimits = this.config.modelContextLimits || { default: 200000 };
+    const modelType = this.getModelType(modelId);
+    return modelLimits[modelType] || modelLimits.default || 200000;
+  }
+
+  private getModelType(modelId: string): string {
+    const id = modelId.toLowerCase();
+
+    if (id.includes("sonnet")) {
+      return "sonnet";
+    }
+    if (id.includes("opus")) {
+      return "opus";
+    }
+
+    return "default";
+  }
+
+  private calculatePercentages(
+    totalTokens: number,
+    contextLimit: number,
+    autocompactBuffer: number = 33000,
+  ): Pick<
+    ContextInfo,
+    "percentage" | "usablePercentage" | "contextLeftPercentage" | "usableTokens"
+  > {
+    const percentage = Math.min(
+      100,
+      Math.max(0, Math.round((totalTokens / contextLimit) * 100)),
+    );
+
+    const usableLimit = Math.max(1, contextLimit - autocompactBuffer);
+    const usablePercentage = Math.min(
+      100,
+      Math.max(0, Math.round((totalTokens / usableLimit) * 100)),
+    );
+
+    const contextLeftPercentage = Math.max(0, 100 - usablePercentage);
+
+    return {
+      percentage,
+      usablePercentage,
+      contextLeftPercentage,
+      usableTokens: usableLimit,
+    };
+  }
+
+  /**
+   * Calculate context info from native Claude Code context_window data (preferred).
+   * Requires Claude Code 2.0.70+ with current_usage field.
+   */
+  calculateContextFromHookData(
+    hookData: ClaudeHookData,
+    autocompactBuffer: number = 33000,
+  ): ContextInfo | null {
+    const currentUsage = hookData.context_window?.current_usage;
+    if (!currentUsage) {
+      debug(
+        "No current_usage in hook data, falling back to transcript parsing",
+      );
+      return null;
+    }
+
+    const contextLimit = hookData.context_window?.context_window_size || 200000;
+    const totalTokens =
+      (currentUsage.input_tokens || 0) +
+      (currentUsage.cache_creation_input_tokens || 0) +
+      (currentUsage.cache_read_input_tokens || 0);
+
+    debug(
+      `Native current_usage: input=${currentUsage.input_tokens}, cache_create=${currentUsage.cache_creation_input_tokens}, cache_read=${currentUsage.cache_read_input_tokens}, total=${totalTokens} (limit: ${contextLimit})`,
+    );
+
+    const nativePct = hookData.context_window?.used_percentage;
+    const percentages = this.calculatePercentages(
+      totalTokens,
+      contextLimit,
+      autocompactBuffer,
+    );
+
+    if (nativePct != null) {
+      percentages.percentage = Math.round(nativePct);
+      debug(`Using native used_percentage: ${nativePct}%`);
+    }
+
+    return {
+      totalTokens,
+      maxTokens: contextLimit,
+      ...percentages,
+    };
+  }
+
+  /**
+   * Calculate context tokens by parsing the transcript file (fallback).
+   * Used for older Claude Code versions that don't provide context_window.
+   */
+  async calculateContextTokensFromTranscript(
+    transcriptPath: string,
+    modelId?: string,
+    autocompactBuffer: number = 33000,
+  ): Promise<ContextInfo | null> {
+    try {
+      debug(`Calculating context tokens from transcript: ${transcriptPath}`);
+
+      const parsedEntries = await parseJsonlFile(transcriptPath);
+
+      if (parsedEntries.length === 0) {
+        debug("No entries in transcript");
+        return null;
+      }
+
+      let mostRecentEntry: ParsedEntry | null = null;
+
+      for (let i = parsedEntries.length - 1; i >= 0; i--) {
+        const entry = parsedEntries[i];
+        if (!entry) continue;
+
+        if (!entry.message?.usage?.input_tokens) continue;
+        if (entry.isSidechain === true) continue;
+
+        mostRecentEntry = entry;
+        debug(
+          `Context segment: Found most recent entry at ${entry.timestamp.toISOString()}, stopping search`,
+        );
+        break;
+      }
+
+      if (mostRecentEntry?.message?.usage) {
+        const usage = mostRecentEntry.message.usage;
+        const totalTokens =
+          (usage.input_tokens || 0) +
+          (usage.cache_read_input_tokens || 0) +
+          (usage.cache_creation_input_tokens || 0);
+
+        const contextLimit = modelId ? this.getContextLimit(modelId) : 200000;
+
+        debug(
+          `Most recent main chain context: ${totalTokens} tokens (limit: ${contextLimit})`,
+        );
+
+        const percentages = this.calculatePercentages(
+          totalTokens,
+          contextLimit,
+          autocompactBuffer,
+        );
+
+        return {
+          totalTokens,
+          maxTokens: contextLimit,
+          ...percentages,
+        };
+      }
+
+      debug("No main chain entries with usage data found");
+      return null;
+    } catch (error) {
+      debug(
+        `Error reading transcript: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return null;
+    }
+  }
+
+  /**
+   * Get context info using native data if available, falling back to transcript parsing.
+   */
+  async getContextInfo(
+    hookData: ClaudeHookData,
+    autocompactBuffer: number = 33000,
+  ): Promise<ContextInfo | null> {
+    const nativeContext = this.calculateContextFromHookData(
+      hookData,
+      autocompactBuffer,
+    );
+    if (nativeContext) {
+      return nativeContext;
+    }
+
+    return this.calculateContextTokensFromTranscript(
+      hookData.transcript_path,
+      hookData.model?.id,
+      autocompactBuffer,
+    );
+  }
+}