supipowers 0.1.4 → 0.2.1

package/bin/install.mjs

@@ -4,7 +4,6 @@ import {
   intro,
   outro,
   confirm,
-  select,
   multiselect,
   spinner,
   isCancel,
@@ -12,7 +11,7 @@ import {
   note,
 } from "@clack/prompts";
 import { spawnSync } from "node:child_process";
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, cpSync, readdirSync } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
@@ -131,29 +130,40 @@ async function main() {
     ompSpinner.stop(`OMP ${ver} detected`);
   }
 
-  // ── Step 2: Install supipowers ─────────────────────────────
-
-  const scope = await select({
-    message: "Where should supipowers be installed?",
-    options: [
-      { value: "global", label: "Global", hint: "available in all projects" },
-      { value: "local", label: "Project-local", hint: "only this directory" },
-    ],
-  });
-  if (isCancel(scope)) bail("Cancelled.");
-
-  const packageSpec = `npm:supipowers@${VERSION}`;
-  const installArgs = ["install", packageSpec];
-  if (scope === "local") installArgs.push("-l");
+  // ── Step 2: Install supipowers into ~/.omp/agent/ ───────────
 
   const s = spinner();
-  s.start(`Installing supipowers (${scope})...`);
-  const result = run(omp, installArgs);
-  if (result.status !== 0) {
+  s.start("Installing supipowers...");
+
+  const packageRoot = resolve(__dirname, "..");
+  const ompAgent = join(homedir(), ".omp", "agent");
+
+  try {
+    // Copy extension (src/ + package.json) → ~/.omp/agent/extensions/supipowers/
+    const extDir = join(ompAgent, "extensions", "supipowers");
+    mkdirSync(extDir, { recursive: true });
+    cpSync(join(packageRoot, "src"), join(extDir, "src"), { recursive: true });
+    cpSync(join(packageRoot, "package.json"), join(extDir, "package.json"));
+
+    // Copy skills → ~/.omp/agent/skills/<skillname>/SKILL.md
+    const skillsSource = join(packageRoot, "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"));
+      }
+    }
+
+    s.stop("supipowers installed");
+  } catch (err) {
     s.stop("Installation failed");
-    bail(result.stderr?.trim() || "omp install failed.");
+    bail(err.message || "Failed to copy files to ~/.omp/agent/");
   }
-  s.stop("supipowers installed");
 
   // ── Step 3: LSP setup (optional) ──────────────────────────
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supipowers",
-  "version": "0.1.4",
+  "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);
+        }
+      }
     },
   });
 }