supipowers 0.2.0 → 0.2.1

package/package.json

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

package/src/commands/config.ts

@@ -1,70 +1,156 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig, updateConfig } from "../config/loader.js";
-import { listProfiles, resolveProfile } from "../config/profiles.js";
-import { notifyInfo, notifySuccess } from "../notifications/renderer.js";
+import { listProfiles } from "../config/profiles.js";
+import type { SupipowersConfig } from "../types.js";
+
+interface SettingDef {
+  label: string;
+  key: string;
+  type: "select" | "toggle" | "number" | "text";
+  options?: string[];
+  get: (config: SupipowersConfig) => string;
+  set: (cwd: string, value: unknown) => void;
+}
+
+function buildSettings(cwd: string): SettingDef[] {
+  return [
+    {
+      label: "Default profile",
+      key: "defaultProfile",
+      type: "select",
+      options: listProfiles(cwd),
+      get: (c) => c.defaultProfile,
+      set: (d, v) => updateConfig(d, { defaultProfile: v }),
+    },
+    {
+      label: "Max parallel agents",
+      key: "orchestration.maxParallelAgents",
+      type: "select",
+      options: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"],
+      get: (c) => String(c.orchestration.maxParallelAgents),
+      set: (d, v) => updateConfig(d, { orchestration: { maxParallelAgents: Number(v) } }),
+    },
+    {
+      label: "Max fix retries",
+      key: "orchestration.maxFixRetries",
+      type: "select",
+      options: ["0", "1", "2", "3", "4", "5"],
+      get: (c) => String(c.orchestration.maxFixRetries),
+      set: (d, v) => updateConfig(d, { orchestration: { maxFixRetries: Number(v) } }),
+    },
+    {
+      label: "Max nesting depth",
+      key: "orchestration.maxNestingDepth",
+      type: "select",
+      options: ["0", "1", "2", "3", "4", "5"],
+      get: (c) => String(c.orchestration.maxNestingDepth),
+      set: (d, v) => updateConfig(d, { orchestration: { maxNestingDepth: Number(v) } }),
+    },
+    {
+      label: "Model preference",
+      key: "orchestration.modelPreference",
+      type: "select",
+      options: ["auto", "fast", "balanced", "quality"],
+      get: (c) => c.orchestration.modelPreference,
+      set: (d, v) => updateConfig(d, { orchestration: { modelPreference: v } }),
+    },
+    {
+      label: "LSP setup guide",
+      key: "lsp.setupGuide",
+      type: "toggle",
+      get: (c) => c.lsp.setupGuide ? "on" : "off",
+      set: (d, v) => updateConfig(d, { lsp: { setupGuide: v === "on" } }),
+    },
+    {
+      label: "Notification verbosity",
+      key: "notifications.verbosity",
+      type: "select",
+      options: ["quiet", "normal", "verbose"],
+      get: (c) => c.notifications.verbosity,
+      set: (d, v) => updateConfig(d, { notifications: { verbosity: v } }),
+    },
+    {
+      label: "QA framework",
+      key: "qa.framework",
+      type: "text",
+      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 } }),
+    },
+    {
+      label: "Release pipeline",
+      key: "release.pipeline",
+      type: "text",
+      get: (c) => c.release.pipeline ?? "not set",
+      set: (d, v) => updateConfig(d, { release: { pipeline: v || null } }),
+    },
+  ];
+}
 
 export function registerConfigCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:config", {
