supipowers 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "OMP-native workflow extension inspired by Superpowers.",
   "type": "module",
   "scripts": {

package/src/commands/config.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig, updateConfig } from "../config/loader.js";
 import { listProfiles } from "../config/profiles.js";
 import type { SupipowersConfig } from "../types.js";
@@ -93,66 +93,69 @@ function buildSettings(cwd: string): SettingDef[] {
   ];
 }
 
-export function registerConfigCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi:config", {
-    description: "View and manage Supipowers configuration",
-    async handler(_args, ctx) {
-      if (!ctx.hasUI) {
-        ctx.ui.notify("Config UI requires interactive mode", "warning");
-        return;
-      }
+export function handleConfig(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("Config UI requires interactive mode", "warning");
+    return;
+  }
 
-      ctx.ui.setEditorText("");
-      void (async () => {
-        const settings = buildSettings(ctx.cwd);
+  void (async () => {
+    const settings = buildSettings(ctx.cwd);
 
-        while (true) {
-          const config = loadConfig(ctx.cwd);
+    while (true) {
+      const config = loadConfig(ctx.cwd);
 
-          const options = settings.map(
-            (s) => `${s.label}: ${s.get(config)}`
-          );
-          options.push("Done");
+      const options = settings.map(
+        (s) => `${s.label}: ${s.get(config)}`
+      );
+      options.push("Done");
 
-          const choice = await ctx.ui.select(
-            "Supipowers Settings",
-            options,
-            { helpText: "Select a setting to change · Esc to close" },
-          );
+      const choice = await ctx.ui.select(
+        "Supipowers Settings",
+        options,
+        { helpText: "Select a setting to change · Esc to close" },
+      );
 
-          if (choice === undefined || choice === "Done") break;
+      if (choice === undefined || choice === "Done") break;
 
-          const index = options.indexOf(choice);
-          const setting = settings[index];
-          if (!setting) break;
+      const index = options.indexOf(choice);
+      const setting = settings[index];
+      if (!setting) break;
 
-          if (setting.type === "select" && setting.options) {
-            const value = await ctx.ui.select(
-              setting.label,
-              setting.options,
-              { initialIndex: setting.options.indexOf(setting.get(config)) },
-            );
-            if (value !== undefined) {
-              setting.set(ctx.cwd, value);
-              ctx.ui.notify(`${setting.label} → ${value}`, "info");
-            }
-          } else if (setting.type === "toggle") {
-            const current = setting.get(config);
-            const newValue = current === "on" ? "off" : "on";
-            setting.set(ctx.cwd, newValue);
-            ctx.ui.notify(`${setting.label} → ${newValue}`, "info");
-          } else if (setting.type === "text") {
-            const value = await ctx.ui.input(
-              setting.label,
-              setting.get(config) === "not set" ? undefined : setting.get(config),
-            );
-            if (value !== undefined) {
-              setting.set(ctx.cwd, value);
-              ctx.ui.notify(`${setting.label} → ${value || "cleared"}`, "info");
-            }
-          }
+      if (setting.type === "select" && setting.options) {
+        const value = await ctx.ui.select(
+          setting.label,
+          setting.options,
+          { initialIndex: setting.options.indexOf(setting.get(config)) },
+        );
+        if (value !== undefined) {
+          setting.set(ctx.cwd, value);
+          ctx.ui.notify(`${setting.label} → ${value}`, "info");
+        }
+      } else if (setting.type === "toggle") {
+        const current = setting.get(config);
+        const newValue = current === "on" ? "off" : "on";
+        setting.set(ctx.cwd, newValue);
+        ctx.ui.notify(`${setting.label} → ${newValue}`, "info");
+      } else if (setting.type === "text") {
+        const value = await ctx.ui.input(
+          setting.label,
+          setting.get(config) === "not set" ? undefined : setting.get(config),
+        );
+        if (value !== undefined) {
+          setting.set(ctx.cwd, value);
+          ctx.ui.notify(`${setting.label} → ${value || "cleared"}`, "info");
         }
-      })();
+      }
+    }
+  })();
+}
+
+export function registerConfigCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:config", {
+    description: "View and manage Supipowers configuration",
+    async handler(_args, ctx) {
+      handleConfig(ctx);
     },
   });
 }

