supipowers 0.1.0

package/src/commands/config.ts

@@ -0,0 +1,70 @@
+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";
+
+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);
+
+      if (!args || args.trim() === "") {
+        const profiles = listProfiles(ctx.cwd);
+        const activeProfile = resolveProfile(ctx.cwd, config);
+
+        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 auto-detect: ${config.lsp.autoDetect}`,
+          `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",
+        ];
+
+        pi.sendMessage({
+          customType: "supi-config",
+          content: [{ type: "text", text: lines.join("\n") }],
+          display: "inline",
+        });
+        return;
+      }
+
+      const setMatch = args.match(/^set\s+(\S+)\s+(.+)$/);
+      if (setMatch) {
+        const [, keyPath, rawValue] = setMatch;
+        const keys = keyPath.split(".");
+        let value: unknown = rawValue;
+
+        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);
+
+        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;
+
+        updateConfig(ctx.cwd, update);
+        notifySuccess(ctx, "Config updated", `${keyPath} = ${rawValue}`);
+        return;
+      }
+
+      notifyInfo(ctx, "Usage", "/supi:config or /supi:config set <key> <value>");
+    },
+  });
+}

package/src/commands/plan.ts

@@ -0,0 +1,85 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { loadConfig } from "../config/loader.js";
+import { savePlan } from "../storage/plans.js";
+import { notifySuccess, notifyInfo } from "../notifications/renderer.js";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export function registerPlanCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:plan", {
+    description: "Start collaborative planning for a feature or task",
+    async handler(args, ctx) {
+      const config = loadConfig(ctx.cwd);
+
+      const skillPath = findSkillPath("planning");
+      let skillContent = "";
+      if (skillPath) {
+        try {
+          skillContent = fs.readFileSync(skillPath, "utf-8");
+        } catch {
+          // Skill file not found — proceed without it
+        }
+      }
+
+      const isQuick = args?.startsWith("--quick");
+      const quickDesc = isQuick ? args.replace("--quick", "").trim() : "";
+
+      let prompt: string;
+      if (isQuick && quickDesc) {
+        prompt = [
+          "Generate a concise implementation plan for the following task.",
+          "Skip brainstorming — go straight to task breakdown.",
+          "",
+          `Task: ${quickDesc}`,
+          "",
+          "Format the plan as markdown with YAML frontmatter (name, created, tags).",
+          "Each task should have: name, [parallel-safe] or [sequential] annotation,",
+          "**files**, **criteria**, and **complexity** (small/medium/large).",
+          "",
+          skillContent ? "Follow these planning guidelines:\n" + skillContent : "",
+          "",
+          "After generating the plan, save it and confirm with the user.",
+        ].join("\n");
+      } else {
+        prompt = [
+          "You are starting a collaborative planning session with the user.",
+          "",
+          args ? `The user wants to plan: ${args}` : "Ask the user what they want to build or accomplish.",
+          "",
+          "Process:",
+          "1. Understand the goal — ask clarifying questions (one at a time)",
+          "2. Propose 2-3 approaches with trade-offs",
+          "3. Generate a task breakdown once aligned",
+          "",
+          "Format the final plan as markdown with YAML frontmatter (name, created, tags).",
+          "Each task: name, [parallel-safe] or [sequential] annotation,",
+          "**files**, **criteria**, **complexity** (small/medium/large).",
+          "",
+          skillContent ? "Follow these planning guidelines:\n" + skillContent : "",
+        ].join("\n");
+      }
+
+      pi.sendMessage(
+        {
+          customType: "supi-plan-start",
+          content: [{ type: "text", text: prompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" }
+      );
+
+      notifyInfo(ctx, "Planning started", args ? `Topic: ${args}` : "Describe what you want to build");
+    },
+  });
+}
+
+function findSkillPath(skillName: string): string | null {
+  const candidates = [
+    path.join(process.cwd(), "skills", skillName, "SKILL.md"),
+    path.join(__dirname, "..", "..", "skills", skillName, "SKILL.md"),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}

package/src/commands/qa.ts

@@ -0,0 +1,52 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { detectAndCache } from "../qa/detector.js";
+import { buildQaRunPrompt } from "../qa/runner.js";
+import { notifyInfo, notifyError } from "../notifications/renderer.js";
+
+export function registerQaCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:qa", {
+    description: "Run QA pipeline (test suite, E2E)",
+    async handler(args, ctx) {
+      const framework = detectAndCache(ctx.cwd);
+
+      if (!framework) {
+        notifyError(
+          ctx,
+          "No test framework detected",
+          "Configure manually: /supi:config set qa.framework vitest && /supi:config set qa.command 'npx vitest run'"
+        );
+        return;
+      }
+
+      let scope: "all" | "changed" | "e2e" = "all";
+      let changedFiles: string[] | undefined;
+
+      if (args?.includes("--changed")) {
+        scope = "changed";
+        try {
+          const result = await pi.exec("git", ["diff", "--name-only", "HEAD"], { cwd: ctx.cwd });
+          if (result.exitCode === 0) {
+            changedFiles = result.stdout.split("\n").filter((f) => f.trim().length > 0);
+          }
+        } catch {
+          scope = "all";
+        }
+      } else if (args?.includes("--e2e")) {
+        scope = "e2e";
+      }
+
+      notifyInfo(ctx, "QA started", `${framework.name} | scope: ${scope}`);
+
+      const prompt = buildQaRunPrompt(framework.command, scope, changedFiles);
+
+      pi.sendMessage(
+        {
+          customType: "supi-qa",
+          content: [{ type: "text", text: prompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" }
+      );
+    },
+  });
+}

package/src/commands/release.ts

@@ -0,0 +1,60 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { loadConfig, updateConfig } from "../config/loader.js";
+import { buildAnalyzerPrompt } from "../release/analyzer.js";
+import { notifyInfo } from "../notifications/renderer.js";
+
+export function registerReleaseCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:release", {
+    description: "Release automation — version bump, notes, publish",
+    async handler(_args, ctx) {
+      const config = loadConfig(ctx.cwd);
+
+      let lastTag: string | null = null;
+      try {
+        const result = await pi.exec("git", ["describe", "--tags", "--abbrev=0"], { cwd: ctx.cwd });
+        if (result.exitCode === 0) lastTag = result.stdout.trim();
+      } catch {
+        // no tags yet
+      }
+
+      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" }
+        );
+        return;
+      }
+
+      notifyInfo(ctx, "Release started", `Pipeline: ${config.release.pipeline}`);
+
+      const prompt = buildAnalyzerPrompt(lastTag);
+
+      pi.sendMessage(
+        {
+          customType: "supi-release",
+          content: [{ type: "text", text: prompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" }
+      );
+    },
+  });
+}

