supipowers 1.2.6 → 1.5.0

package/src/commands/config.ts

@@ -1,78 +1,204 @@
 import type { Platform, PlatformContext } from "../platform/types.js";
-import { loadConfig, updateConfig } from "../config/loader.js";
-import { listProfiles } from "../config/profiles.js";
-import { checkInstallation } from "../context-mode/installer.js";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+import { formatConfigErrors, inspectConfig, updateConfig } from "../config/loader.js";
+import type { InspectionLoadResult } from "../config/schema.js";
 import type { SupipowersConfig } from "../types.js";
+import { createWorkflowProgress } from "../platform/progress.js";
+import {
+  interactivelySaveGateSetup,
+  setupGates,
+  summarizeEnabledGates,
+  type GateSetupMode,
+  type SetupGatesProgressEvent,
+} from "../quality/setup.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" },
+  { value: "", label: "not set — auto-detect on first /supi:qa run" },
+  { value: "vitest", label: "vitest — npx vitest run" },
+  { value: "jest", label: "jest — npx jest" },
+  { value: "mocha", label: "mocha — npx mocha" },
+  { value: "pytest", label: "pytest — pytest" },
+  { value: "cargo-test", label: "cargo-test — cargo test" },
+  { value: "go-test", label: "go-test — go test ./..." },
+  { value: "npm-test", label: "npm-test — npm test" },
 ];
 
 const CHANNEL_OPTIONS = [
   { value: [] as string[], label: "not set — auto-detect on first /supi:release run" },
-  { value: ["github", "npm"], label: "both — GitHub Release + npm publish" },
   { value: ["github"], label: "github — GitHub Release with gh CLI" },
-  { value: ["npm"], label: "npm — npm publish to registry" },
 ];
 
