@pi-unipi/footer 0.1.2 → 0.1.4

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("NTF 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("NTF 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,11 +11,11 @@
  */
 
 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";
+
 
-/** Nerd Font icon for ralph: 󰼉 */
-const RALPH_ICON = "\udb81\udf09";
 
 /** Green dot indicator (with explicit ANSI codes) */
 const GREEN_DOT = "\x1b[38;5;82m●\x1b[0m";
@@ -48,10 +48,18 @@ 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")) {
+      return { content: mutedPlaceholder("🔁 RL OFF"), visible: true };
+    }
+    return { content: "", visible: false };
+  }
 
   const dot = active ? GREEN_DOT : RED_DOT;
 
+  const ralphIcon = getIcon("activeLoops");
+
   if (active) {
     // Active: green dot + iteration stats
     const iterStr = iteration !== undefined
@@ -59,15 +67,11 @@ function renderActiveLoopsSegment(ctx: FooterSegmentContext): RenderedSegment {
       : "";
     const nameStr = name ? ` ${name}` : "";
     // Color the icon and text parts, keep dot's own color
-    const iconAndText = `${RALPH_ICON} ${iterStr}${nameStr}`;
-    const coloredText = colorText(ctx, "ralphOn", iconAndText);
-    // Insert the dot after the icon
-    const content = `${RALPH_ICON} ${dot} ${colorText(ctx, "ralphOn", `${iterStr}${nameStr}`)}`;
+    const content = `${ralphIcon} ${dot} ${colorText(ctx, "ralphOn", `${iterStr}${nameStr}`)}`;
     return { content, visible: true };
   } else {
     // Off/inactive: red dot
-    const content = `${RALPH_ICON} ${dot}`;
-    return { content: `${colorText(ctx, "ralphOff", RALPH_ICON)} ${dot}`, visible: true };
+    return { content: `${colorText(ctx, "ralphOff", ralphIcon)} ${dot}`, visible: true };
   }
 }
 
@@ -76,13 +80,19 @@ 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) {
+    if (isSegmentEnabled("ralph", "total_iterations")) {
+      return { content: mutedPlaceholder("🔁 RL 0"), visible: true };
+    }
+    return { content: "", visible: false };
+  }
   const maxIterations = data.maxIterations;
   const display = maxIterations ? `${iteration}/${maxIterations}` : `${iteration}`;
 
+  const ralphIcon = getIcon("activeLoops");
   const dot = active ? GREEN_DOT : RED_DOT;
   const semantic: SemanticColor = active ? "ralphOn" : "ralphOff";
-  const content = `${colorText(ctx, semantic, RALPH_ICON)} ${dot} ${colorText(ctx, semantic, display)}`;
+  const content = `${colorText(ctx, semantic, ralphIcon)} ${dot} ${colorText(ctx, semantic, display)}`;
   return { content, visible: true };
 }
 
@@ -90,20 +100,26 @@ 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) {
+    if (isSegmentEnabled("ralph", "loop_status")) {
+      return { content: mutedPlaceholder("🔁 RL OFF"), visible: true };
+    }
+    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" ? "✓" : "";
   const display = name ? `${statusIcon} ${name}` : `${statusIcon}`;
 
   const active = status === "active" || status === "completed";
   const semantic: SemanticColor = active ? "ralphOn" : "ralphOff";
-  const content = `${colorText(ctx, semantic, RALPH_ICON)} ${dot} ${colorText(ctx, semantic, display)}`;
+  const content = `${colorText(ctx, semantic, ralphIcon)} ${dot} ${colorText(ctx, semantic, display)}`;
   return { content, visible: true };
 }
 
 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

@@ -7,7 +7,7 @@
  * Status keys from packages:
  *   "unipi-workflow" → "⚡ wf:brainstorm ✓ rl"  (active command shown)
  *   "ralph"          → "rl:loop-name 3/50"
- *   "unipi-memory"   → "⚡ mem 75p/101all"
+ *   "unipi-memory"   → "⚡ MEM 75p/101all"
  *   "subagents"      → various
  */
 
