pi-messenger 0.7.3

package/crew/utils/progress.ts

@@ -0,0 +1,107 @@
+/**
+ * Crew - Progress Tracking
+ * 
+ * Real-time visibility into agent execution via --mode json event parsing.
+ */
+
+export interface AgentProgress {
+  agent: string;
+  status: "pending" | "running" | "completed" | "failed";
+  currentTool?: string;
+  currentToolArgs?: string;
+  recentTools: Array<{ tool: string; args: string; endMs: number }>;
+  tokens: number;
+  durationMs: number;
+  error?: string;
+}
+
+// Event types from pi's --mode json output
+interface PiEvent {
+  type: string;
+  toolName?: string;
+  args?: Record<string, unknown>;
+  message?: {
+    role: string;
+    usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number };
+    model?: string;
+    content?: Array<{ type: string; text?: string }>;
+    errorMessage?: string;
+  };
+}
+
+export function createProgress(agent: string): AgentProgress {
+  return {
+    agent,
+    status: "pending",
+    recentTools: [],
+    tokens: 0,
+    durationMs: 0,
+  };
+}
+
+export function parseJsonlLine(line: string): PiEvent | null {
+  if (!line.trim()) return null;
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+export function updateProgress(progress: AgentProgress, event: PiEvent, startTime: number): void {
+  progress.durationMs = Date.now() - startTime;
+
+  switch (event.type) {
+    case "tool_execution_start":
+      progress.status = "running";
+      progress.currentTool = event.toolName;
+      progress.currentToolArgs = extractArgsPreview(event.args);
+      break;
+
+    case "tool_execution_end":
+      if (progress.currentTool) {
+        progress.recentTools.unshift({
+          tool: progress.currentTool,
+          args: progress.currentToolArgs ?? "",
+          endMs: Date.now(),
+        });
+        if (progress.recentTools.length > 5) progress.recentTools.pop();
+      }
+      progress.currentTool = undefined;
+      progress.currentToolArgs = undefined;
+      break;
+
+    case "message_end":
+      if (event.message?.usage) {
+        progress.tokens += (event.message.usage.input ?? 0) + (event.message.usage.output ?? 0);
+      }
+      if (event.message?.errorMessage) {
+        progress.error = event.message.errorMessage;
+      }
+      break;
+  }
+}
+
+function extractArgsPreview(args?: Record<string, unknown>): string {
+  if (!args) return "";
+  const previewKeys = ["command", "path", "file_path", "pattern", "query"];
+  for (const key of previewKeys) {
+    if (args[key] && typeof args[key] === "string") {
+      const value = args[key] as string;
+      return value.length > 60 ? `${value.slice(0, 57)}...` : value;
+    }
+  }
+  return "";
+}
+
+export function getFinalOutput(messages: PiEvent[]): string {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.type === "message_end" && msg.message?.role === "assistant") {
+      for (const part of msg.message.content ?? []) {
+        if (part.type === "text" && part.text) return part.text;
+      }
+    }
+  }
+  return "";
+}

package/crew/utils/result.ts

@@ -0,0 +1,16 @@
+/**
+ * Crew - Result Formatter
+ * 
+ * Helper for consistent tool result formatting.
+ */
+
+/**
+ * Format a tool result with text content and structured details.
+ * Matches the pattern used throughout pi-messenger handlers.
+ */
+export function result(text: string, details: Record<string, unknown>) {
+  return {
+    content: [{ type: "text" as const, text }],
+    details
+  };
+}

package/crew/utils/truncate.ts

