supipowers 0.7.11 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.7.11",
+  "version": "0.8.0",
   "description": "OMP-native workflow extension inspired by supipowers.",
   "type": "module",
   "scripts": {
@@ -38,7 +38,9 @@
     "@oh-my-pi/pi-coding-agent": "latest",
     "@oh-my-pi/pi-tui": "latest",
     "@sinclair/typebox": "^0.34.48",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
+    "better-sqlite3": "^12.8.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"
   },

package/src/commands/run.ts

@@ -27,7 +27,7 @@ import { buildWorktreePrompt } from "../git/worktree.js";
 import { buildBranchFinishPrompt } from "../git/branch-finish.js";
 import { detectBaseBranch } from "../git/base-branch.js";
 import type { RunManifest, AgentResult } from "../types.js";
-import { AgentGridWidget, createAgentGridFactory } from "../orchestrator/agent-grid.js";
+import { RunProgressState, activeRuns } from "../orchestrator/run-progress.js";
 
 interface ParsedRunArgs {
   profile?: string;
@@ -90,7 +90,17 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             updateRun(ctx.cwd, manifest);
             manifest = null;
           } else {
-            notifyInfo(ctx, `Resuming run: ${manifest.id}`);
+            const completedBatches = manifest.batches.filter((b) => b.status === "completed").length;
+            const totalBatches = manifest.batches.length;
+            const completedTasks = manifest.batches
+              .filter((b) => b.status === "completed")
+              .reduce((sum, b) => sum + b.taskIds.length, 0);
+            const totalTasks = manifest.batches.reduce((sum, b) => sum + b.taskIds.length, 0);
+            notifyInfo(
+              ctx,
+              `Resuming run: ${manifest.id}`,
+              `${completedTasks}/${totalTasks} tasks done, ${completedBatches}/${totalBatches} batches completed`,
+            );
           }
         } else {
           // No UI — resume automatically
@@ -176,21 +186,34 @@ export function registerRunCommand(pi: ExtensionAPI): void {
       const lsp = isLspAvailable(pi.getActiveTools());
       const ctxMode = detectContextMode(pi.getActiveTools()).available;
 
-      // Mount agent grid widget for live progress visualization
-      let widget: AgentGridWidget | undefined;
-      if (ctx.hasUI) {
-        const widgetReady = new Promise<AgentGridWidget>((resolve) => {
-          ctx.ui.setWidget("supi-agents", createAgentGridFactory((w) => {
-            widget = w;
-            for (const task of plan.tasks) {
-              w.addTask(task.id, task.name);
-            }
-            resolve(w);
-          }));
-        });
-        // Wait for TUI to instantiate the widget before dispatching agents
-        widget = await widgetReady;
+      // Create shared progress state and send inline progress message
+      const progress = new RunProgressState();
+      for (const task of plan.tasks) {
+        const deps = task.parallelism.type === "sequential" ? task.parallelism.dependsOn : [];
+        progress.addTask(task.id, task.name, deps);
+      }
+      // On resume, mark already-completed tasks
+      const existingResults = loadAllAgentResults(ctx.cwd, manifest!.id);
+      for (const result of existingResults) {
+        if (result.status === "done") {
+          progress.setStatus(result.taskId, "done");
+        } else if (result.status === "done_with_concerns") {
+          progress.setStatus(result.taskId, "done_with_concerns", result.concerns);
+        } else if (result.status === "blocked") {
+          progress.setStatus(result.taskId, "blocked", result.output);
+        }
       }
+      activeRuns.set(manifest.id, progress);
+
+      // Send inline progress message — the registered renderer will display it
+      pi.sendMessage(
+        {
+          customType: "supi-run-progress",
+          content: [{ type: "text", text: "Running tasks..." }],
+          display: "custom",
+          details: { runId: manifest.id },
+        },
+      );
 
       try {
       for (const batch of manifest.batches) {
@@ -204,6 +227,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
           `Batch ${batch.index + 1}/${manifest.batches.length}`,
           `${batch.taskIds.length} tasks`
         );
+        progress.batchLabel = `Batch ${batch.index + 1}/${manifest.batches.length}`;
 
         const batchResults: AgentResult[] = [];
         const agentPromises = batch.taskIds.map((taskId) => {
@@ -218,7 +242,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
             config,
             lspAvailable: lsp,
             contextModeAvailable: ctxMode,
-            widget,
+            progress,
           });
         });
 
@@ -255,7 +279,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
                 config,
                 lspAvailable: lsp,
                 contextModeAvailable: ctxMode,
-                widget,
+                progress,
                 previousOutput: failed.output,
                 failureReason: failed.output,
               });