@@ -15,20 +15,20 @@ import type { FooterSegment, FooterSegmentContext, RenderedSegment } from "../ty
 import { getIcon } from "../rendering/icons.js";
 import { loadFooterSettings } from "../config.js";
 import { getSeparator } from "../rendering/separators.js";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 
 /** Map status keys to short display names and segment IDs for icons */
 const STATUS_DISPLAY: Record<string, { short: string; segmentId: string }> = {
-  "unipi-workflow": { short: "wf", segmentId: "currentCommand" },
-  workflow: { short: "wf", segmentId: "currentCommand" },
-  ralph: { short: "rl", segmentId: "activeLoops" },
-  "unipi-memory": { short: "mem", segmentId: "projectCount" },
-  memory: { short: "mem", segmentId: "projectCount" },
-  compactor: { short: "cmp", segmentId: "compactions" },
-  mcp: { short: "mcp", segmentId: "serversTotal" },
-  notify: { short: "ntf", segmentId: "platformsEnabled" },
-  kanboard: { short: "kb", segmentId: "docsCount" },
-  info: { short: "info", segmentId: "extensionStatuses" },
-  subagents: { short: "sa", segmentId: "extensionStatuses" },
+  "unipi-workflow": { short: "WF", segmentId: "currentCommand" },
+  workflow: { short: "WF", segmentId: "currentCommand" },
+  ralph: { short: "RL", segmentId: "activeLoops" },
+  memory: { short: "MEM", segmentId: "projectCount" },
+  compactor: { short: "CMP", segmentId: "compactions" },
+  mcp: { short: "MCP", segmentId: "serversTotal" },
+  notify: { short: "NTF", segmentId: "platformsEnabled" },
+  kanboard: { short: "KB", segmentId: "docsCount" },
+  info: { short: "INF", segmentId: "extensionStatuses" },
+  subagents: { short: "SA", segmentId: "extensionStatuses" },
 };
 
 /** Get the separator character for the current settings */
@@ -110,10 +110,15 @@ function renderExtensionStatusesSegment(ctx: FooterSegmentContext): RenderedSegm
 
   if (parts.length === 0) return { content: "", visible: false };
 
+  // Clamp total content to terminal width to prevent TUI crash
   const content = parts.join(` ${sep} `);
+  const maxW = ctx.width > 0 ? ctx.width : 120;
+  if (visibleWidth(content) > maxW) {
+    return { content: truncateToWidth(content, maxW, "…"), visible: true };
+  }
   return { content, visible: true };
 }
 
 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

@@ -10,8 +10,7 @@ import type { FooterSegment, FooterSegmentContext, RenderedSegment, SemanticColo
 import { applyColor } from "../rendering/theme.js";
 import { getIcon } from "../rendering/icons.js";
 
-/** Nerd Font icon for workflow:  */
-const WORKFLOW_ICON = "\uf52e";
+
 
 function withIcon(segmentId: string, text: string): string {
   const icon = getIcon(segmentId);
@@ -24,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 {
@@ -46,15 +67,17 @@ function renderCurrentCommandSegment(ctx: FooterSegmentContext): RenderedSegment
   const active = data.active === true;
   const command = data.command as string | undefined;
 
+  const workflowIcon = getIcon("currentCommand");
+
   // No workflow — show dash
   if (!command) {
-    const content = `${WORKFLOW_ICON} -`;
+    const content = withIcon("currentCommand", "-");
     return { content: applyColor("workflow", content, ctx.theme, ctx.colors), visible: true };
   }
 
   const statusPrefix = active ? "▶" : "✓";
   const semanticColor = getWorkflowSemanticColor(command);
-  const content = `${WORKFLOW_ICON} ${statusPrefix} ${command}`;
+  const content = `${workflowIcon} ${statusPrefix} ${command}`;
   return { content: applyColor(semanticColor, content, ctx.theme, ctx.colors), visible: true };
 }
 
@@ -94,7 +117,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();