package/src/commands/review.ts

@@ -0,0 +1,84 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { loadConfig } from "../config/loader.js";
+import { 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";
+
+export function registerReviewCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:review", {
+    description: "Run quality gates at chosen depth (quick/thorough/full-regression)",
+    async handler(args, ctx) {
+      const config = loadConfig(ctx.cwd);
+
+      let profileOverride: string | undefined;
+      if (args?.includes("--quick")) profileOverride = "quick";
+      else if (args?.includes("--thorough")) profileOverride = "thorough";
+      else if (args?.includes("--full")) profileOverride = "full-regression";
+      else if (args?.includes("--profile")) {
+        const match = args.match(/--profile\s+(\S+)/);
+        if (match) profileOverride = match[1];
+      }
+
+      const profile = resolveProfile(ctx.cwd, config, profileOverride);
+      const lsp = isLspAvailable(pi.getActiveTools());
+
+      if (!lsp && profile.gates.lspDiagnostics) {
+        notifyWarning(
+          ctx,
+          "LSP not available",
+          "Review will continue without LSP diagnostics. Run /supi:config for setup."
+        );
+      }
+
+      let changedFiles: string[] = [];
+      try {
+        const result = await pi.exec("git", ["diff", "--name-only", "HEAD"], { cwd: ctx.cwd });
+        if (result.exitCode === 0) {
+          changedFiles = result.stdout
+            .split("\n")
+            .map((f) => f.trim())
+            .filter((f) => f.length > 0);
+        }
+      } catch {
+        // If git fails, we'll review without file filtering
+      }
+
+      if (changedFiles.length === 0) {
+        try {
+          const result = await pi.exec("git", ["diff", "--name-only", "--cached"], { cwd: ctx.cwd });
+          if (result.exitCode === 0) {
+            changedFiles = result.stdout
+              .split("\n")
+              .map((f) => f.trim())
+              .filter((f) => f.length > 0);
+          }
+        } catch {
+          // continue without
+        }
+      }
+
+      if (changedFiles.length === 0) {
+        notifyInfo(ctx, "No changed files detected", "Reviewing all files in scope");
+      }
+
+      const reviewPrompt = buildReviewPrompt({
+        profile,
+        changedFiles,
+        testCommand: config.qa.command,
+        lspAvailable: lsp,
+      });
+
+      notifyInfo(ctx, `Review started`, `profile: ${profile.name}`);
+
+      pi.sendMessage(
+        {
+          customType: "supi-review",
+          content: [{ type: "text", text: reviewPrompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" }
+      );
+    },
+  });
+}

package/src/commands/run.ts

@@ -0,0 +1,175 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { loadConfig } from "../config/loader.js";
+import { resolveProfile } from "../config/profiles.js";
+import { listPlans, readPlanFile, parsePlan } from "../storage/plans.js";
+import {
+  generateRunId,
+  createRun,
+  updateRun,
+  findActiveRun,
+  saveAgentResult,
+  loadAllAgentResults,
+} from "../storage/runs.js";
+import { scheduleBatches } from "../orchestrator/batch-scheduler.js";
+import { dispatchAgent, dispatchFixAgent } from "../orchestrator/dispatcher.js";
+import { summarizeBatch, buildRunSummary } from "../orchestrator/result-collector.js";
+import { analyzeConflicts } from "../orchestrator/conflict-resolver.js";
+import { isLspAvailable } from "../lsp/detector.js";
+import {
+  notifyInfo,
+  notifySuccess,
+  notifyWarning,
+  notifyError,
+  notifySummary,
+} from "../notifications/renderer.js";
+import type { RunManifest, AgentResult } from "../types.js";
+
+export function registerRunCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:run", {
+    description: "Execute a plan with sub-agent orchestration",
+    async handler(args, ctx) {
+      const config = loadConfig(ctx.cwd);
+      const profile = resolveProfile(ctx.cwd, config, args?.replace("--profile ", "") || undefined);
+
+      let manifest = findActiveRun(ctx.cwd);
+
+      if (!manifest) {
+        const plans = listPlans(ctx.cwd);
+        if (plans.length === 0) {
+          notifyError(ctx, "No plans found", "Run /supi:plan first to create a plan");
+          return;
+        }
+
+        const planName = args?.trim() || plans[0];
+        const planContent = readPlanFile(ctx.cwd, planName);
+        if (!planContent) {
+          notifyError(ctx, "Plan not found", planName);
+          return;
+        }
+
+        const plan = parsePlan(planContent, planName);
+        const batches = scheduleBatches(plan.tasks, config.orchestration.maxParallelAgents);
+
+        manifest = {
+          id: generateRunId(),
+          planRef: planName,
+          profile: profile.name,
+          status: "running",
+          startedAt: new Date().toISOString(),
+          batches,
+        };
+        createRun(ctx.cwd, manifest);
+        notifyInfo(ctx, `Run started: ${manifest.id}`, `${plan.tasks.length} tasks in ${batches.length} batches`);
+      } else {
+        notifyInfo(ctx, `Resuming run: ${manifest.id}`);
+      }
+
+      const planContent = readPlanFile(ctx.cwd, manifest.planRef);
+      if (!planContent) {
+        notifyError(ctx, "Plan file missing", manifest.planRef);
+        return;
+      }
+      const plan = parsePlan(planContent, manifest.planRef);
+      const lsp = isLspAvailable(pi.getActiveTools());
+
+      for (const batch of manifest.batches) {
+        if (batch.status === "completed") continue;
+
+        batch.status = "running";
+        updateRun(ctx.cwd, manifest);
+
+        notifyInfo(
+          ctx,
+          `Batch ${batch.index + 1}/${manifest.batches.length}`,
+          `${batch.taskIds.length} tasks`
+        );
+
+        const batchResults: AgentResult[] = [];
+        const agentPromises = batch.taskIds.map((taskId) => {
+          const task = plan.tasks.find((t) => t.id === taskId);
+          if (!task) return Promise.resolve(null);
+
+          return dispatchAgent({
+            pi,
+            ctx,
+            task,
+            planContext: plan.context,
+            config,
+            lspAvailable: lsp,
+          });
+        });
+
+        const results = await Promise.all(agentPromises);
+        for (const result of results) {
+          if (result) {
+            batchResults.push(result);
+            saveAgentResult(ctx.cwd, manifest.id, result);
+          }
+        }
+
+        const conflicts = analyzeConflicts(batchResults, plan.tasks);
+        if (conflicts.hasConflicts) {
+          notifyWarning(
+            ctx,
+            "File conflicts detected",
+            conflicts.conflictingFiles.join(", ")
+          );
+        }
+
+        const failedResults = batchResults.filter((r) => r.status === "blocked");
+        for (const failed of failedResults) {
+          if (config.orchestration.maxFixRetries > 0) {
+            const task = plan.tasks.find((t) => t.id === failed.taskId);
+            if (!task) continue;
+
+            for (let retry = 0; retry < config.orchestration.maxFixRetries; retry++) {
+              notifyInfo(ctx, `Retrying task ${failed.taskId}`, `attempt ${retry + 1}`);
+              const fixResult = await dispatchFixAgent({
+                pi,
+                ctx,
+                task,
+                planContext: plan.context,
+                config,
+                lspAvailable: lsp,
+                previousOutput: failed.output,
+                failureReason: failed.output,
+              });
+              saveAgentResult(ctx.cwd, manifest.id, fixResult);
+              if (fixResult.status !== "blocked") break;
+            }
+          }
+        }
+
+        const allResults = loadAllAgentResults(ctx.cwd, manifest.id);
+        const summary = summarizeBatch(batch, allResults);
+
+        batch.status = summary.allPassed ? "completed" : "failed";
+        updateRun(ctx.cwd, manifest);
+
+        if (!summary.allPassed) {
+          notifyWarning(
+            ctx,
+            `Batch ${batch.index + 1} had issues`,
+            `${summary.blocked} blocked, ${summary.doneWithConcerns} with concerns`
+          );
+        }
+      }
+
+      const allResults = loadAllAgentResults(ctx.cwd, manifest.id);
+      const runSummary = buildRunSummary(allResults);
+
+      manifest.status = runSummary.blocked > 0 ? "failed" : "completed";
+      manifest.completedAt = new Date().toISOString();
+      updateRun(ctx.cwd, manifest);
+
+      const durationSec = Math.round(runSummary.totalDuration / 1000);
+      notifySummary(
+        ctx,
+        "Run complete",
+        `${runSummary.done + runSummary.doneWithConcerns}/${runSummary.totalTasks} tasks done ` +
+        `(${runSummary.done} clean, ${runSummary.doneWithConcerns} with concerns, ` +
+        `${runSummary.blocked} blocked) | ${runSummary.totalFilesChanged} files | ${durationSec}s`
+      );
+    },
+  });
+}