package/src/commands/status.ts

@@ -1,46 +1,48 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { findActiveRun, loadAllAgentResults } from "../storage/runs.js";
 
-export function registerStatusCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi:status", {
-    description: "Check on running sub-agents and task progress",
-    async handler(_args, ctx) {
-      ctx.ui.setEditorText("");
+export function handleStatus(ctx: ExtensionContext): void {
+  const activeRun = findActiveRun(ctx.cwd);
+  if (!activeRun) {
+    ctx.ui.notify("No active runs — use /supi:run to execute a plan", "info");
+    return;
+  }
 
-      const activeRun = findActiveRun(ctx.cwd);
-      if (!activeRun) {
-        ctx.ui.notify("No active runs — use /supi:run to execute a plan", "info");
-        return;
-      }
+  void (async () => {
+    const results = loadAllAgentResults(ctx.cwd, activeRun.id);
+    const totalTasks = activeRun.batches.reduce(
+      (sum, b) => sum + b.taskIds.length,
+      0
+    );
+    const doneCount = results.filter((r) => r.status === "done").length;
+    const concernCount = results.filter((r) => r.status === "done_with_concerns").length;
+    const blockedCount = results.filter((r) => r.status === "blocked").length;
+    const currentBatch = activeRun.batches.find((b) => b.status !== "completed");
 
-      void (async () => {
-        const results = loadAllAgentResults(ctx.cwd, activeRun.id);
-        const totalTasks = activeRun.batches.reduce(
-          (sum, b) => sum + b.taskIds.length,
-          0
-        );
-        const doneCount = results.filter((r) => r.status === "done").length;
-        const concernCount = results.filter((r) => r.status === "done_with_concerns").length;
-        const blockedCount = results.filter((r) => r.status === "blocked").length;
-        const currentBatch = activeRun.batches.find((b) => b.status !== "completed");
+    const options = [
+      `Run: ${activeRun.id}`,
+      `Status: ${activeRun.status}`,
+      `Plan: ${activeRun.planRef}`,
+      `Profile: ${activeRun.profile}`,
+      `Progress: ${results.length}/${totalTasks} tasks`,
+      `  Done: ${doneCount}`,
+      `  With concerns: ${concernCount}`,
+      `  Blocked: ${blockedCount}`,
+      `Batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "all complete"}`,
+      "Close",
+    ];
 
-        const options = [
-          `Run: ${activeRun.id}`,
-          `Status: ${activeRun.status}`,
-          `Plan: ${activeRun.planRef}`,
-          `Profile: ${activeRun.profile}`,
-          `Progress: ${results.length}/${totalTasks} tasks`,
-          `  Done: ${doneCount}`,
-          `  With concerns: ${concernCount}`,
-          `  Blocked: ${blockedCount}`,
-          `Batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "all complete"}`,
-          "Close",
-        ];
+    await ctx.ui.select("Supipowers Status", options, {
+      helpText: "Esc to close",
+    });
+  })();
+}
 
-        await ctx.ui.select("Supipowers Status", options, {
-          helpText: "Esc to close",
-        });
-      })();
+export function registerStatusCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:status", {
+    description: "Check on running sub-agents and task progress",
+    async handler(_args, ctx) {
+      handleStatus(ctx);
     },
   });
 }

package/src/commands/supi.ts

@@ -1,52 +1,56 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig } from "../config/loader.js";
 import { findActiveRun } from "../storage/runs.js";
 import { loadLatestReport } from "../storage/reports.js";
 import { listPlans } from "../storage/plans.js";
 