-interface SettingDef {
+export interface SettingDef {
   label: string;
   key: string;
   helpText: string;
   type: "select" | "toggle";
   options?: string[];
-  get: (config: SupipowersConfig) => string;
-  set: (cwd: string, value: unknown) => void;
+  get: () => string;
+  set: (cwd: string, value: unknown) => Promise<string | null>;
 }
 
-function buildSettings(platform: Platform, cwd: string): SettingDef[] {
+export interface ConfigCommandDependencies {
+  inspectConfig: typeof inspectConfig;
+  updateConfig: typeof updateConfig;
+  setupGates: typeof setupGates;
+  interactivelySaveGateSetup: typeof interactivelySaveGateSetup;
+}
+
+const CONFIG_COMMAND_DEPENDENCIES: ConfigCommandDependencies = {
+  inspectConfig,
+  updateConfig,
+  setupGates,
+  interactivelySaveGateSetup,
+};
+
+function currentConfig(inspection: InspectionLoadResult): SupipowersConfig {
+  return inspection.effectiveConfig ?? DEFAULT_CONFIG;
+}
+
+function describeInspection(inspection: InspectionLoadResult, config: SupipowersConfig): string {
+  if (inspection.parseErrors.length > 0 || inspection.validationErrors.length > 0) {
+    return `config error — ${formatConfigErrors(inspection).split("\n")[0]}`;
+  }
+
+  return summarizeEnabledGates(config.quality.gates);
+}
+
+function createQualityGateSetupProgress(ctx: PlatformContext, mode: GateSetupMode) {
+  if (mode !== "ai-assisted") {
+    return null;
+  }
+
+  const progress = createWorkflowProgress(ctx.ui, {
+    title: "quality gate setup",
+    statusKey: "supi-quality-gate-setup",
+    widgetKey: "supi-quality-gate-setup",
+    steps: [
+      { key: "collect", label: "Inspect project" },
+      { key: "ai", label: "AI analysis" },
+    ],
+  });
+
+  return {
+    handle(event: SetupGatesProgressEvent) {
+      switch (event.type) {
+        case "collecting-project-facts":
+          progress.activate("collect", "Reading scripts and tools");
+          return;
+        case "baseline-ready":
+          progress.complete("collect", "baseline ready");
+          return;
+        case "ai-analysis-started":
+          progress.activate("ai", "Analyzing project checks");
+          return;
+        case "ai-analysis-completed":
+          progress.complete("ai", "proposal ready");
+          return;
+      }
+    },
+    fail(message: string) {
+      if (progress.getStatus("ai") === "active") {
+        progress.fail("ai", message);
+      } else if (progress.getStatus("collect") === "active") {
+        progress.fail("collect", message);
+      }
+    },
+    dispose() {
+      progress.dispose();
+    },
+  };
+}
+
+function buildGateSetupDialogOptions(mode: GateSetupMode) {
+  return mode === "ai-assisted"
+    ? {
+        title: "AI-assisted quality gate proposal",
+        intro: "AI analyzed your project and suggested these gates.",
+      }
+    : {
+        intro: "Detected project checks and suggested these gates.",
+      };
+}
+
+export function buildSettings(
+  platform: Platform,
+  ctx: PlatformContext,
+  inspection: InspectionLoadResult,
+  deps: ConfigCommandDependencies = CONFIG_COMMAND_DEPENDENCIES,
+): SettingDef[] {
   const { paths } = platform;
+  const config = currentConfig(inspection);
+
   return [
     {
-      label: "Default profile",
-      key: "defaultProfile",
-      helpText: "Review depth used when no flag is passed to /supi:review",
+      label: "Setup quality gates",
+      key: "quality.gates",
+      helpText: "Inspect the project and configure review gates",
       type: "select",
-      options: listProfiles(paths, cwd),
-      get: (c) => c.defaultProfile,
-      set: (d, v) => updateConfig(paths, d, { defaultProfile: v }),
+      options: ["Run deterministic setup", "Run AI-assisted setup"],
+      get: () => describeInspection(inspection, config),
+      set: async (cwd, value) => {
+        const mode: GateSetupMode = String(value).includes("AI-assisted") ? "ai-assisted" : "deterministic";
+        const progress = createQualityGateSetupProgress(ctx, mode);
+
+        try {
+          const result = await deps.setupGates(platform, cwd, deps.inspectConfig(platform.paths, cwd), {
+            mode,
+            onProgress: (event) => progress?.handle(event),
+          });
+
+          if (result.status === "invalid") {
+            ctx.ui.notify(result.errors.join("\n"), "error");
+            return null;
+          }
+
+          if (result.status !== "proposed") {
+            return null;
+          }
+
+          progress?.dispose();
+          const saveResult = await deps.interactivelySaveGateSetup(
+            ctx,
+            paths,
+            cwd,
+            result.proposal,
+            buildGateSetupDialogOptions(mode),
+          );
+          return saveResult === "saved" ? "saved" : null;
+        } catch (error) {
+          progress?.fail((error as Error).message);
+          throw error;
+        } finally {
+          progress?.dispose();
+        }
+      },
     },
     {
       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(paths, d, { lsp: { setupGuide: v === "on" } }),
-    },
-    {
-      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,
-      set: (d, v) => updateConfig(paths, d, { notifications: { verbosity: v } }),
+      get: () => (config.lsp.setupGuide ? "on" : "off"),
+      set: async (cwd, value) => {
+        deps.updateConfig(paths, cwd, { lsp: { setupGuide: value === "on" } });
+        return String(value);
+      },
     },
     {
       label: "QA framework",
       key: "qa.framework",
       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) => {
-        const chosen = FRAMEWORK_OPTIONS.find((f) => f.label === v);
-        if (chosen) {
-          updateConfig(paths, d, { qa: { framework: chosen.value || null, command: chosen.command } });
+      options: FRAMEWORK_OPTIONS.map((framework) => framework.label),
+      get: () => config.qa.framework ?? "not set",
+      set: async (cwd, value) => {
+        const chosen = FRAMEWORK_OPTIONS.find((framework) => framework.label === value);
+        if (!chosen) {
+          return null;
         }
+
+        deps.updateConfig(paths, cwd, { qa: { framework: chosen.value || null } });
+        return chosen.label.split(" — ")[0];
       },
     },
     {
@@ -80,50 +206,58 @@ function buildSettings(platform: Platform, cwd: string): SettingDef[] {
       key: "release.channels",
       helpText: "Where /supi:release publishes your project",
       type: "select",
-      options: CHANNEL_OPTIONS.map((p) => p.label),
-      get: (c) => c.release.channels.length > 0 ? c.release.channels.join(", ") : "not set",
-      set: (d, v) => {
-        const chosen = CHANNEL_OPTIONS.find((p) => p.label === v);
-        if (chosen) {
-          updateConfig(paths, d, { release: { channels: chosen.value } });
+      options: CHANNEL_OPTIONS.map((channel) => channel.label),
+      get: () =>
+        config.release.channels.length > 0 ? config.release.channels.join(", ") : "not set",
+      set: async (cwd, value) => {
+        const chosen = CHANNEL_OPTIONS.find((channel) => channel.label === value);
+        if (!chosen) {
+          return null;
         }
+
+        deps.updateConfig(paths, cwd, { release: { channels: chosen.value } });
+        return chosen.label.split(" — ")[0];
       },
     },
   ];
 }
 
-export function handleConfig(platform: Platform, ctx: PlatformContext): void {
+export async function runConfigMenu(
+  platform: Platform,
+  ctx: PlatformContext,
+  deps: ConfigCommandDependencies = CONFIG_COMMAND_DEPENDENCIES,
+): Promise<void> {
   if (!ctx.hasUI) {
     ctx.ui.notify("Config UI requires interactive mode", "warning");
     return;
   }
 
-  void (async () => {
-    const settings = buildSettings(platform, ctx.cwd);
-
-    while (true) {
-      const config = loadConfig(platform.paths, ctx.cwd);
-
-      const options = settings.map(
-        (s) => `${s.label}: ${s.get(config)}`
-      );
-      options.push("Done");
+  while (true) {
+    const inspection = deps.inspectConfig(platform.paths, ctx.cwd);
+    const settings = buildSettings(platform, ctx, inspection, deps);
+    const options = settings.map((setting) => `${setting.label}: ${setting.get()}`);
+    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 === null || choice === "Done") break;
+    if (choice === undefined || choice === null || 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;
+    }
 
+    try {
       if (setting.type === "select" && setting.options) {
-        const currentValue = setting.get(config);
-        const currentIndex = setting.options.findIndex((o) => o.startsWith(currentValue));
+        const currentValue = setting.get();
+        const currentIndex = setting.options.findIndex((option) => option.startsWith(currentValue));
         const value = await ctx.ui.select(
           setting.label,
           setting.options,
@@ -132,39 +266,34 @@ export function handleConfig(platform: Platform, ctx: PlatformContext): void {
             helpText: setting.helpText,
           },
         );
+
         if (value !== undefined && value !== null) {
-          setting.set(ctx.cwd, value);
-          const display = value.split(" — ")[0];
-          ctx.ui.notify(`${setting.label} → ${display}`, "info");
+          const display = await setting.set(ctx.cwd, value);
+          if (display) {
+            ctx.ui.notify(`${setting.label} → ${display}`, "info");
+          }
         }
       } else if (setting.type === "toggle") {
-        const current = setting.get(config);
+        const current = setting.get();
         const newValue = current === "on" ? "off" : "on";
-        setting.set(ctx.cwd, newValue);
-        ctx.ui.notify(`${setting.label} → ${newValue}`, "info");
+        const display = await setting.set(ctx.cwd, newValue);
+        if (display) {
+          ctx.ui.notify(`${setting.label} → ${display}`, "info");
+        }
       }
+    } catch (error) {
+      ctx.ui.notify((error as Error).message, "error");
     }
-  })();
-
-  // Context-mode status (async, fire-and-forget)
-  checkInstallation(
-    (cmd: string, args: string[]) => platform.exec(cmd, args),
-    platform.getActiveTools(),
-  ).then((status) => {
-    const lines = [
-      "",
-      "Context Mode:",
-      `  CLI installed: ${status.cliInstalled ? "\u2713" + (status.version ? ` v${status.version}` : "") : "\u2717"}`,
-      `  MCP configured: ${status.mcpConfigured ? "\u2713" : "\u2717"}`,
-      `  Tools available: ${status.toolsAvailable ? "\u2713" : "\u2717"}`,
-    ];
-    if (!status.mcpConfigured && status.cliInstalled) {
-      lines.push(`  \u2192 Run \`${platform.name} mcp add context-mode\` to enable`);
-    }
-    ctx.ui.notify(lines.join("\n"), "info");
-  }).catch(() => {
-    // Silently ignore — context-mode status is optional
-  });
+  }
+}
+
+export function handleConfig(platform: Platform, ctx: PlatformContext): void {
+  void runConfigMenu(platform, ctx, CONFIG_COMMAND_DEPENDENCIES);
+
+  ctx.ui.notify(
+    "\nContext Mode: ✓ built-in (native tools)",
+    "info",
+  );
 }
 
 export function registerConfigCommand(platform: Platform): void {

package/src/commands/doctor.ts

@@ -1,9 +1,11 @@
 import type { Platform, PlatformContext, PlatformCapabilities } from "../platform/types.js";
 import { existsSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { loadConfig } from "../config/loader.js";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+import { formatConfigErrors, inspectConfig } from "../config/loader.js";
 import { detectContextMode } from "../context-mode/detector.js";
 import { isLspAvailable } from "../lsp/detector.js";
+import { summarizeEnabledGates } from "../quality/setup.js";
 import { DEPENDENCIES } from "../deps/registry.js";
 
 export interface CheckResult {
@@ -39,7 +41,7 @@ export async function checkPlatform(platform: Platform): Promise<CheckResult> {
   const name = platform.name.toUpperCase();
   const presence = { ok: true, detail: `${name} detected` };
   try {
-    const r = await platform.exec("echo", ["ok"]);
+    const r = await platform.exec("node", ["--version"]);
     return { name: "Platform", presence, functional: { ok: r.code === 0, detail: r.code === 0 ? "exec works" : "exec failed" } };
   } catch {
     return { name: "Platform", presence, functional: { ok: false, detail: "exec failed" } };
@@ -51,15 +53,14 @@ export async function checkConfig(platform: Platform, cwd: string): Promise<Chec
   const globalPath = platform.paths.global("config.json");
   const projectExists = existsSync(projectPath);
   const globalExists = existsSync(globalPath);
-
-  // loadConfig never throws — it falls back to DEFAULT_CONFIG via readJsonSafe
-  const config = loadConfig(platform.paths, cwd);
+  const inspection = inspectConfig(platform.paths, cwd);
+  const config = inspection.effectiveConfig ?? DEFAULT_CONFIG;
 
   if (!projectExists && !globalExists) {
     return {
       name: "Config",
       presence: { ok: false, detail: "No config.json found (using defaults)" },
-      functional: { ok: true, detail: `defaultProfile: ${config.defaultProfile}` },
+      functional: { ok: true, detail: `quality.gates: ${summarizeEnabledGates(config.quality.gates)}` },
     };
   }
 
@@ -67,10 +68,18 @@ export async function checkConfig(platform: Platform, cwd: string): Promise<Chec
     ? `${platform.paths.dotDir}/supipowers/config.json (project)`
     : `~/${platform.paths.dotDir}/supipowers/config.json (global)`;
 
+  if (inspection.parseErrors.length > 0 || inspection.validationErrors.length > 0) {
+    return {
+      name: "Config",
+      presence: { ok: true, detail: `Found ${foundPath}` },
+      functional: { ok: false, detail: formatConfigErrors(inspection) },
+    };
+  }
+
   return {
     name: "Config",
     presence: { ok: true, detail: `Found ${foundPath}` },
-    functional: { ok: true, detail: `Parsed (defaultProfile: ${config.defaultProfile})` },
+    functional: { ok: true, detail: `quality.gates: ${summarizeEnabledGates(config.quality.gates)}` },
   };
 }
 
@@ -218,11 +227,8 @@ const CTX_TOOL_NAMES: Record<string, string> = {
   ctxFetchAndIndex: "ctx_fetch_and_index",
 };
 
-export function checkContextMode(activeTools: string[]): CheckResult {
-  const status = detectContextMode(activeTools);
-  if (!status.available) {
-    return { name: "Context Mode", presence: { ok: false, detail: "No context-mode tools detected" } };
-  }
+export function checkContextMode(_activeTools: string[]): CheckResult {
+  const status = detectContextMode();
 
   const foundNames = Object.entries(status.tools)
     .filter(([, v]) => v)
@@ -230,7 +236,7 @@ export function checkContextMode(activeTools: string[]): CheckResult {
 
   return {
     name: "Context Mode",
-    presence: { ok: true, detail: "Tools available" },
+    presence: { ok: true, detail: "Native tools (built-in)" },
     functional: { ok: true, detail: foundNames.join(", ") },
   };
 }

package/src/commands/fix-pr.ts

@@ -1,6 +1,7 @@
 import type { Platform } from "../platform/types.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { moduleDir, toBashPath } from "../utils/paths.js";
 import { loadFixPrConfig, saveFixPrConfig } from "../fix-pr/config.js";
 import { buildFixPrOrchestratorPrompt } from "../fix-pr/prompt-builder.js";
 import type { FixPrConfig, CommentReplyPolicy } from "../fix-pr/types.js";
@@ -15,6 +16,7 @@ import { modelRegistry } from "../config/model-registry-instance.js";
 import { resolveModelForAction, createModelBridge, applyModelOverride } from "../config/model-resolver.js";
 import { loadModelConfig } from "../config/model-config.js";
 import { detectBotReviewers } from "../fix-pr/bot-detector.js";
+import { fetchPrComments } from "../fix-pr/fetch-comments.js";
 
 modelRegistry.register({
   id: "fix-pr",
@@ -32,13 +34,13 @@ modelRegistry.register({
 });
 
 function getScriptsDir(): string {
-  return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "fix-pr", "scripts");
+  return toBashPath(path.join(moduleDir(import.meta.url), "..", "fix-pr", "scripts"));
 }
 
 function findSkillPath(skillName: string): string | null {
   const candidates = [
     path.join(process.cwd(), "skills", skillName, "SKILL.md"),
-    path.join(path.dirname(new URL(import.meta.url).pathname), "..", "..", "skills", skillName, "SKILL.md"),
+    path.join(moduleDir(import.meta.url), "..", "..", "skills", skillName, "SKILL.md"),
   ];
   for (const p of candidates) {
     if (fs.existsSync(p)) return p;
@@ -138,19 +140,14 @@ export function registerFixPrCommand(platform: Platform): void {
       }
 
       // ── Step 4: Fetch initial comments ─────────────────────────────
-      const sessionDir = getSessionDir(platform.paths, ctx.cwd, ledger.id);
+      const sessionDir = toBashPath(getSessionDir(platform.paths, ctx.cwd, ledger.id));
       const scriptsDir = getScriptsDir();
       const snapshotPath = path.join(sessionDir, "snapshots", `comments-${ledger.iteration}.jsonl`);
 
-      const fetchResult = await platform.exec("bash", [
-        path.join(scriptsDir, "fetch-pr-comments.sh"),
-        repo,
-        String(prNumber),
-        snapshotPath,
-      ], { cwd: ctx.cwd });
+      const fetchError = await fetchPrComments(platform, repo, prNumber, snapshotPath, ctx.cwd);
 
-      if (fetchResult.code !== 0) {
-        notifyError(ctx, "Failed to fetch PR comments", fetchResult.stderr);
+      if (fetchError) {
+        notifyError(ctx, "Failed to fetch PR comments", fetchError);
         return;
       }