@pi-unipi/footer 0.1.3 → 2.0.0

package/src/segments/notify.ts

@@ -6,8 +6,9 @@
  */
 
 import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../types.js";
-import { applyColor } from "../rendering/theme.js";
+import { applyColor, mutedPlaceholder } from "../rendering/theme.js";
 import { getIcon } from "../rendering/icons.js";
+import { isSegmentEnabled } from "../config.js";
 
 function withIcon(segmentId: string, text: string): string {
   const icon = getIcon(segmentId);
@@ -23,7 +24,12 @@ function getNotifyData(ctx: FooterSegmentContext): Record<string, unknown> {
 function renderPlatformsEnabledSegment(ctx: FooterSegmentContext): RenderedSegment {
   const data = getNotifyData(ctx);
   const platforms = data.platforms as string[] | undefined;
-  if (!platforms || platforms.length === 0) return { content: "", visible: false };
+  if (!platforms || platforms.length === 0) {
+    if (isSegmentEnabled("notify", "platforms_enabled")) {
+      return { content: mutedPlaceholder(withIcon("platformsEnabled", "OFF")), visible: true };
+    }
+    return { content: "", visible: false };
+  }
 
   const content = withIcon("platformsEnabled", platforms.join(","));
   return { content: applyColor("notify", content, ctx.theme, ctx.colors), visible: true };
@@ -32,7 +38,12 @@ function renderPlatformsEnabledSegment(ctx: FooterSegmentContext): RenderedSegme
 function renderLastSentSegment(ctx: FooterSegmentContext): RenderedSegment {
   const data = getNotifyData(ctx);
   const timestamp = data.timestamp as string | undefined;
-  if (!timestamp) return { content: "", visible: false };
+  if (!timestamp) {
+    if (isSegmentEnabled("notify", "last_sent")) {
+      return { content: mutedPlaceholder(withIcon("lastSent", "0")), visible: true };
+    }
+    return { content: "", visible: false };
+  }
 
   // Show relative time
   const sent = new Date(timestamp);
@@ -45,6 +56,6 @@ function renderLastSentSegment(ctx: FooterSegmentContext): RenderedSegment {
 }
 
 export const NOTIFY_SEGMENTS: FooterSegment[] = [
-  { id: "platforms_enabled", label: "Platforms", icon: "", render: renderPlatformsEnabledSegment, defaultShow: true },
-  { id: "last_sent", label: "Last Sent", icon: "", render: renderLastSentSegment, defaultShow: true },
+  { id: "platforms_enabled", label: "Platforms", shortLabel: "NTF", description: "Active notification platforms", zone: "center", icon: "", render: renderPlatformsEnabledSegment, defaultShow: true },
+  { id: "last_sent", label: "Last Sent", shortLabel: "LST", description: "Time of last notification sent", zone: "center", icon: "", render: renderLastSentSegment, defaultShow: true },
 ];

package/src/segments/ralph.ts

@@ -11,8 +11,9 @@
  */
 
 import type { FooterSegment, FooterSegmentContext, RenderedSegment, SemanticColor } from "../types.js";
-import { applyColor } from "../rendering/theme.js";
+import { applyColor, mutedPlaceholder } from "../rendering/theme.js";
 import { getIcon } from "../rendering/icons.js";
+import { isSegmentEnabled } from "../config.js";
 
 
 
@@ -47,7 +48,14 @@ function renderActiveLoopsSegment(ctx: FooterSegmentContext): RenderedSegment {
   const maxIterations = data.maxIterations as number | undefined;
 
   // Always show when there's ralph data (even when off, to show red dot)
-  if (!active && !name && iteration === undefined) return { content: "", visible: false };
+  if (!active && !name && iteration === undefined) {
+    // Show muted placeholder when enabled but no data
+    if (isSegmentEnabled("ralph", "active_loops")) {
+      const ralphIcon = getIcon("activeLoops");
+      return { content: mutedPlaceholder(`${ralphIcon} OFF`), visible: true };
+    }
+    return { content: "", visible: false };
+  }
 
   const dot = active ? GREEN_DOT : RED_DOT;
 
@@ -73,7 +81,10 @@ function renderTotalIterationsSegment(ctx: FooterSegmentContext): RenderedSegmen
   const active = data.active === true;
   const lastIteration = data.lastIteration as Record<string, unknown> | undefined;
   const iteration = data.iteration ?? lastIteration?.iteration;
-  if (iteration === undefined || iteration === null) return { content: "", visible: false };
+  if (iteration === undefined || iteration === null) {
+    // No data — hide to avoid duplicating active_loops placeholder
+    return { content: "", visible: false };
+  }
   const maxIterations = data.maxIterations;
   const display = maxIterations ? `${iteration}/${maxIterations}` : `${iteration}`;
 
@@ -88,11 +99,15 @@ function renderLoopStatusSegment(ctx: FooterSegmentContext): RenderedSegment {
   const data = getRalphData(ctx);
   const status = data.status as string | undefined;
   const name = data.name as string | undefined;
-  if (!status && !name) return { content: "", visible: false };
+  if (!status && !name) {
+    // No data — hide to avoid duplicating active_loops placeholder
+    return { content: "", visible: false };
+  }
 
   const ralphIcon = getIcon("activeLoops");
   const dot = status === "active" ? GREEN_DOT : status === "completed" ? GREEN_DOT : RED_DOT;
-  const statusIcon = status === "active" ? "▶" : status === "paused" ? "⏸" : status === "completed" ? "✓" : "";
+  // Small geometric status indicators (▶ ⏸ ✓) work in all icon styles
+  const statusIcon = status === "active" ? "\u25B6" : status === "paused" ? "\u23F8" : status === "completed" ? "\u2713" : "";
   const display = name ? `${statusIcon} ${name}` : `${statusIcon}`;
 
   const active = status === "active" || status === "completed";
@@ -102,7 +117,7 @@ function renderLoopStatusSegment(ctx: FooterSegmentContext): RenderedSegment {
 }
 
 export const RALPH_SEGMENTS: FooterSegment[] = [
-  { id: "active_loops", label: "Active Loops", icon: "", render: renderActiveLoopsSegment, defaultShow: true },
-  { id: "total_iterations", label: "Total Iterations", icon: "", render: renderTotalIterationsSegment, defaultShow: true },
-  { id: "loop_status", label: "Loop Status", icon: "", render: renderLoopStatusSegment, defaultShow: true },
+  { id: "active_loops", label: "Loops", shortLabel: "RL", description: "Active Ralph loops", zone: "center", icon: "", render: renderActiveLoopsSegment, defaultShow: true },
+  { id: "total_iterations", label: "Iterations", shortLabel: "ITR", description: "Total Ralph loop iterations", zone: "center", icon: "", render: renderTotalIterationsSegment, defaultShow: true },
+  { id: "loop_status", label: "Status", shortLabel: "STS", description: "Current loop status", zone: "center", icon: "", render: renderLoopStatusSegment, defaultShow: true },
 ];

package/src/segments/status-ext.ts

@@ -120,5 +120,5 @@ function renderExtensionStatusesSegment(ctx: FooterSegmentContext): RenderedSegm
 }
 
 export const STATUS_EXT_SEGMENTS: FooterSegment[] = [
-  { id: "extension_statuses", label: "Extensions", icon: "", render: renderExtensionStatusesSegment, defaultShow: true },
+  { id: "extension_statuses", label: "Extensions", shortLabel: "EXT", description: "Extension statuses overview", zone: "center", icon: "", render: renderExtensionStatusesSegment, defaultShow: true },
 ];

package/src/segments/workflow.ts

@@ -23,21 +23,43 @@ function getWorkflowData(ctx: FooterSegmentContext): Record<string, unknown> {
   return data as Record<string, unknown>;
 }
 
-/** Map a workflow command name to a semantic color for slight differentiation */
+/** Map a workflow command name to a semantic color for category differentiation */
 function getWorkflowSemanticColor(command: string): SemanticColor {
-  const commandLower = command.toLowerCase();
-
-  if (commandLower.includes("brainstorm")) return "workflowBrainstorm";
-  if (commandLower.includes("plan")) return "workflowPlan";
-  if (commandLower.includes("work") && !commandLower.includes("network") && !commandLower.includes("framework")) return "workflowWork";
-  if (commandLower.includes("review")) return "workflowReview";
-  if (commandLower.includes("auto")) return "workflowAuto";
-  if (commandLower.includes("fix") || commandLower.includes("debug")) return "workflowWork";
-  if (commandLower.includes("quick")) return "workflowOther";
-  if (commandLower.includes("document")) return "workflowPlan";
-  if (commandLower.includes("consolidate")) return "workflowOther";
-
-  return "workflow";
+  const c = command.toLowerCase();
+
+  // Red: brainstorm, debug, gather-context, quick-fix, quick-work, chore-create
+  if (c.includes("brainstorm") || c.includes("debug") || c.includes("gather-context") ||
+      c.includes("quick-fix") || c.includes("quick-work") || c.includes("chore-create")) {
+    return "workflowBrainstorm";
+  }
+
+  // Orange: chore-execute, plan
+  if (c.includes("chore-exec") || c.includes("plan")) {
+    return "workflowChoreExec";
+  }
+
+  // Yellow: work
+  if (c.includes("work") && !c.includes("network") && !c.includes("framework") && !c.includes("worktree")) {
+    return "workflowWork";
+  }
+
+  // Green: review-work, review
+  if (c.includes("review")) {
+    return "workflowReview";
+  }
+
+  // Blue: worktree-*
+  if (c.includes("worktree")) {
+    return "worktree" as SemanticColor;
+  }
+
+  // Auto
+  if (c.includes("auto")) {
+    return "workflowAuto";
+  }
+
+  // Default: idle/none
+  return "workflowNone";
 }
 
 function renderCurrentCommandSegment(ctx: FooterSegmentContext): RenderedSegment {
@@ -53,7 +75,8 @@ function renderCurrentCommandSegment(ctx: FooterSegmentContext): RenderedSegment
     return { content: applyColor("workflow", content, ctx.theme, ctx.colors), visible: true };
   }
 
-  const statusPrefix = active ? "▶" : "✓";
+  // Small geometric status indicators work in all icon styles
+  const statusPrefix = active ? "\u25B6" : "\u2713";
   const semanticColor = getWorkflowSemanticColor(command);
   const content = `${workflowIcon} ${statusPrefix} ${command}`;
   return { content: applyColor(semanticColor, content, ctx.theme, ctx.colors), visible: true };
@@ -95,7 +118,7 @@ function formatDuration(ms: number): string {
 }
 
 export const WORKFLOW_SEGMENTS: FooterSegment[] = [
-  { id: "current_command", label: "Current Command", icon: "", render: renderCurrentCommandSegment, defaultShow: true },
-  { id: "sandbox_level", label: "Sandbox Level", icon: "", render: renderSandboxLevelSegment, defaultShow: false },
-  { id: "command_duration", label: "Command Duration", icon: "", render: renderCommandDurationSegment, defaultShow: true },
+  { id: "current_command", label: "Command", shortLabel: "WRK", description: "Active workflow command", zone: "left", icon: "", render: renderCurrentCommandSegment, defaultShow: true },
+  { id: "sandbox_level", label: "Sandbox", shortLabel: "SBX", description: "Sandbox permission level", zone: "center", icon: "", render: renderSandboxLevelSegment, defaultShow: false },
+  { id: "command_duration", label: "Duration", shortLabel: "CDUR", description: "Current command duration", zone: "center", icon: "", render: renderCommandDurationSegment, defaultShow: true },
 ];

package/src/tps-tracker.ts

@@ -0,0 +1,204 @@
+/**
+ * @pi-unipi/footer — TPS (Tokens Per Second) tracker
+ *
+ * Per-message TPS calculation for live generation rate display.
+ * Tracks individual assistant messages with start/stop timestamps
+ * to measure generation rate excluding idle/tool-execution time.
+ */
+
+/** Per-message TPS record */
+interface MessageTpsRecord {
+  /** Message index in the session */
+  messageIndex: number;
+  /** Output tokens for this message */
+  outputTokens: number;
+  /** When generation started (Date.now()) */
+  startedAt: number;
+  /** When generation completed (Date.now()), 0 if still generating */
+  completedAt: number;
+  /** Computed TPS for this message */
+  tps: number;
+}
+
+/**
+ * Tracks per-message TPS and computes live/session metrics.
+ *
+ * Usage: Call `onMessageUpdate()` whenever output tokens change.
+ * The tracker records generation start/stop per message and computes
+ * live TPS from the current message and session averages excluding idle time.
+ */
+export class TpsTracker {
+  /** Per-message records */
+  private records: MessageTpsRecord[] = [];
+
+  /** Highest message index seen so far (for dedup) */
+  private lastSeenMessageCount = 0;
+
+  /** Total output tokens across all completed messages */
+  private totalOutput = 0;
+
+  /**
+   * Update with the latest message data from the session.
+   * Call this on every tick (e.g. 1s interval) with the current state.
+   *
+   * @param messageIndex - Index of the assistant message (0-based, sequential)
+   * @param outputTokens - Output tokens for this message
+   * @param hasStopReason - Whether this message has completed (has stopReason)
+   */
+  onMessageUpdate(messageIndex: number, outputTokens: number, hasStopReason: boolean): void {
+    const now = Date.now();
+
+    // New message — create a record
+    if (messageIndex >= this.records.length) {
+      // Fill gaps if indices jump
+      while (this.records.length < messageIndex) {
+        this.records.push({
+          messageIndex: this.records.length,
+          outputTokens: 0,
+          startedAt: 0,
+          completedAt: 0,
+          tps: 0,
+        });
+      }
+
+      if (hasStopReason && outputTokens > 0) {
+        // Fast message: already completed on first sighting
+        // Estimate duration: floor of 1 second, or outputTokens/100, whichever is smaller
+        const estimatedDuration = Math.max(1, outputTokens / 100);
+        const tps = outputTokens / estimatedDuration;
+
+        this.records.push({
+          messageIndex,
+          outputTokens,
+          startedAt: now - estimatedDuration * 1000,
+          completedAt: now,
+          tps,
+        });
+        this.totalOutput += outputTokens;
+      } else {
+        // Just started — mark start time
+        this.records.push({
+          messageIndex,
+          outputTokens,
+          startedAt: now,
+          completedAt: 0,
+          tps: 0,
+        });
+      }
+      this.lastSeenMessageCount = messageIndex + 1;
+      return;
+    }
+
+    // Update existing message
+    const record = this.records[messageIndex];
+    if (!record) return;
+
+    record.outputTokens = outputTokens;
+
+    if (record.completedAt === 0 && hasStopReason) {
+      // Message just completed
+      record.completedAt = now;
+      const durationSec = (record.completedAt - record.startedAt) / 1000;
+      record.tps = durationSec > 0 ? outputTokens / durationSec : outputTokens;
+      this.totalOutput += outputTokens;
+    } else if (record.completedAt === 0) {
+      // Still generating — update output tokens (live TPS computed on demand)
+    }
+  }
+
+  /**
+   * Get the live TPS from the currently generating message.
+   * Returns the instantaneous rate based on tokens generated so far
+   * in the current message divided by elapsed time.
+   */
+  getLiveTps(): number {
+    // Find the last record that's still generating
+    for (let i = this.records.length - 1; i >= 0; i--) {
+      const record = this.records[i];
+      if (record.completedAt === 0 && record.startedAt > 0) {
+        // Currently generating
+        const elapsedSec = (Date.now() - record.startedAt) / 1000;
+        if (elapsedSec <= 0) return 0;
+        return record.outputTokens / elapsedSec;
+      }
+    }
+    // No active generation — return the last completed message's TPS
+    if (this.records.length > 0) {
+      const last = this.records[this.records.length - 1];
+      return last.tps;
+    }
+    return 0;
+  }
+
+  /**
+   * Get the session average TPS, excluding idle/tool-execution time.
+   * Computed as total output tokens / total generation time.
+   */
+  getSessionAvgTps(): number {
+    let totalTokens = 0;
+    let totalDurationSec = 0;
+
+    for (const record of this.records) {
+      if (record.completedAt > 0 && record.startedAt > 0) {
+        totalTokens += record.outputTokens;
+        totalDurationSec += (record.completedAt - record.startedAt) / 1000;
+      }
+    }
+
+    // Include currently generating message in average
+    for (let i = this.records.length - 1; i >= 0; i--) {
+      if (this.records[i].completedAt === 0 && this.records[i].startedAt > 0) {
+        totalTokens += this.records[i].outputTokens;
+        totalDurationSec += (Date.now() - this.records[i].startedAt) / 1000;
+        break;
+      }
+    }
+
+    if (totalDurationSec <= 0) return 0;
+    return totalTokens / totalDurationSec;
+  }
+
+  /**
+   * Whether the model is currently streaming tokens.
+   * True if the latest message has started but not completed.
+   */
+  isStreaming(): boolean {
+    if (this.records.length === 0) return false;
+    const last = this.records[this.records.length - 1];
+    return last.startedAt > 0 && last.completedAt === 0;
+  }
+
+  /**
+   * Whether the model was recently generating tokens.
+   * Kept for backward compatibility with renderer.
+   */
+  isGenerating(): boolean {
+    return this.isStreaming();
+  }
+
+  /**
+   * Get total output tokens for the session.
+   */
+  getTotalOutput(): number {
+    // Include tokens from incomplete messages too
+    let total = this.totalOutput;
+    for (const record of this.records) {
+      if (record.completedAt === 0 && record.startedAt > 0) {
+        total += record.outputTokens;
+      }
+    }
+    return total;
+  }
+
+  /**
+   * Reset the tracker (e.g., on session shutdown).
+   */
+  reset(): void {
+    this.records = [];
+    this.lastSeenMessageCount = 0;
+    this.totalOutput = 0;
+  }
+}
+
+/** Singleton TPS tracker instance */
+export const tpsTracker = new TpsTracker();