-export function registerSupiCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi", {
-    description: "Supipowers overview — show available commands and project status",
-    async handler(_args, ctx) {
-      ctx.ui.setEditorText("");
-      void (async () => {
-        const config = loadConfig(ctx.cwd);
-        const activeRun = findActiveRun(ctx.cwd);
-        const latestReport = loadLatestReport(ctx.cwd);
-        const plans = listPlans(ctx.cwd);
+export function handleSupi(pi: ExtensionAPI, ctx: ExtensionContext): void {
+  void (async () => {
+    const config = loadConfig(ctx.cwd);
+    const activeRun = findActiveRun(ctx.cwd);
+    const latestReport = loadLatestReport(ctx.cwd);
+    const plans = listPlans(ctx.cwd);
+
+    const commands = [
+      "/supi:plan     — Start collaborative planning",
+      "/supi:run      — Execute a plan with sub-agents",
+      "/supi:review   — Run quality gates",
+      "/supi:qa       — Run QA pipeline",
+      "/supi:release  — Release automation",
+      "/supi:config   — Manage configuration",
+      "/supi:status   — Check running tasks",
+      "/supi:update   — Update to latest version",
+    ];
 
-        const commands = [
-          "/supi:plan     — Start collaborative planning",
-          "/supi:run      — Execute a plan with sub-agents",
-          "/supi:review   — Run quality gates",
-          "/supi:qa       — Run QA pipeline",
-          "/supi:release  — Release automation",
-          "/supi:config   — Manage configuration",
-          "/supi:status   — Check running tasks",
-          "/supi:update   — Update to latest version",
-        ];
+    const status = [
+      `Profile: ${config.defaultProfile}`,
+      `Plans: ${plans.length}`,
+      `Active run: ${activeRun ? activeRun.id : "none"}`,
+      `Last review: ${latestReport ? `${latestReport.timestamp.slice(0, 10)} (${latestReport.passed ? "passed" : "failed"})` : "none"}`,
+    ];
 
-        const status = [
-          `Profile: ${config.defaultProfile}`,
-          `Plans: ${plans.length}`,
-          `Active run: ${activeRun ? activeRun.id : "none"}`,
-          `Last review: ${latestReport ? `${latestReport.timestamp.slice(0, 10)} (${latestReport.passed ? "passed" : "failed"})` : "none"}`,
-        ];
+    const choice = await ctx.ui.select(
+      "Supipowers",
+      [...commands, "", ...status, "", "Close"],
+      { helpText: "Select a command to run · Esc to close" },
+    );
 
-        const choice = await ctx.ui.select(
-          "Supipowers",
-          [...commands, "", ...status, "", "Close"],
-          { helpText: "Select a command to run · Esc to close" },
-        );
+    if (choice && choice.startsWith("/supi:")) {
+      const cmdName = choice.split(" ")[0].slice(1); // remove leading /
+      const cmd = pi.getCommands().find((c) => c.name === cmdName);
+      if (cmd) {
+        await cmd.handler("", ctx as any);
+      }
+    }
+  })();
+}
 
-        if (choice && choice.startsWith("/supi:")) {
-          const cmdName = choice.split(" ")[0].slice(1); // remove leading /
-          const cmd = pi.getCommands().find((c) => c.name === cmdName);
-          if (cmd) {
-            await cmd.handler("", ctx);
-          }
-        }
-      })();
+export function registerSupiCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi", {
+    description: "Supipowers overview — show available commands and project status",
+    async handler(_args, ctx) {
+      // Handled via input event interception — this is a fallback for non-interactive contexts
+      handleSupi(pi, ctx);
     },
   });
 }

package/src/commands/update.ts

