supipowers 0.2.5 → 0.2.7

package/package.json

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

package/src/commands/config.ts

@@ -1,12 +1,31 @@
-import type { ExtensionAPI, ExtensionCommandContext } 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";
 
+const FRAMEWORK_OPTIONS = [
+  { value: "", label: "not set — auto-detect on first /supi:qa run", command: null },
+  { value: "vitest", label: "vitest — npx vitest run", command: "npx vitest run" },
+  { value: "jest", label: "jest — npx jest", command: "npx jest" },
+  { value: "mocha", label: "mocha — npx mocha", command: "npx mocha" },
+  { value: "pytest", label: "pytest — pytest", command: "pytest" },
+  { value: "cargo-test", label: "cargo-test — cargo test", command: "cargo test" },
+  { value: "go-test", label: "go-test — go test ./...", command: "go test ./..." },
+  { value: "npm-test", label: "npm-test — npm test", command: "npm test" },
+];
+
+const PIPELINE_OPTIONS = [
+  { value: "", label: "not set — choose on first /supi:release run" },
+  { value: "npm", label: "npm — npm publish to registry" },
+  { value: "github", label: "github — GitHub Release with gh CLI" },
+  { value: "manual", label: "manual — I'll handle publishing myself" },
+];
+
 interface SettingDef {
   label: string;
   key: string;
-  type: "select" | "toggle" | "number" | "text";
+  helpText: string;
+  type: "select" | "toggle";
   options?: string[];
   get: (config: SupipowersConfig) => string;
   set: (cwd: string, value: unknown) => void;
@@ -17,6 +36,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Default profile",
       key: "defaultProfile",
+      helpText: "Review depth used when no flag is passed to /supi:review",
       type: "select",
       options: listProfiles(cwd),
       get: (c) => c.defaultProfile,
@@ -25,6 +45,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Max parallel agents",
       key: "orchestration.maxParallelAgents",
+      helpText: "Sub-agents running concurrently in each /supi:run batch",
       type: "select",
       options: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
       get: (c) => String(c.orchestration.maxParallelAgents),
@@ -33,6 +54,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Max fix retries",
       key: "orchestration.maxFixRetries",
+      helpText: "Times a failed task is retried before marking it blocked",
       type: "select",
       options: ["0", "1", "2", "3", "4", "5"],
       get: (c) => String(c.orchestration.maxFixRetries),
@@ -41,6 +63,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Max nesting depth",
       key: "orchestration.maxNestingDepth",
+      helpText: "How deep sub-agents can spawn other sub-agents",
       type: "select",
       options: ["0", "1", "2", "3", "4", "5"],
       get: (c) => String(c.orchestration.maxNestingDepth),
@@ -49,6 +72,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Model preference",
       key: "orchestration.modelPreference",
+      helpText: "Which model sub-agents use for code generation",
       type: "select",
       options: ["auto", "fast", "balanced", "quality"],
       get: (c) => c.orchestration.modelPreference,
@@ -57,6 +81,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "LSP setup guide",
       key: "lsp.setupGuide",
+      helpText: "Show LSP setup tips when no language server is active",
       type: "toggle",
       get: (c) => c.lsp.setupGuide ? "on" : "off",
       set: (d, v) => updateConfig(d, { lsp: { setupGuide: v === "on" } }),
@@ -64,6 +89,7 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "Notification verbosity",
       key: "notifications.verbosity",
+      helpText: "How much detail supipowers shows in notifications",
       type: "select",
       options: ["quiet", "normal", "verbose"],
       get: (c) => c.notifications.verbosity,
@@ -72,88 +98,94 @@ function buildSettings(cwd: string): SettingDef[] {
     {
       label: "QA framework",
       key: "qa.framework",
-      type: "text",
+      helpText: "Test runner used by /supi:qa",
+      type: "select",
+      options: FRAMEWORK_OPTIONS.map((f) => f.label),
       get: (c) => c.qa.framework ?? "not set",
-      set: (d, v) => updateConfig(d, { qa: { framework: v || null } }),
-    },
-    {
-      label: "QA command",
-      key: "qa.command",
-      type: "text",
-      get: (c) => c.qa.command ?? "not set",
-      set: (d, v) => updateConfig(d, { qa: { command: v || null } }),
+      set: (d, v) => {
+        const chosen = FRAMEWORK_OPTIONS.find((f) => f.label === v);
+        if (chosen) {
+          updateConfig(d, { qa: { framework: chosen.value || null, command: chosen.command } });
+        }
+      },
     },
     {
       label: "Release pipeline",
       key: "release.pipeline",
-      type: "text",
+      helpText: "How /supi:release publishes your project",
+      type: "select",
+      options: PIPELINE_OPTIONS.map((p) => p.label),
       get: (c) => c.release.pipeline ?? "not set",
-      set: (d, v) => updateConfig(d, { release: { pipeline: v || null } }),
+      set: (d, v) => {
+        const chosen = PIPELINE_OPTIONS.find((p) => p.label === v);
+        if (chosen) {
+          updateConfig(d, { release: { pipeline: chosen.value || null } });
+        }
+      },
     },
   ];
 }
 
-export function registerConfigCommand(pi: ExtensionAPI): void {
-  pi.registerCommand("supi:config", {
-    description: "View and manage Supipowers configuration",
-    // Synchronous handler — returning void (not a Promise) prevents OMP's "Working..." indicator
-    handler: ((_args: string, ctx: ExtensionCommandContext) => {
-      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 currentValue = setting.get(config);
+        const currentIndex = setting.options.findIndex((o) => o.startsWith(currentValue));
+        const value = await ctx.ui.select(
+          setting.label,
+          setting.options,
+          {
+            initialIndex: Math.max(0, currentIndex),
+            helpText: setting.helpText,
+          },
+        );
+        if (value !== undefined) {
+          setting.set(ctx.cwd, value);
+          const display = value.split(" — ")[0];
+          ctx.ui.notify(`${setting.label} → ${display}`, "info");
         }
-      })();
-    }) as any,
+      } 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");
+      }
+    }
+  })();
+}
+
+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,47 +1,48 @@
-import type { ExtensionAPI, ExtensionCommandContext } 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",
-    // Synchronous handler — returning void (not a Promise) prevents OMP's "Working..." indicator
-    handler: ((_args: string, ctx: ExtensionCommandContext) => {
-      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",
-        });
-      })();
-    }) as any,
+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,53 +1,56 @@
-import type { ExtensionAPI, ExtensionCommandContext } 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",
-    // Synchronous handler — returning void (not a Promise) prevents OMP's "Working..." indicator
-    handler: ((_args: string, ctx: ExtensionCommandContext) => {
-      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);
-          }
-        }
-      })();
-    }) as any,
+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,101 +1,103 @@
-import type { ExtensionAPI, ExtensionCommandContext } 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",
-    // Synchronous handler — returning void (not a Promise) prevents OMP's "Working..." indicator
-    handler: ((_args: string, ctx: ExtensionCommandContext) => {
-      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
-          }
-        }
+    // 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");
+    ctx.ui.notify(`Current version: v${currentVersion}`, "info");
 
-        // 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();
-
-        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"));
         }
-      })();
-    }) as any,
+      }
+
+      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