@@ -314,11 +338,7 @@ export function registerRunCommand(pi: ExtensionAPI): void {
         notifyInfo(ctx, "Run succeeded", "Follow branch finish instructions to integrate your work");
       }
       } finally {
-        // Ensure widget interval timer is cleaned up even on exception
-        widget?.dispose();
-        if (ctx.hasUI) {
-          ctx.ui.setWidget("supi-agents", undefined);
-        }
+        activeRuns.delete(manifest.id);
       }
     },
   });

package/src/index.ts

@@ -15,6 +15,7 @@ import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
 import { registerFixPrCommand } from "./commands/fix-pr.js";
 import { loadConfig } from "./config/loader.js";
 import { registerContextModeHooks } from "./context-mode/hooks.js";
+import { registerProgressRenderer } from "./orchestrator/progress-renderer.js";
 
 // TUI-only commands — intercepted at the input level to prevent
 // message submission and "Working..." indicator
@@ -48,6 +49,9 @@ export default function supipowers(pi: ExtensionAPI): void {
   registerUpdateCommand(pi);
   registerFixPrCommand(pi);
 
+  // Register custom message renderers
+  registerProgressRenderer(pi);
+
   // Intercept TUI-only commands at the input level — this runs BEFORE
   // message submission, so no chat message appears and no "Working..." indicator
   pi.on("input", (event, ctx) => {

package/src/orchestrator/dispatcher.ts

@@ -18,7 +18,7 @@ import {
   notifyError,
   notifyInfo,
 } from "../notifications/renderer.js";
-import type { AgentGridWidget } from "./agent-grid.js";
+import type { RunProgressState } from "./run-progress.js";
 
 export interface DispatchOptions {
   pi: ExtensionAPI;
@@ -31,22 +31,22 @@ export interface DispatchOptions {
   config: SupipowersConfig;
   lspAvailable: boolean;
   contextModeAvailable: boolean;
-  widget?: AgentGridWidget;
+  progress?: RunProgressState;
 }
 
 export async function dispatchAgent(
   options: DispatchOptions,
 ): Promise<AgentResult> {
-  const { pi, ctx, task, planContext, config, lspAvailable, contextModeAvailable, widget } = options;
+  const { pi, ctx, task, planContext, config, lspAvailable, contextModeAvailable, progress } = options;
   const startTime = Date.now();
 
   const prompt = buildTaskPrompt(task, planContext, config, lspAvailable, contextModeAvailable);
 
   // Initialize widget card if available
-  widget?.setStatus(task.id, "running");
+  progress?.setStatus(task.id, "running");
 
   try {
-    const result = await executeSubAgent(pi, prompt, task, config, ctx, widget);
+    const result = await executeSubAgent(pi, prompt, task, config, ctx, progress);
 
     const agentResult: AgentResult = {
       taskId: task.id,
@@ -60,15 +60,15 @@ export async function dispatchAgent(
     // Update widget with final status
     switch (agentResult.status) {
       case "done":
-        widget?.setStatus(task.id, "done");
+        progress?.setStatus(task.id, "done");
         notifySuccess(ctx, `Task ${task.id} completed`, task.name);
         break;
       case "done_with_concerns":
-        widget?.setStatus(task.id, "done_with_concerns", agentResult.concerns);
+        progress?.setStatus(task.id, "done_with_concerns", agentResult.concerns);
         notifyWarning(ctx, `Task ${task.id} done with concerns`, agentResult.concerns);
         break;
       case "blocked":
-        widget?.setStatus(task.id, "blocked", agentResult.output);
+        progress?.setStatus(task.id, "blocked", agentResult.output);
         notifyError(ctx, `Task ${task.id} blocked`, agentResult.output);
         break;
     }
@@ -76,7 +76,7 @@ export async function dispatchAgent(
     return agentResult;
   } catch (error) {
     const errorMsg = `Agent error: ${error instanceof Error ? error.message : String(error)}`;
-    widget?.setStatus(task.id, "blocked", errorMsg);
+    progress?.setStatus(task.id, "blocked", errorMsg);
 
     const agentResult: AgentResult = {
       taskId: task.id,
@@ -131,7 +131,7 @@ async function executeSubAgent(
   task: PlanTask,
   config: SupipowersConfig,
   ctx?: NotifyCtx,
-  widget?: AgentGridWidget,
+  progress?: RunProgressState,
 ): Promise<SubAgentResult> {
   const { createAgentSession } = pi.pi;
 
@@ -160,8 +160,8 @@ async function executeSubAgent(
       const preview = content.split("\n").filter(Boolean).pop()?.slice(0, 80) ?? "";
       if (preview && preview !== lastThinkingPreview) {
         lastThinkingPreview = preview;
-        if (widget) {
-          widget.setThinking(task.id, preview);
+        if (progress) {
+          progress.setActivity(task.id, preview);
         } else if (ctx) {
           ctx.ui.notify(`${tag}: thinking — ${preview}`, "info");
         }
@@ -172,8 +172,9 @@ async function executeSubAgent(
       if (FILE_TOOLS.has(event.toolName) && args?.file_path) {
         pendingToolArgs.set(event.toolCallId, args);
       }
-      if (widget) {
-        widget.addActivity(task.id, formatToolAction(event.toolName, args));
+      if (progress) {
+        progress.setActivity(task.id, formatToolAction(event.toolName, args));
+        progress.incrementTools(task.id);
       } else if (ctx) {
         ctx.ui.notify(`${tag}: ${formatToolAction(event.toolName, args)}`, "info");
       }
@@ -182,7 +183,7 @@ async function executeSubAgent(
       const args = pendingToolArgs.get(event.toolCallId);
       if (args?.file_path && !event.isError) {
         filesChanged.add(String(args.file_path));
-        widget?.addFileChanged(task.id);
+        progress?.incrementFiles(task.id);
       }
       pendingToolArgs.delete(event.toolCallId);
     }
@@ -275,7 +276,7 @@ export async function dispatchAgentWithReview(
   }
 
   // Step 2: Spec compliance review
-  options.widget?.setStatus(task.id, "reviewing");
+  options.progress?.setStatus(task.id, "reviewing");
   for (let attempt = 0; attempt <= maxReviewRetries; attempt++) {
     const specReview = await dispatchSpecReview(
       pi,
@@ -319,7 +320,7 @@ export async function dispatchAgentWithReview(
   }
 
   // Step 3: Code quality review
-  options.widget?.setStatus(task.id, "reviewing");
+  options.progress?.setStatus(task.id, "reviewing");
   for (let attempt = 0; attempt <= maxReviewRetries; attempt++) {
     const qualityReview = await dispatchQualityReview(
       pi,
@@ -422,7 +423,7 @@ async function dispatchQualityReview(
 export async function dispatchFixAgent(
   options: DispatchOptions & { previousOutput: string; failureReason: string },
 ): Promise<AgentResult> {
-  const { pi, ctx, task, config, lspAvailable, contextModeAvailable, previousOutput, failureReason, widget } =
+  const { pi, ctx, task, config, lspAvailable, contextModeAvailable, previousOutput, failureReason, progress } =
     options;
   const startTime = Date.now();
 
@@ -434,10 +435,10 @@ export async function dispatchFixAgent(
     contextModeAvailable,
   );
 
-  widget?.setStatus(task.id, "running");
+  progress?.setStatus(task.id, "running");
 
   try {
-    const result = await executeSubAgent(pi, prompt, task, config, ctx, widget);
+    const result = await executeSubAgent(pi, prompt, task, config, ctx, progress);
     return {
       taskId: task.id,
       status: result.status,

package/src/orchestrator/progress-renderer.ts

@@ -0,0 +1,180 @@
+// src/orchestrator/progress-renderer.ts
+import type { TaskStatus } from "./agent-grid.js";
+import { activeRuns, type TaskProgress } from "./run-progress.js";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+interface Theme {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+  sep: { dot: string };
+  tree: {
+    branch: string;
+    last: string;
+    vertical: string;
+    hook: string;
+  };
+}
+
+interface Component {
+  render(width: number): string[];
+  invalidate(): void;
+}
+
+interface CustomMessage<T> {
+  details: T;
+}
+
+interface RunProgressDetails {
+  runId: string;
+}
+
+type MessageRenderer<T> = (
+  message: CustomMessage<T>,
+  options: { expanded: boolean },
+  theme: Theme,
+) => Component | undefined;
+
+interface ExtensionAPI {
+  registerMessageRenderer<T>(customType: string, renderer: MessageRenderer<T>): void;
+}
+
+// ── Constants ──────────────────────────────────────────────────────
+
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+interface StatusConfig {
+  color: string;
+  icon: (frame: number) => string;
+}
+
+const STATUS_CONFIG: Record<TaskStatus, StatusConfig> = {
+  pending:            { color: "dim",     icon: () => "○" },
+  running:            { color: "accent",  icon: (f) => SPINNER_FRAMES[f % SPINNER_FRAMES.length] },
+  reviewing:          { color: "warning", icon: () => "◎" },
+  done:               { color: "success", icon: () => "✓" },
+  done_with_concerns: { color: "warning", icon: () => "⚠" },
+  blocked:            { color: "error",   icon: () => "✗" },
+};
+
+// ── Helper: format elapsed time ────────────────────────────────────
+
+function formatElapsed(startedAt: number, completedAt?: number): string {
+  const ms = (completedAt ?? Date.now()) - startedAt;
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  return rem > 0 ? `${m}m${rem}s` : `${m}m`;
+}
+
+// ── Inline Progress Component ──────────────────────────────────────
+
+class InlineProgressComponent implements Component {
+  #runId: string;
+  #theme: Theme;
+  #spinnerFrame = 0;
+
+  constructor(runId: string, theme: Theme) {
+    this.#runId = runId;
+    this.#theme = theme;
+  }
+
+  render(_width: number): string[] {
+    // Advance spinner on every render call (called each repaint)
+    this.#spinnerFrame = (this.#spinnerFrame + 1) % SPINNER_FRAMES.length;
+
+    const state = activeRuns.get(this.#runId);
+    if (!state || state.tasks.size === 0) return [];
+
+    const tasks = [...state.tasks.values()];
+    const lines: string[] = [];
+    const tree = this.#theme.tree;
+    const sep = this.#theme.sep.dot;
+
+    tasks.forEach((task, idx) => {
+      const isLast = idx === tasks.length - 1;
+      const prefix = isLast ? tree.last : tree.branch;
+      const cfg = STATUS_CONFIG[task.status];
+      const icon = this.#theme.fg(cfg.color, cfg.icon(this.#spinnerFrame));
+      const taskLabel = this.#theme.fg(cfg.color, `T${task.taskId}`);
+      const name = this.#theme.bold(task.name);
+
+      const parts: string[] = [`${prefix} ${icon} ${taskLabel} ${sep} ${name}`];
+      this.#appendTaskMeta(task, parts, sep);
+
+      // Show dependencies for pending tasks
+      if (task.status === "pending" && task.dependsOn.length > 0) {
+        const depLabels = task.dependsOn.map((d) => `T${d}`).join(", ");
+        parts.push(` ${sep} `);
+        parts.push(this.#theme.fg("dim", `Depends on ${depLabels}`));
+      }
+
+      lines.push(parts.join(""));
+    });
+
+    // Summary line
+    const summary = state.summary;
+    const summaryParts: string[] = [];
+    if (state.batchLabel) summaryParts.push(this.#theme.fg("muted", state.batchLabel));
+    if (summary.done > 0)    summaryParts.push(this.#theme.fg("success", `${summary.done} done`));
+    if (summary.running > 0) summaryParts.push(this.#theme.fg("accent",  `${summary.running} running`));
+    if (summary.pending > 0) summaryParts.push(this.#theme.fg("dim",     `${summary.pending} pending`));
+    if (summary.blocked > 0) summaryParts.push(this.#theme.fg("error",   `${summary.blocked} blocked`));
+
+    if (summaryParts.length > 0) {
+      const indent = `  `; // align under tree
+      lines.push(`${indent}${summaryParts.join(` ${sep} `)}`);
+    }
+
+    return lines;
+  }
+
+  invalidate(): void {
+    // No cache to bust — we render fresh each time
+  }
+
+  // ── Private ────────────────────────────────────────────────────
+
+  #appendTaskMeta(task: TaskProgress, parts: string[], sep: string): void {
+    const isActive = task.status === "running" || task.status === "reviewing";
+    const isDone =
+      task.status === "done" ||
+      task.status === "done_with_concerns" ||
+      task.status === "blocked";
+
+    if (task.toolCount > 0) {
+      parts.push(` ${sep} `);
+      parts.push(this.#theme.fg("muted", `${task.toolCount} tools`));
+    }
+
+    if (isDone && task.filesChanged > 0) {
+      parts.push(` ${sep} `);
+      parts.push(this.#theme.fg("muted", `${task.filesChanged} files`));
+    }
+
+    if (isDone) {
+      const elapsed = formatElapsed(task.startedAt, task.completedAt);
+      parts.push(` ${sep} `);
+      parts.push(this.#theme.fg("muted", elapsed));
+    }
+
+    if (isActive && task.currentActivity) {
+      parts.push(` ${sep} `);
+      parts.push(this.#theme.fg("dim", task.currentActivity));
+    }
+  }
+}
+
+// ── Registration ───────────────────────────────────────────────────
+
+export function registerProgressRenderer(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer<RunProgressDetails>(
+    "supi-run-progress",
+    (message, _options, theme) => {
+      const { runId } = message.details;
+      if (!runId) return undefined;
+      return new InlineProgressComponent(runId, theme);
+    },
+  );
+}

package/src/orchestrator/run-progress.ts

@@ -0,0 +1,78 @@
+// src/orchestrator/run-progress.ts
+import type { TaskStatus } from "./agent-grid.js";
+
+export interface TaskProgress {
+  taskId: number;
+  name: string;
+  status: TaskStatus;
+  currentActivity: string;
+  toolCount: number;
+  filesChanged: number;
+  startedAt: number;
+  completedAt?: number;
+  errorReason?: string;
+  concerns?: string;
+  dependsOn: number[];
+}
+
+/** Shared state store for a single run — written by dispatcher, read by renderer */
+export class RunProgressState {
+  readonly tasks = new Map<number, TaskProgress>();
+  batchLabel = "";
+
+  addTask(taskId: number, name: string, dependsOn: number[] = []): void {
+    this.tasks.set(taskId, {
+      taskId,
+      name,
+      status: "pending",
+      currentActivity: "",
+      toolCount: 0,
+      filesChanged: 0,
+      startedAt: Date.now(),
+      dependsOn,
+    });
+  }
+
+  setStatus(taskId: number, status: TaskStatus, reason?: string): void {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.status = status;
+    if (status === "blocked") task.errorReason = reason;
+    if (status === "done_with_concerns") task.concerns = reason;
+    if (status === "done" || status === "done_with_concerns" || status === "blocked") {
+      task.completedAt = Date.now();
+    }
+  }
+
+  setActivity(taskId: number, activity: string): void {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.currentActivity = activity;
+  }
+
+  incrementTools(taskId: number): void {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.toolCount++;
+  }
+
+  incrementFiles(taskId: number): void {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+    task.filesChanged++;
+  }
+
+  get summary() {
+    const all = [...this.tasks.values()];
+    return {
+      total: all.length,
+      done: all.filter((t) => t.status === "done" || t.status === "done_with_concerns").length,
+      running: all.filter((t) => t.status === "running" || t.status === "reviewing").length,
+      blocked: all.filter((t) => t.status === "blocked").length,
+      pending: all.filter((t) => t.status === "pending").length,
+    };
+  }
+}
+
+/** Module-level store: runId → state. Renderer reads from here. */
+export const activeRuns = new Map<string, RunProgressState>();