@@ -0,0 +1,79 @@
+/**
+ * Crew - Output Truncation
+ * 
+ * Prevents token explosion from verbose agent outputs.
+ */
+
+export interface MaxOutputConfig {
+  bytes?: number;
+  lines?: number;
+}
+
+export interface TruncationResult {
+  text: string;
+  truncated: boolean;
+  originalBytes?: number;
+  originalLines?: number;
+  artifactPath?: string;
+}
+
+export const DEFAULT_MAX_OUTPUT: Required<MaxOutputConfig> = {
+  bytes: 200 * 1024,  // 200KB
+  lines: 5000,
+};
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+/**
+ * Truncate output to fit within limits.
+ */
+export function truncateOutput(
+  output: string,
+  config: MaxOutputConfig,
+  artifactPath?: string
+): TruncationResult {
+  const maxBytes = config.bytes ?? DEFAULT_MAX_OUTPUT.bytes;
+  const maxLines = config.lines ?? DEFAULT_MAX_OUTPUT.lines;
+
+  const lines = output.split("\n");
+  const bytes = Buffer.byteLength(output, "utf-8");
+
+  if (bytes <= maxBytes && lines.length <= maxLines) {
+    return { text: output, truncated: false };
+  }
+
+  // Truncate by lines first
+  let truncatedLines = lines.length > maxLines ? lines.slice(0, maxLines) : lines;
+  let result = truncatedLines.join("\n");
+
+  // Then truncate by bytes if still too large
+  if (Buffer.byteLength(result, "utf-8") > maxBytes) {
+    // Binary search for the right cut point
+    let low = 0, high = result.length;
+    while (low < high) {
+      const mid = Math.floor((low + high + 1) / 2);
+      if (Buffer.byteLength(result.slice(0, mid), "utf-8") <= maxBytes) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    result = result.slice(0, low);
+  }
+
+  const keptLines = result.split("\n").length;
+  const fullOutputHint = artifactPath ? ` - full output at ${artifactPath}` : "";
+  const marker = `[TRUNCATED: ${keptLines}/${lines.length} lines, ${formatBytes(Buffer.byteLength(result))}/${formatBytes(bytes)}${fullOutputHint}]\n`;
+
+  return {
+    text: marker + result,
+    truncated: true,
+    originalBytes: bytes,
+    originalLines: lines.length,
+    artifactPath,
+  };
+}

package/crew-overlay.ts

@@ -0,0 +1,259 @@
+/**
+ * Crew Overlay - Task Visualization
+ * 
+ * Renders the Crew tab content for the messenger overlay.
+ * Shows flat task list under PRD name with status and dependencies.
+ */
+
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import * as crewStore from "./crew/store.js";
+import { autonomousState } from "./crew/state.js";
+import type { Task } from "./crew/types.js";
+
+// Status icons
+const STATUS_ICONS: Record<string, string> = {
+  done: "✓",
+  in_progress: "●",
+  todo: "○",
+  blocked: "✗",
+};
+
+export interface CrewViewState {
+  scrollOffset: number;
+  selectedTaskIndex: number;
+}
+
+export function createCrewViewState(): CrewViewState {
+  return {
+    scrollOffset: 0,
+    selectedTaskIndex: 0,
+  };
+}
+
+/**
+ * Render the crew overview content - flat task list under PRD.
+ */
+export function renderCrewContent(
+  theme: Theme,
+  cwd: string,
+  width: number,
+  height: number,
+  viewState: CrewViewState
+): string[] {
+  const lines: string[] = [];
+  const plan = crewStore.getPlan(cwd);
+
+  if (!plan) {
+    return renderEmptyState(theme, width, height);
+  }
+
+  const tasks = crewStore.getTasks(cwd);
+  
+  // Header: PRD with progress
+  const pct = plan.task_count > 0 ? Math.round((plan.completed_count / plan.task_count) * 100) : 0;
+  const progressText = `[${plan.completed_count}/${plan.task_count}]`;
+  const prdLine = `📋 ${plan.prd}`;
+  const prdWidth = visibleWidth(prdLine);
+  const progressWidth = visibleWidth(progressText);
+  const padding = Math.max(1, width - prdWidth - progressWidth - 2);
+  
+  lines.push(prdLine + " ".repeat(padding) + theme.fg("accent", progressText));
+  lines.push("");
+
+  // Task list
+  if (tasks.length === 0) {
+    lines.push(theme.fg("dim", "  (no tasks yet)"));
+  } else {
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i];
+      const taskLine = renderTaskLine(theme, task, i === viewState.selectedTaskIndex, width);
+      lines.push(taskLine);
+    }
+  }
+
+  // Add legend
+  lines.push("");
+  lines.push(renderLegend(theme, width));
+
+  // Ensure we fill the height
+  while (lines.length < height) {
+    lines.push("");
+  }
+
+  // Handle scrolling if content exceeds height
+  if (lines.length > height) {
+    const startIdx = Math.min(viewState.scrollOffset, lines.length - height);
+    return lines.slice(startIdx, startIdx + height);
+  }
+
+  return lines.slice(0, height);
+}
+
+/**
+ * Render the status bar for autonomous mode.
+ */
+export function renderCrewStatusBar(theme: Theme, cwd: string, width: number): string {
+  const plan = crewStore.getPlan(cwd);
+  
+  if (!plan) {
+    return theme.fg("dim", "No active plan");
+  }
+
+  if (!autonomousState.active) {
+    // Show plan progress
+    const progress = `${plan.completed_count}/${plan.task_count}`;
+    const ready = crewStore.getReadyTasks(cwd);
+    const readyText = ready.length > 0 ? ` │ ${ready.length} ready` : "";
+    return truncateToWidth(
+      `📋 ${plan.prd}: ${progress} tasks${readyText}`,
+      width
+    );
+  }
+
+  // Autonomous mode active
+  const progress = `${plan.completed_count}/${plan.task_count}`;
+  
+  // Calculate elapsed time
+  let elapsed = "";
+  if (autonomousState.startedAt) {
+    const startTime = new Date(autonomousState.startedAt).getTime();
+    const elapsedMs = Date.now() - startTime;
+    const minutes = Math.floor(elapsedMs / 60000);
+    const seconds = Math.floor((elapsedMs % 60000) / 1000);
+    elapsed = `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  }
+
+  const readyTasks = crewStore.getReadyTasks(cwd);
+  
+  const parts = [
+    `Wave ${autonomousState.waveNumber}`,
+    `${progress} tasks`,
+    `${readyTasks.length} ready`,
+  ];
+  
+  if (elapsed) {
+    parts.push(`⏱️ ${elapsed}`);
+  }
+
+  return truncateToWidth(
+    theme.fg("accent", "● AUTO ") + parts.join(" │ "),
+    width
+  );
+}
+
+// =============================================================================
+// Private Helpers
+// =============================================================================
+
+function renderEmptyState(theme: Theme, width: number, height: number): string[] {
+  const lines: string[] = [];
+  const msg = "No active plan";
+  const hint = "Use pi_messenger({ action: \"plan\" })";
+  
+  const padTop = Math.floor((height - 3) / 2);
+  for (let i = 0; i < padTop; i++) lines.push("");
+  
+  const pad1 = " ".repeat(Math.max(0, Math.floor((width - msg.length) / 2)));
+  lines.push(pad1 + msg);
+  lines.push("");
+  const pad2 = " ".repeat(Math.max(0, Math.floor((width - hint.length) / 2)));
+  lines.push(pad2 + theme.fg("dim", hint));
+  
+  while (lines.length < height) lines.push("");
+  return lines;
+}
+
+function renderTaskLine(
+  theme: Theme,
+  task: Task,
+  isSelected: boolean,
+  width: number
+): string {
+  const icon = STATUS_ICONS[task.status] ?? "?";
+  const selectIndicator = isSelected ? theme.fg("accent", "▸ ") : "  ";
+  
+  // Color the icon based on status
+  let coloredIcon: string;
+  switch (task.status) {
+    case "done":
+      coloredIcon = theme.fg("accent", icon);
+      break;
+    case "in_progress":
+      coloredIcon = theme.fg("warning", icon);
+      break;
+    case "blocked":
+      coloredIcon = theme.fg("error", icon);
+      break;
+    default:
+      coloredIcon = theme.fg("dim", icon);
+  }
+
+  // Build task suffix (assigned agent or dependencies)
+  let suffix = "";
+  if (task.status === "in_progress" && task.assigned_to) {
+    suffix = ` (${task.assigned_to})`;
+  } else if (task.status === "todo" && task.depends_on.length > 0) {
+    suffix = ` → deps: ${task.depends_on.join(", ")}`;
+  } else if (task.status === "blocked" && task.blocked_reason) {
+    // Truncate block reason
+    const reason = task.blocked_reason.slice(0, 20);
+    suffix = ` [${reason}${task.blocked_reason.length > 20 ? "…" : ""}]`;
+  }
+
+  const line = `${selectIndicator}${coloredIcon} ${task.id}  ${task.title}`;
+  const fullLine = line + theme.fg("dim", suffix);
+  
+  return truncateToWidth(fullLine, width);
+}
+
+function renderLegend(theme: Theme, width: number): string {
+  const items = [
+    `${theme.fg("accent", STATUS_ICONS.done)} done`,
+    `${theme.fg("warning", STATUS_ICONS.in_progress)} in_progress`,
+    `${theme.fg("dim", STATUS_ICONS.todo)} todo`,
+    `${theme.fg("error", STATUS_ICONS.blocked)} blocked`,
+  ];
+  
+  const legend = "Legend: " + items.join("  ");
+  return truncateToWidth(theme.fg("dim", legend), width);
+}
+
+/**
+ * Navigate to next/prev task.
+ */
+export function navigateTask(viewState: CrewViewState, direction: 1 | -1, taskCount: number): void {
+  if (taskCount === 0) return;
+  viewState.selectedTaskIndex = Math.max(
+    0,
+    Math.min(taskCount - 1, viewState.selectedTaskIndex + direction)
+  );
+}
+
+/**
+ * Get the currently selected task ID.
+ */
+export function getSelectedTaskId(cwd: string, viewState: CrewViewState): string | null {
+  const tasks = crewStore.getTasks(cwd);
+  if (viewState.selectedTaskIndex >= 0 && viewState.selectedTaskIndex < tasks.length) {
+    return tasks[viewState.selectedTaskIndex].id;
+  }
+  return null;
+}
+
+// Legacy exports for compatibility (no-ops now that epics are removed)
+export function toggleEpicExpansion(_viewState: CrewViewState, _epicId: string): void {
+  // No-op - epics removed
+}
+
+export function navigateEpic(viewState: CrewViewState, direction: 1 | -1, _epicCount: number): void {
+  // Redirect to task navigation
+  const cwd = process.cwd();
+  const tasks = crewStore.getTasks(cwd);
+  navigateTask(viewState, direction, tasks.length);
+}
+
+export function getSelectedEpicId(_cwd: string, _viewState: CrewViewState): string | null {
+  // No-op - epics removed
+  return null;
+}