-    description: "View and manage Supipowers configuration and profiles",
-    async handler(args, ctx) {
-      const config = loadConfig(ctx.cwd);
+    description: "View and manage Supipowers configuration",
+    async handler(_args, ctx) {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Config UI requires interactive mode", "warning");
+        return;
+      }
 
-      if (!args || args.trim() === "") {
-        const profiles = listProfiles(ctx.cwd);
-        const activeProfile = resolveProfile(ctx.cwd, config);
+      const settings = buildSettings(ctx.cwd);
 
-        const lines = [
-          "# Supipowers Configuration",
-          "",
-          `Profile: ${config.defaultProfile}`,
-          `Max parallel agents: ${config.orchestration.maxParallelAgents}`,
-          `Max fix retries: ${config.orchestration.maxFixRetries}`,
-          `Max nesting depth: ${config.orchestration.maxNestingDepth}`,
-          `Model preference: ${config.orchestration.modelPreference}`,
-          `LSP setup guide: ${config.lsp.setupGuide}`,
-          `Notification verbosity: ${config.notifications.verbosity}`,
-          `QA framework: ${config.qa.framework ?? "not detected"}`,
-          `Release pipeline: ${config.release.pipeline ?? "not configured"}`,
-          "",
-          `Available profiles: ${profiles.join(", ")}`,
-          "",
-          "To update: /supi:config set <key> <value>",
-          "Example: /supi:config set orchestration.maxParallelAgents 5",
-        ];
+      // Main settings loop
+      while (true) {
+        const config = loadConfig(ctx.cwd);
 
-        pi.sendMessage({
-          customType: "supi-config",
-          content: [{ type: "text", text: lines.join("\n") }],
-          display: "inline",
-        });
-        return;
-      }
+        const options = settings.map(
+          (s) => `${s.label}: ${s.get(config)}`
+        );
+        options.push("Done");
 
-      const setMatch = args.match(/^set\s+(\S+)\s+(.+)$/);
-      if (setMatch) {
-        const [, keyPath, rawValue] = setMatch;
-        const keys = keyPath.split(".");
-        let value: unknown = rawValue;
+        const choice = await ctx.ui.select(
+          "Supipowers Settings",
+          options,
+          { helpText: "Select a setting to change · Esc to close" },
+        );
 
-        if (rawValue === "true") value = true;
-        else if (rawValue === "false") value = false;
-        else if (rawValue === "null") value = null;
-        else if (!isNaN(Number(rawValue))) value = Number(rawValue);
+        if (choice === undefined || choice === "Done") break;
 
-        const update: Record<string, unknown> = {};
-        let current = update;
-        for (let i = 0; i < keys.length - 1; i++) {
-          current[keys[i]] = {};
-          current = current[keys[i]] as Record<string, unknown>;
-        }
-        current[keys[keys.length - 1]] = value;
+        const index = options.indexOf(choice);
+        const setting = settings[index];
+        if (!setting) break;
 
-        updateConfig(ctx.cwd, update);
-        notifySuccess(ctx, "Config updated", `${keyPath} = ${rawValue}`);
-        return;
+        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");
+          }
+        }
       }
-
-      notifyInfo(ctx, "Usage", "/supi:config or /supi:config set <key> <value>");
     },
   });
 }

package/src/commands/qa.ts

