supipowers 1.5.2 → 2.0.0

package/src/commands/review.ts

@@ -10,7 +10,11 @@ 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 { createWorkflowProgress } from "../platform/progress.js";
-import { runQualityGates, type ReviewRunEvent } from "../quality/runner.js";
+import {
+  discoverChangedRepoFiles,
+  runQualityGates,
+  type ReviewRunEvent,
+} from "../quality/runner.js";
 import {
   interactivelySaveGateSetup,
   setupGates,
@@ -23,10 +27,20 @@ import type {
   QualityGatesConfig,
   ReviewReport,
   SupipowersConfig,
+  WorkspaceTarget,
 } from "../types.js";
 import { CANONICAL_GATE_ORDER, GATE_DISPLAY_NAMES } from "../quality/registry.js";
 import { REVIEW_GATE_REGISTRY } from "../quality/review-gates.js";
 import { saveReviewReport } from "../storage/reports.js";
+import { resolvePackageManager } from "../workspace/package-manager.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
+import { getChangedWorkspaceTargets } from "../workspace/path-mapping.js";
+import {
+  parseTargetArg,
+  selectWorkspaceTarget,
+  sortWorkspaceTargetOptions,
+} from "../workspace/selector.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
 
 modelRegistry.register({
   id: "checks",
@@ -61,6 +75,8 @@ export interface ChecksCommandDependencies {
   interactivelySaveGateSetup: typeof interactivelySaveGateSetup;
   runQualityGates: typeof runQualityGates;
   saveReviewReport: typeof saveReviewReport;
+  resolvePackageManager: typeof resolvePackageManager;
+  discoverWorkspaceTargets: typeof discoverWorkspaceTargets;
   notifyInfo: typeof notifyInfo;
 }
 
@@ -77,9 +93,35 @@ const CHECKS_COMMAND_DEPENDENCIES: ChecksCommandDependencies = {
   interactivelySaveGateSetup,
   runQualityGates,
   saveReviewReport,
+  resolvePackageManager,
+  discoverWorkspaceTargets,
   notifyInfo,
 };
 
+interface ResolvedChecksTargets {
+  mode: "single" | "all";
+  runTargets: WorkspaceTarget[];
+  workspaceTargets: WorkspaceTarget[];
+}
+
+interface CompletedChecksRun {
+  target: WorkspaceTarget;
+  report: ReviewReport;
+  reportPath: string;
+  failedGates: GateResult[];
+}
+
+interface RunChecksForTargetInput {
+  platform: Platform;
+  ctx: any;
+  deps: ChecksCommandDependencies;
+  target: WorkspaceTarget;
+  workspaceTargets: WorkspaceTarget[];
+  filters: GateFilters;
+  reviewModel: ReturnType<ChecksCommandDependencies["resolveModelForAction"]>;
+}
+
+
 function tokenizeGateList(raw: string): string[] {
   return raw
     .split(/[\s,]+/)
@@ -156,7 +198,7 @@ function validateGateSelection(enabledGateIds: GateId[], filters: GateFilters):
 }
 
 function describeScope(scope: ConfigScope): string {
-  return scope === "global" ? "global" : "project";
+  return scope === "global" ? "global" : "repository";
 }
 
 function buildRecoveryDetail(scopes: ConfigScope[]): string {
@@ -168,6 +210,122 @@ function buildRecoveryDetail(scopes: ConfigScope[]): string {
   ].join("\n");
 }
 
+function getTargetConfigOptions(target: WorkspaceTarget) {
+  return { repoRoot: target.repoRoot };
+}
+
+function formatTargetLocation(target: WorkspaceTarget): string {
+  return target.kind === "root" ? "root" : target.relativeDir;
+}
+
+function formatTargetLabel(target: WorkspaceTarget): string {
+  return target.kind === "root" ? `${target.name} (root)` : `${target.name} (${target.relativeDir})`;
+}
+
+function buildChecksTargetOptionLabel(option: { target: WorkspaceTarget; changed: boolean }): string {
+  return `${option.target.name} — ${formatTargetLocation(option.target)} — ${option.changed ? "changed" : "unchanged"}`;
+}
+
+function buildAllChecksTargetLabel(
+  workspaceTargets: WorkspaceTarget[],
+  changedTargetIds: Set<string>,
+): string {
+  const workspaceCount = workspaceTargets.filter((target) => target.kind === "workspace").length;
+  const base = workspaceCount === 0
+    ? "All — root target"
+    : `All — root + ${workspaceCount} workspace${workspaceCount === 1 ? "" : "s"}`;
+  const changedCount = workspaceTargets.filter((target) => changedTargetIds.has(target.id)).length;
+  return changedCount > 0 ? `${base} — ${changedCount} changed` : `${base} — no changed targets`;
+}
+
+function getDefaultChecksTarget(workspaceTargets: WorkspaceTarget[]): WorkspaceTarget {
+  return workspaceTargets.find((target) => target.kind === "root") ?? workspaceTargets[0]!;
+}
+
+function isMonorepoTargets(workspaceTargets: WorkspaceTarget[]): boolean {
+  return workspaceTargets.some((target) => target.kind === "workspace");
+}
+
+async function resolveChecksTargets(
+  platform: Platform,
+  ctx: any,
+  args: string | undefined,
+  deps: ChecksCommandDependencies,
+): Promise<ResolvedChecksTargets | null> {
+  const requestedTarget = parseTargetArg(args);
+  const repoRoot = await resolveRepoRoot(platform, ctx.cwd);
+  const packageManager = deps.resolvePackageManager(repoRoot);
+  const workspaceTargets = deps.discoverWorkspaceTargets(repoRoot, packageManager.id);
+
+  if (workspaceTargets.length === 0) {
+    throw new Error("No workspace targets found for checks.");
+  }
+
+  if (requestedTarget?.toLowerCase() === "all") {
+    return { mode: "all", runTargets: workspaceTargets, workspaceTargets };
+  }
+
+  if (requestedTarget) {
+    const target = await selectWorkspaceTarget(
+      ctx,
+      workspaceTargets.map((target) => ({ target, changed: false })),
+      requestedTarget,
+      {
+        title: "Checks target",
+        helpText: "Pick one target to run checks for. Use --target all to run the root target and every workspace target.",
+      },
+    );
+    if (!target) {
+      throw new Error(`Checks target not found: ${requestedTarget}`);
+    }
+    return { mode: "single", runTargets: [target], workspaceTargets };
+  }
+
+  if (!isMonorepoTargets(workspaceTargets)) {
+    return {
+      mode: "single",
+      runTargets: [getDefaultChecksTarget(workspaceTargets)],
+      workspaceTargets,
+    };
+  }
+
+  const changedRepoFiles = await discoverChangedRepoFiles(platform.exec.bind(platform), repoRoot);
+  const changedTargetIds = new Set(
+    getChangedWorkspaceTargets(workspaceTargets, changedRepoFiles).map((target) => target.id),
+  );
+  const options = sortWorkspaceTargetOptions(
+    workspaceTargets.map((target) => ({
+      target,
+      changed: changedTargetIds.has(target.id),
+      label: buildChecksTargetOptionLabel({
+        target,
+        changed: changedTargetIds.has(target.id),
+      }),
+    })),
+  );
+
+  if (!ctx.hasUI) {
+    return { mode: "all", runTargets: workspaceTargets, workspaceTargets };
+  }
+
+  const allLabel = buildAllChecksTargetLabel(workspaceTargets, changedTargetIds);
+  const labels = [allLabel, ...options.map((option) => option.label ?? buildChecksTargetOptionLabel(option))];
+  const choice = await ctx.ui.select("Checks target", labels, {
+    initialIndex: 0,
+    helpText: "All runs the root target and every workspace target. Choose a single target to narrow the run.",
+  });
+  if (!choice) {
+    return null;
+  }
+  if (choice === allLabel) {
+    return { mode: "all", runTargets: workspaceTargets, workspaceTargets };
+  }
+
+  const selectedIndex = labels.indexOf(choice) - 1;
+  const target = selectedIndex >= 0 ? options[selectedIndex]?.target ?? null : null;
+  return target ? { mode: "single", runTargets: [target], workspaceTargets } : null;
+}
+
 function gateStepKey(gateId: GateId): string {
   return `gate-${gateId}`;
 }
@@ -350,12 +508,15 @@ async function recoverInvalidQualityGateConfig(
   ctx: any,
   deps: ChecksCommandDependencies,
   reviewProgress: ReturnType<typeof createReviewProgress>,
+  target: WorkspaceTarget,
 ): Promise<
   | { status: "unrecoverable" }
   | { status: "cancelled" }
   | { status: "recovered"; config: SupipowersConfig }
 > {
-  const recovery = deps.inspectQualityGateRecovery(platform.paths, ctx.cwd);
+  const configRoot = target.repoRoot;
+  const configOptions = getTargetConfigOptions(target);
+  const recovery = deps.inspectQualityGateRecovery(platform.paths, configRoot, configOptions);
   const recoverableScopes = recovery.scopes
     .filter((scope) => scope.recoverableInvalidQualityGates)
     .map((scope) => scope.scope);
@@ -374,7 +535,7 @@ async function recoverInvalidQualityGateConfig(
   reviewProgress.startRepair(`cleaning ${recoverableScopes.join(" + ")}`);
 
   for (const scope of recoverableScopes) {
-    deps.removeQualityGatesConfig(platform.paths, ctx.cwd, scope);
+    deps.removeQualityGatesConfig(platform.paths, configRoot, scope, configOptions);
   }
 
   deps.notifyInfo(
@@ -385,8 +546,8 @@ async function recoverInvalidQualityGateConfig(
 
   const setupResult = await deps.setupGates(
     platform,
-    ctx.cwd,
-    deps.inspectConfig(platform.paths, ctx.cwd),
+    configRoot,
+    deps.inspectConfig(platform.paths, configRoot, configOptions),
     { mode: "deterministic" },
   );
   if (setupResult.status !== "proposed") {
@@ -400,7 +561,7 @@ async function recoverInvalidQualityGateConfig(
   const saveResult = await deps.interactivelySaveGateSetup(
     ctx,
     platform.paths,
-    ctx.cwd,
+    configRoot,
     setupResult.proposal,
   );
   if (saveResult !== "saved") {
@@ -414,7 +575,7 @@ async function recoverInvalidQualityGateConfig(
     return { status: "cancelled" };
   }
 
-  const config = deps.loadConfig(platform.paths, ctx.cwd);
+  const config = deps.loadConfig(platform.paths, configRoot, configOptions);
   reviewProgress.completeRepair("reconfigured");
   return {
     status: "recovered",
@@ -422,6 +583,96 @@ async function recoverInvalidQualityGateConfig(
   };
 }
 
+async function runChecksForTarget(input: RunChecksForTargetInput): Promise<CompletedChecksRun | null> {
+  const { platform, ctx, deps, target, workspaceTargets, filters, reviewModel } = input;
+  const reviewProgress = createReviewProgress(ctx);
+  const configRoot = target.repoRoot;
+  const configOptions = getTargetConfigOptions(target);
+
+  try {
+    reviewProgress.startLoadingConfig();
+
+    let config: SupipowersConfig;
+    try {
+      config = deps.loadConfig(platform.paths, configRoot, configOptions);
+      reviewProgress.completeLoadingConfig();
+    } catch (error) {
+      const recovered = await recoverInvalidQualityGateConfig(
+        platform,
+        ctx,
+        deps,
+        reviewProgress,
+        target,
+      );
+      if (recovered.status === "unrecoverable") {
+        throw error;
+      }
+      if (recovered.status === "cancelled") {
+        return null;
+      }
+      config = recovered.config;
+    }
+
+    const enabledGateIds = getEnabledGateIds(config.quality.gates);
+    reviewProgress.configureGateSteps(config.quality.gates, filters);
+    validateGateSelection(enabledGateIds, filters);
+
+    reviewProgress.startScopeDiscovery();
+    const report = await deps.runQualityGates({
+      platform,
+      cwd: target.packageDir,
+      target,
+      workspaceTargets,
+      gates: config.quality.gates,
+      filters,
+      reviewModel,
+      gateRegistry: REVIEW_GATE_REGISTRY,
+      onEvent: (event) => reviewProgress.handleRunnerEvent(event),
+    });
+
+    reviewProgress.startSavingReport();
+    const reportPath = deps.saveReviewReport(platform.paths, target, report);
+    reviewProgress.completeSavingReport(report.overallStatus);
+
+    return {
+      target,
+      report,
+      reportPath,
+      failedGates: getFailedGates(report),
+    };
+  } catch (error) {
+    reviewProgress.failActive((error as Error).message);
+    throw error;
+  } finally {
+    reviewProgress.dispose();
+  }
+}
+
+function buildBatchChecksTitle(results: CompletedChecksRun[]): string {
+  const counts = results.reduce(
+    (summary, result) => {
+      summary[result.report.overallStatus] += 1;
+      return summary;
+    },
+    { passed: 0, failed: 0, blocked: 0 } satisfies Record<ReviewReport["overallStatus"], number>,
+  );
+  const parts = [
+    counts.passed > 0 ? `${counts.passed} passed` : null,
+    counts.failed > 0 ? `${counts.failed} failed` : null,
+    counts.blocked > 0 ? `${counts.blocked} blocked` : null,
+  ].filter((part): part is string => part !== null);
+
+  return `Checks complete: ${parts.join(", ")}`;
+}
+
+function buildBatchChecksSummary(results: CompletedChecksRun[]): string {
+  return results.map((result) => {
+    const { passed, failed, blocked, skipped } = result.report.summary;
+    return `${formatTargetLabel(result.target)}: ${result.report.overallStatus} — ${passed} passed, ${failed} failed, ${blocked} blocked, ${skipped} skipped — saved: ${result.reportPath}`;
+  }).join("\n");
+}
+
+
 export function buildReviewSummary(report: ReviewReport, reportPath: string): string {
   const orderedGates = [...report.gates].sort(
     (left, right) =>
@@ -548,7 +799,6 @@ function buildFixPrompt(failedGates: GateResult[]): string {
     ].join("\n"));
   }
 
-  const gateNames = failedGates.map((g) => GATE_DISPLAY_NAMES[g.gate] ?? g.gate);
   const rerunCmd = `/supi:checks --only ${failedGates.map((g) => g.gate).join(" ")}`;
 
   return [
@@ -565,7 +815,6 @@ export async function handleChecks(
   args: string | undefined,
   deps: ChecksCommandDependencies = CHECKS_COMMAND_DEPENDENCIES,
 ): Promise<void> {
-  const reviewProgress = createReviewProgress(ctx);
   let modelCleanup: (() => Promise<void>) | undefined;
 
   try {
@@ -574,82 +823,67 @@ export async function handleChecks(
     const resolved = deps.resolveModelForAction("checks", modelRegistry, modelCfg, bridge);
     modelCleanup = await deps.applyModelOverride(platform, ctx, "checks", resolved);
 
-    reviewProgress.startLoadingConfig();
+    const filters = parseGateFilters(args);
+    const selection = await resolveChecksTargets(platform, ctx, args, deps);
+    if (!selection) {
+      return;
+    }
 
-    let config: SupipowersConfig;
-    try {
-      config = deps.loadConfig(platform.paths, ctx.cwd);
-      reviewProgress.completeLoadingConfig();
-    } catch (error) {
-      const recovered = await recoverInvalidQualityGateConfig(platform, ctx, deps, reviewProgress);
-      if (recovered.status === "unrecoverable") {
-        throw error;
-      }
-      if (recovered.status === "cancelled") {
+    const results: CompletedChecksRun[] = [];
+    for (const target of selection.runTargets) {
+      const result = await runChecksForTarget({
+        platform,
+        ctx,
+        deps,
+        target,
+        workspaceTargets: selection.workspaceTargets,
+        filters,
+        reviewModel: resolved,
+      });
+      if (!result) {
         return;
       }
-      config = recovered.config;
+      results.push(result);
     }
 
-    const enabledGateIds = getEnabledGateIds(config.quality.gates);
-    const filters = parseGateFilters(args);
-    reviewProgress.configureGateSteps(config.quality.gates, filters);
-    validateGateSelection(enabledGateIds, filters);
-
-    reviewProgress.startScopeDiscovery();
-    const report = await deps.runQualityGates({
-      platform,
-      cwd: ctx.cwd,
-      gates: config.quality.gates,
-      filters,
-      reviewModel: resolved,
-      gateRegistry: REVIEW_GATE_REGISTRY,
-      onEvent: (event) => reviewProgress.handleRunnerEvent(event),
-    });
-
-    reviewProgress.startSavingReport();
-    const reportPath = deps.saveReviewReport(platform.paths, ctx.cwd, report);
-    reviewProgress.completeSavingReport(report.overallStatus);
-
-    // Dispose widget before showing any TUI dialogs
-    reviewProgress.dispose();
+    if (selection.mode === "all" && results.length > 1) {
+      deps.notifyInfo(ctx, buildBatchChecksTitle(results), buildBatchChecksSummary(results));
+      return;
+    }
 
-    const failedGates = getFailedGates(report);
+    const [result] = results;
+    if (!result) {
+      return;
+    }
 
-    if (failedGates.length === 0) {
+    if (result.failedGates.length === 0) {
       deps.notifyInfo(
         ctx,
-        `Checks complete: ${report.overallStatus}`,
-        buildReviewSummary(report, reportPath),
+        `Checks complete: ${result.report.overallStatus}`,
+        buildReviewSummary(result.report, result.reportPath),
       );
       return;
     }
 
-    // Show compact failure summary
-    const failureNames = failedGates.map((g) => GATE_DISPLAY_NAMES[g.gate] ?? g.gate);
+    const failureNames = result.failedGates.map((gate) => GATE_DISPLAY_NAMES[gate.gate] ?? gate.gate);
     deps.notifyInfo(
       ctx,
-      `Checks complete: ${report.overallStatus}`,
-      buildFailureSummary(failedGates),
+      `Checks complete: ${result.report.overallStatus}`,
+      buildFailureSummary(result.failedGates),
     );
 
-    // Offer to fix
     const FIX_NOW = `Yes, fix ${failureNames.join(", ")}`;
     const SAVE_ONLY = "No, just save for later";
     const choice = await ctx.ui.select(
-      `${failedGates.length} check${failedGates.length === 1 ? "" : "s"} failed — do you want to fix now?`,
+      `${result.failedGates.length} check${result.failedGates.length === 1 ? "" : "s"} failed — do you want to fix now?`,
       [FIX_NOW, SAVE_ONLY],
     );
 
     if (choice === FIX_NOW) {
-      platform.sendUserMessage(buildFixPrompt(failedGates));
+      platform.sendUserMessage(buildFixPrompt(result.failedGates));
     }
-  } catch (error) {
-    reviewProgress.failActive((error as Error).message);
-    throw error;
   } finally {
     await modelCleanup?.();
-    reviewProgress.dispose();
   }
 }