@@ -1,100 +1,103 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
 import { readFileSync, existsSync, mkdirSync, cpSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
 
-export function registerUpdateCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi:update", {
-    description: "Update supipowers to the latest version",
-    async handler(_args, ctx) {
-      ctx.ui.setEditorText("");
-      void (async () => {
-        const ompAgent = join(homedir(), ".omp", "agent");
-        const extDir = join(ompAgent, "extensions", "supipowers");
-        const installedPkgPath = join(extDir, "package.json");
+export function handleUpdate(pi: ExtensionAPI, ctx: ExtensionContext): void {
+  void (async () => {
+    const ompAgent = join(homedir(), ".omp", "agent");
+    const extDir = join(ompAgent, "extensions", "supipowers");
+    const installedPkgPath = join(extDir, "package.json");
 
-        // Get current installed version
-        let currentVersion = "unknown";
-        if (existsSync(installedPkgPath)) {
-          try {
-            const pkg = JSON.parse(readFileSync(installedPkgPath, "utf8"));
-            currentVersion = pkg.version;
-          } catch {
-            // corrupted — will update anyway
-          }
-        }
-
-        ctx.ui.notify(`Current version: v${currentVersion}`, "info");
+    // Get current installed version
+    let currentVersion = "unknown";
+    if (existsSync(installedPkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(installedPkgPath, "utf8"));
+        currentVersion = pkg.version;
+      } catch {
+        // corrupted — will update anyway
+      }
+    }
 
-        // Check latest version on npm
-        const checkResult = await pi.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() });
-        if (checkResult.exitCode !== 0) {
-          ctx.ui.notify("Failed to check for updates — npm view failed", "error");
-          return;
-        }
-        const latestVersion = checkResult.stdout.trim();
+    ctx.ui.notify(`Current version: v${currentVersion}`, "info");
 
-        if (latestVersion === currentVersion) {
-          ctx.ui.notify(`supipowers v${currentVersion} is already up to date`, "info");
-          return;
-        }
+    // Check latest version on npm
+    const checkResult = await pi.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() });
+    if (checkResult.exitCode !== 0) {
+      ctx.ui.notify("Failed to check for updates — npm view failed", "error");
+      return;
+    }
+    const latestVersion = checkResult.stdout.trim();
 
-        ctx.ui.notify(`Updating v${currentVersion} → v${latestVersion}...`, "info");
+    if (latestVersion === currentVersion) {
+      ctx.ui.notify(`supipowers v${currentVersion} is already up to date`, "info");
+      return;
+    }
 
-        // Download latest to a temp directory
-        const tempDir = join(tmpdir(), `supipowers-update-${Date.now()}`);
-        mkdirSync(tempDir, { recursive: true });
+    ctx.ui.notify(`Updating v${currentVersion} → v${latestVersion}...`, "info");
 
-        try {
-          const installResult = await pi.exec(
-            "npm", ["install", "--prefix", tempDir, `supipowers@${latestVersion}`],
-            { cwd: tempDir },
-          );
-          if (installResult.exitCode !== 0) {
-            ctx.ui.notify("Failed to download latest version", "error");
-            return;
-          }
+    // Download latest to a temp directory
+    const tempDir = join(tmpdir(), `supipowers-update-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
 
-          const downloadedRoot = join(tempDir, "node_modules", "supipowers");
-          if (!existsSync(downloadedRoot)) {
-            ctx.ui.notify("Downloaded package not found", "error");
-            return;
-          }
+    try {
+      const installResult = await pi.exec(
+        "npm", ["install", "--prefix", tempDir, `supipowers@${latestVersion}`],
+        { cwd: tempDir },
+      );
+      if (installResult.exitCode !== 0) {
+        ctx.ui.notify("Failed to download latest version", "error");
+        return;
+      }
 
-          // Clean previous installation
-          if (existsSync(extDir)) {
-            rmSync(extDir, { recursive: true });
-          }
+      const downloadedRoot = join(tempDir, "node_modules", "supipowers");
+      if (!existsSync(downloadedRoot)) {
+        ctx.ui.notify("Downloaded package not found", "error");
+        return;
+      }
 
-          // Copy extension files
-          mkdirSync(extDir, { recursive: true });
-          cpSync(join(downloadedRoot, "src"), join(extDir, "src"), { recursive: true });
-          cpSync(join(downloadedRoot, "package.json"), join(extDir, "package.json"));
+      // Clean previous installation
+      if (existsSync(extDir)) {
+        rmSync(extDir, { recursive: true });
+      }
 
-          // Copy skills
-          const skillsSource = join(downloadedRoot, "skills");
-          if (existsSync(skillsSource)) {
-            const skillDirs = readdirSync(skillsSource, { withFileTypes: true });
-            for (const entry of skillDirs) {
-              if (!entry.isDirectory()) continue;
-              const skillFile = join(skillsSource, entry.name, "SKILL.md");
-              if (!existsSync(skillFile)) continue;
-              const destDir = join(ompAgent, "skills", entry.name);
-              mkdirSync(destDir, { recursive: true });
-              cpSync(skillFile, join(destDir, "SKILL.md"));
-            }
-          }
+      // Copy extension files
+      mkdirSync(extDir, { recursive: true });
+      cpSync(join(downloadedRoot, "src"), join(extDir, "src"), { recursive: true });
+      cpSync(join(downloadedRoot, "package.json"), join(extDir, "package.json"));
 
-          ctx.ui.notify(`supipowers updated to v${latestVersion}`, "info");
-        } finally {
-          // Clean up temp directory
-          try {
-            rmSync(tempDir, { recursive: true });
-          } catch {
-            // best effort cleanup
-          }
+      // Copy skills
+      const skillsSource = join(downloadedRoot, "skills");
+      if (existsSync(skillsSource)) {
+        const skillDirs = readdirSync(skillsSource, { withFileTypes: true });
+        for (const entry of skillDirs) {
+          if (!entry.isDirectory()) continue;
+          const skillFile = join(skillsSource, entry.name, "SKILL.md");
+          if (!existsSync(skillFile)) continue;
+          const destDir = join(ompAgent, "skills", entry.name);
+          mkdirSync(destDir, { recursive: true });
+          cpSync(skillFile, join(destDir, "SKILL.md"));
         }
-      })();
+      }
+
+      ctx.ui.notify(`supipowers updated to v${latestVersion}`, "info");
+    } finally {
+      // Clean up temp directory
+      try {
+        rmSync(tempDir, { recursive: true });
+      } catch {
+        // best effort cleanup
+      }
+    }
+  })();
+}
+
+export function registerUpdateCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:update", {
+    description: "Update supipowers to the latest version",
+    async handler(_args, ctx) {
+      handleUpdate(pi, ctx);
     },
   });
 }

package/src/index.ts

@@ -2,15 +2,24 @@ import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
-import { registerSupiCommand } from "./commands/supi.js";
-import { registerConfigCommand } from "./commands/config.js";
-import { registerStatusCommand } from "./commands/status.js";
+import { registerSupiCommand, handleSupi } from "./commands/supi.js";
+import { registerConfigCommand, handleConfig } from "./commands/config.js";
+import { registerStatusCommand, handleStatus } from "./commands/status.js";
 import { registerPlanCommand } from "./commands/plan.js";
 import { registerRunCommand } from "./commands/run.js";
 import { registerReviewCommand } from "./commands/review.js";
 import { registerQaCommand } from "./commands/qa.js";
 import { registerReleaseCommand } from "./commands/release.js";
-import { registerUpdateCommand } from "./commands/update.js";
+import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
+
+// TUI-only commands — intercepted at the input level to prevent
+// message submission and "Working..." indicator
+const TUI_COMMANDS: Record<string, (pi: ExtensionAPI, ctx: any) => void> = {
+  "supi": (pi, ctx) => handleSupi(pi, ctx),
+  "supi:config": (_pi, ctx) => handleConfig(ctx),
+  "supi:status": (_pi, ctx) => handleStatus(ctx),
+  "supi:update": (pi, ctx) => handleUpdate(pi, ctx),
+};
 
 function getInstalledVersion(): string | null {
   const pkgPath = join(homedir(), ".omp", "agent", "extensions", "supipowers", "package.json");
@@ -23,7 +32,7 @@ function getInstalledVersion(): string | null {
 }
 
 export default function supipowers(pi: ExtensionAPI): void {
-  // Register all commands
+  // Register all commands (needed for autocomplete)
   registerSupiCommand(pi);
   registerConfigCommand(pi);
   registerStatusCommand(pi);
@@ -34,6 +43,22 @@ export default function supipowers(pi: ExtensionAPI): void {
   registerReleaseCommand(pi);
   registerUpdateCommand(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) => {
+    const text = event.text.trim();
+    if (!text.startsWith("/")) return;
+
+    const spaceIndex = text.indexOf(" ");
+    const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+
+    const handler = TUI_COMMANDS[commandName];
+    if (!handler) return;
+
+    handler(pi, ctx);
+    return { handled: true };
+  });
+
   // Session start
   pi.on("session_start", async (_event, ctx) => {
     // Check for updates in the background