@@ -23,6 +23,20 @@ export function registerQaCommand(pi: ExtensionAPI): void {
 
       if (args?.includes("--changed")) {
         scope = "changed";
+      } else if (args?.includes("--e2e")) {
+        scope = "e2e";
+      } else if (ctx.hasUI && !args?.trim()) {
+        // No flag provided — let the user pick
+        const choice = await ctx.ui.select(
+          "QA scope",
+          ["all — Run all tests", "changed — Only changed files", "e2e — E2E / Playwright only"],
+          { helpText: "Select test scope · Esc to cancel" },
+        );
+        if (!choice) return;
+        scope = choice.split(" — ")[0] as "all" | "changed" | "e2e";
+      }
+
+      if (scope === "changed") {
         try {
           const result = await pi.exec("git", ["diff", "--name-only", "HEAD"], { cwd: ctx.cwd });
           if (result.exitCode === 0) {
@@ -31,8 +45,6 @@ export function registerQaCommand(pi: ExtensionAPI): void {
         } catch {
           scope = "all";
         }
-      } else if (args?.includes("--e2e")) {
-        scope = "e2e";
       }
 
       notifyInfo(ctx, "QA started", `${framework.name} | scope: ${scope}`);

package/src/commands/release.ts

@@ -18,32 +18,19 @@ export function registerReleaseCommand(pi: ExtensionAPI): void {
       }
 
       if (!config.release.pipeline) {
-        const prompt = [
-          "# Release Setup",
-          "",
-          "This is your first release with supipowers. How do you publish?",
-          "",
-          "1. **npm** — npm publish to registry",
-          "2. **github** — GitHub Release with gh CLI",
-          "3. **manual** — I'll handle publishing myself",
-          "",
-          "Tell me which option, and I'll save it for future releases.",
-          "",
-          "After you answer, I'll analyze commits and prepare the release.",
-        ].join("\n");
-
-        pi.sendMessage(
-          {
-            customType: "supi-release-setup",
-            content: [{ type: "text", text: prompt }],
-            display: "none",
-          },
-          { deliverAs: "steer" }
+        const choice = await ctx.ui.select(
+          "Release Setup — How do you publish?",
+          ["npm — npm publish to registry", "github — GitHub Release with gh CLI", "manual — I'll handle publishing myself"],
+          { helpText: "Select your release pipeline" },
         );
-        return;
+
+        if (!choice) return;
+        const pipeline = choice.split(" — ")[0];
+        updateConfig(ctx.cwd, { release: { pipeline } });
+        ctx.ui.notify(`Release pipeline set to: ${pipeline}`, "info");
       }
 
-      notifyInfo(ctx, "Release started", `Pipeline: ${config.release.pipeline}`);
+      notifyInfo(ctx, "Release started", `Pipeline: ${config.release.pipeline || "just configured"}`);
 
       const prompt = buildAnalyzerPrompt(lastTag);
 

package/src/commands/review.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { loadConfig } from "../config/loader.js";
-import { resolveProfile } from "../config/profiles.js";
+import { listProfiles, resolveProfile } from "../config/profiles.js";
 import { buildReviewPrompt } from "../quality/gate-runner.js";
 import { isLspAvailable } from "../lsp/detector.js";
 import { notifyInfo, notifyWarning } from "../notifications/renderer.js";
@@ -20,6 +20,21 @@ export function registerReviewCommand(pi: ExtensionAPI): void {
         if (match) profileOverride = match[1];
       }
 
+      // If no flag provided and UI is available, let the user pick
+      if (!profileOverride && ctx.hasUI) {
+        const profiles = listProfiles(ctx.cwd);
+        const choice = await ctx.ui.select(
+          "Review profile",
+          profiles,
+          {
+            initialIndex: profiles.indexOf(config.defaultProfile),
+            helpText: "Select review depth · Esc to cancel",
+          },
+        );
+        if (!choice) return;
+        profileOverride = choice;
+      }
+
       const profile = resolveProfile(ctx.cwd, config, profileOverride);
       const lsp = isLspAvailable(pi.getActiveTools());
 

package/src/commands/status.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { findActiveRun, loadAllAgentResults } from "../storage/runs.js";
-import { notifyInfo } from "../notifications/renderer.js";
 
 export function registerStatusCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:status", {
@@ -9,42 +8,35 @@ export function registerStatusCommand(pi: ExtensionAPI): void {
       const activeRun = findActiveRun(ctx.cwd);
 
       if (!activeRun) {
-        notifyInfo(ctx, "No active runs", "Use /supi:run to execute a plan");
+        ctx.ui.notify("No active runs — use /supi:run to execute a plan", "info");
         return;
       }
 
       const results = loadAllAgentResults(ctx.cwd, activeRun.id);
-      const completedIds = new Set(results.map((r) => r.taskId));
       const totalTasks = activeRun.batches.reduce(
         (sum, b) => sum + b.taskIds.length,
         0
       );
-      const completedCount = results.length;
       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 lines = [
-        `# Run: ${activeRun.id}`,
-        "",
+      const options = [
+        `Run: ${activeRun.id}`,
         `Status: ${activeRun.status}`,
         `Plan: ${activeRun.planRef}`,
         `Profile: ${activeRun.profile}`,
-        `Progress: ${completedCount}/${totalTasks} tasks`,
-        "",
+        `Progress: ${results.length}/${totalTasks} tasks`,
         `  Done: ${doneCount}`,
         `  With concerns: ${concernCount}`,
         `  Blocked: ${blockedCount}`,
-        "",
-        `Current batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "none"}`,
+        `Batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "all complete"}`,
+        "Close",
       ];
 
-      pi.sendMessage({
-        customType: "supi-status",
-        content: [{ type: "text", text: lines.join("\n") }],
-        display: "inline",
+      await ctx.ui.select("Supipowers Status", options, {
+        helpText: "Esc to close",
       });
     },
   });

package/src/commands/supi.ts

@@ -13,30 +13,36 @@ export function registerSupiCommand(pi: ExtensionAPI): void {
       const latestReport = loadLatestReport(ctx.cwd);
       const plans = listPlans(ctx.cwd);
 
-      const lines: string[] = [
-        "# Supipowers",
-        "",
-        "## 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",
-        "",
-        "## Project 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 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",
       ];
 
-      pi.sendMessage({
-        customType: "supi-overview",
-        content: [{ type: "text", text: lines.join("\n") }],
-        display: "inline",
-      });
+      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" },
+      );
+
+      if (choice && choice.startsWith("/supi:")) {
+        const cmdName = choice.split(" ")[0].slice(1); // remove leading /
+        const handler = pi.getCommands().find((c) => c.name === cmdName);
+        if (handler) {
+          await handler.handler("", ctx);
+        }
+      }
     },
   });
 }