package/src/commands/status.ts

@@ -0,0 +1,51 @@
+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", {
+    description: "Check on running sub-agents and task progress",
+    async handler(_args, ctx) {
+      const activeRun = findActiveRun(ctx.cwd);
+
+      if (!activeRun) {
+        notifyInfo(ctx, "No active runs", "Use /supi:run to execute a plan");
+        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}`,
+        "",
+        `Status: ${activeRun.status}`,
+        `Plan: ${activeRun.planRef}`,
+        `Profile: ${activeRun.profile}`,
+        `Progress: ${completedCount}/${totalTasks} tasks`,
+        "",
+        `  Done: ${doneCount}`,
+        `  With concerns: ${concernCount}`,
+        `  Blocked: ${blockedCount}`,
+        "",
+        `Current batch: ${currentBatch ? `#${currentBatch.index} (${currentBatch.status})` : "none"}`,
+      ];
+
+      pi.sendMessage({
+        customType: "supi-status",
+        content: [{ type: "text", text: lines.join("\n") }],
+        display: "inline",
+      });
+    },
+  });
+}

package/src/commands/supi.ts

@@ -0,0 +1,42 @@
+import type { ExtensionAPI } 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) {
+      const config = loadConfig(ctx.cwd);
+      const activeRun = findActiveRun(ctx.cwd);
+      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"}`,
+      ];
+
+      pi.sendMessage({
+        customType: "supi-overview",
+        content: [{ type: "text", text: lines.join("\n") }],
+        display: "inline",
+      });
+    },
+  });
+}