supipowers 0.2.1 → 0.2.3

package/bin/install.mjs

@@ -11,7 +11,7 @@ import {
   note,
 } from "@clack/prompts";
 import { spawnSync } from "node:child_process";
-import { readFileSync, existsSync, mkdirSync, cpSync, readdirSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, cpSync, rmSync, readdirSync } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
@@ -130,39 +130,65 @@ async function main() {
     ompSpinner.stop(`OMP ${ver} detected`);
   }
 
-  // ── Step 2: Install supipowers into ~/.omp/agent/ ───────────
-
-  const s = spinner();
-  s.start("Installing supipowers...");
+  // ── Step 2: Install / update supipowers into ~/.omp/agent/ ──
 
   const packageRoot = resolve(__dirname, "..");
   const ompAgent = join(homedir(), ".omp", "agent");
+  const extDir = join(ompAgent, "extensions", "supipowers");
+  const installedPkgPath = join(extDir, "package.json");
+
+  // Check for existing installation
+  let installedVersion = null;
+  if (existsSync(installedPkgPath)) {
+    try {
+      const installed = JSON.parse(readFileSync(installedPkgPath, "utf8"));
+      installedVersion = installed.version;
+    } catch {
+      // corrupted package.json — treat as not installed
+    }
+  }
 
-  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"));
-      }
+  if (installedVersion === VERSION) {
+    note(`supipowers v${VERSION} is already installed and up to date.`, "Up to date");
+  } else {
+    const action = installedVersion ? "Updating" : "Installing";
+    if (installedVersion) {
+      note(`v${installedVersion} → v${VERSION}`, "Updating supipowers");
     }
 
-    s.stop("supipowers installed");
-  } catch (err) {
-    s.stop("Installation failed");
-    bail(err.message || "Failed to copy files to ~/.omp/agent/");
+    const s = spinner();
+    s.start(`${action} supipowers...`);
+
+    try {
+      // Clean previous installation to remove stale files
+      if (existsSync(extDir)) {
+        rmSync(extDir, { recursive: true });
+      }
+
+      // Copy extension (src/ + package.json) → ~/.omp/agent/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(installedVersion ? `supipowers updated to v${VERSION}` : `supipowers v${VERSION} installed`);
+    } catch (err) {
+      s.stop(`${action} failed`);
+      bail(err.message || "Failed to copy files to ~/.omp/agent/");
+    }
   }
 
   // ── Step 3: LSP setup (optional) ──────────────────────────

package/package.json

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

package/src/commands/config.ts

@@ -102,55 +102,57 @@ export function registerConfigCommand(pi: ExtensionAPI): void {
         return;
       }
 
-      const settings = buildSettings(ctx.cwd);
+      ctx.ui.setEditorText("");
+      void (async () => {
+        const settings = buildSettings(ctx.cwd);
 
-      // Main settings loop
-      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");
+            }
           }
         }
-      }
+      })();
     },
   });
 }

package/src/commands/status.ts

@@ -5,39 +5,42 @@ export function registerStatusCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi:status", {
     description: "Check on running sub-agents and task progress",
     async handler(_args, ctx) {
-      const activeRun = findActiveRun(ctx.cwd);
+      ctx.ui.setEditorText("");
 
+      const activeRun = findActiveRun(ctx.cwd);
       if (!activeRun) {
         ctx.ui.notify("No active runs — use /supi:run to execute a plan", "info");
         return;
       }
 
-      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",
+        });
+      })();
     },
   });
 }

package/src/commands/supi.ts

@@ -8,41 +8,45 @@ export function registerSupiCommand(pi: ExtensionAPI): void {
   pi.registerCommand("supi", {
     description: "Supipowers overview — show available commands and project status",
     async handler(_args, ctx) {
-      const config = loadConfig(ctx.cwd);
-      const activeRun = findActiveRun(ctx.cwd);
-      const latestReport = loadLatestReport(ctx.cwd);
-      const plans = listPlans(ctx.cwd);
+      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);
 
-      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",
-      ];
+        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 handler = pi.getCommands().find((c) => c.name === cmdName);
-        if (handler) {
-          await handler.handler("", ctx);
+        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);
+          }
         }
-      }
+      })();
     },
   });
 }

package/src/commands/update.ts

@@ -0,0 +1,100 @@
+import type { ExtensionAPI } 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");
+
+        // 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");
+
+        // 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;
+        }
+
+        ctx.ui.notify(`Updating v${currentVersion} → v${latestVersion}...`, "info");
+
+        // Download latest to a temp directory
+        const tempDir = join(tmpdir(), `supipowers-update-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+
+        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;
+          }
+
+          const downloadedRoot = join(tempDir, "node_modules", "supipowers");
+          if (!existsSync(downloadedRoot)) {
+            ctx.ui.notify("Downloaded package not found", "error");
+            return;
+          }
+
+          // Clean previous installation
+          if (existsSync(extDir)) {
+            rmSync(extDir, { recursive: true });
+          }
+
+          // 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"));
+
+          // 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
+          }
+        }
+      })();
+    },
+  });
+}

package/src/index.ts

@@ -1,4 +1,7 @@
 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";
@@ -7,6 +10,17 @@ 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";
+
+function getInstalledVersion(): string | null {
+  const pkgPath = join(homedir(), ".omp", "agent", "extensions", "supipowers", "package.json");
+  if (!existsSync(pkgPath)) return null;
+  try {
+    return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+  } catch {
+    return null;
+  }
+}
 
 export default function supipowers(pi: ExtensionAPI): void {
   // Register all commands
@@ -18,11 +32,27 @@ export default function supipowers(pi: ExtensionAPI): void {
   registerReviewCommand(pi);
   registerQaCommand(pi);
   registerReleaseCommand(pi);
+  registerUpdateCommand(pi);
 
   // Session start
   pi.on("session_start", async (_event, ctx) => {
-    if (ctx.hasUI) {
-      ctx.ui.setStatus("supipowers", "supi ready");
-    }
+    // Check for updates in the background
+    const currentVersion = getInstalledVersion();
+    if (!currentVersion) return;
+
+    pi.exec("npm", ["view", "supipowers", "version"], { cwd: tmpdir() })
+      .then((result) => {
+        if (result.exitCode !== 0) return;
+        const latest = result.stdout.trim();
+        if (latest && latest !== currentVersion) {
+          ctx.ui.notify(
+            `supipowers v${latest} available (current: v${currentVersion}). Run /supi:update`,
+            "info",
+          );
+        }
+      })
+      .catch(() => {
+        // Network error — silently ignore
+      });
   });
 }