supipowers 1.5.2 → 2.0.0

package/src/commands/fix-pr.ts

@@ -1,10 +1,23 @@
-import type { Platform } from "../platform/types.js";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
-import { moduleDir, toBashPath } from "../utils/paths.js";
+import type { Platform } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { buildWorkspaceTargetOptionLabel, parseTargetArg, selectWorkspaceTarget, stripCliArg, tokenizeCliArgs } from "../workspace/selector.js";
+import { resolvePackageManager } from "../workspace/package-manager.js";
+import { resolveRepoRoot } from "../workspace/repo-root.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
+import { moduleDir } 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";
+import type { FixPrAssessmentBatch } from "../fix-pr/contracts.js";
+import type { FixPrConfig, CommentReplyPolicy, PrComment } from "../fix-pr/types.js";
+import {
+  clusterPrCommentsByTarget,
+  fetchPrComments,
+  parsePrCommentsJsonl,
+  stringifyPrCommentsJsonl,
+} from "../fix-pr/fetch-comments.js";
 import {
   generateFixPrSessionId,
   createFixPrSession,
@@ -16,7 +29,8 @@ 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";
+import { runFixPrAssessment, groupAssessmentsIntoBatches } from "../fix-pr/assessment.js";
+import { updateFixPrSession } from "../storage/fix-pr-sessions.js";
 
 modelRegistry.register({
   id: "fix-pr",
@@ -34,7 +48,7 @@ modelRegistry.register({
 });
 
 function getScriptsDir(): string {
-  return toBashPath(path.join(moduleDir(import.meta.url), "..", "fix-pr", "scripts"));
+  return path.join(moduleDir(import.meta.url), "..", "fix-pr", "scripts");
 }
 
 function findSkillPath(skillName: string): string | null {
@@ -42,49 +56,128 @@ function findSkillPath(skillName: string): string | null {
     path.join(process.cwd(), "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;
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+
+function parsePrNumberArg(args?: string): number | null {
+  const tokens = tokenizeCliArgs(stripCliArg(args, "--target"));
+
+  for (const token of tokens) {
+    const normalized = token.replace(/^#/, "");
+    if (/^\d+$/.test(normalized)) {
+      return parseInt(normalized, 10);
+    }
   }
+
   return null;
 }
 
+
+function describeTarget(target: WorkspaceTarget): string {
+  return target.kind === "root"
+    ? `root (${target.relativeDir})`
+    : `${target.name} (${target.relativeDir})`;
+}
+
+function formatCommentCount(count: number): string {
+  return `${count} comment${count === 1 ? "" : "s"}`;
+}
+
+function formatUnscopedCommentCount(count: number): string {
+  return `${formatCommentCount(count)} without file path`;
+}
+
+function buildCommentTargetOptions(
+  targets: readonly WorkspaceTarget[],
+  commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
+) {
+  return targets.flatMap((target) => {
+    const count = commentsByTargetId.get(target.id)?.length ?? 0;
+    if (count === 0) {
+      return [];
+    }
+
+    return [{
+      target,
+      changed: true,
+      label: buildWorkspaceTargetOptionLabel({ target, changed: true }, [formatCommentCount(count)]),
+    }];
+  });
+}
+
+function countUnresolvedAssessments(assessment: FixPrAssessmentBatch): number {
+  return assessment.assessments.filter((item: FixPrAssessmentBatch["assessments"][number]) => item.verdict !== "apply").length;
+}
+
+
+function buildDeferredCommentsSummary(
+  options: ReadonlyArray<{ target: WorkspaceTarget }>,
+  commentsByTargetId: ReadonlyMap<string, readonly PrComment[]>,
+  selectedTarget: WorkspaceTarget,
+  unscopedCommentCount: number,
+ ): string | null {
+  const deferred = options
+    .filter((option) => option.target.id !== selectedTarget.id)
+    .map((option) => `${describeTarget(option.target)}: ${formatCommentCount(commentsByTargetId.get(option.target.id)?.length ?? 0)}`);
+
+  if (unscopedCommentCount > 0) {
+    deferred.push(`unscoped review comments: ${formatUnscopedCommentCount(unscopedCommentCount)}`);
+  }
+
+  return deferred.length > 0 ? deferred.join("; ") : null;
+}
+
+function buildAvailableTargetDetail(
+  options: ReadonlyArray<{ target: WorkspaceTarget }>,
+  unscopedCommentCount: number,
+ ): string {
+  const availableTargets = options.length > 0
+    ? `Available targets: ${options.map((option) => option.target.id).join(", ")}`
+    : "No package or root targets have actionable comments in this PR snapshot.";
+
+  if (unscopedCommentCount === 0) {
+    return availableTargets;
+  }
+
+  return `${availableTargets} Deferred unscoped review comments: ${formatUnscopedCommentCount(unscopedCommentCount)}.`;
+}
+
 export function registerFixPrCommand(platform: Platform): void {
   platform.registerCommand("supi:fix-pr", {
     description: "Fix PR review comments with token-optimized agent orchestration",
     async handler(args: string | undefined, ctx: any): Promise<void> {
-      // Resolve and apply model override early — before any logic that might fail
       const modelConfig = loadModelConfig(platform.paths, ctx.cwd);
       const bridge = createModelBridge(platform);
       const resolved = resolveModelForAction("fix-pr", modelRegistry, modelConfig, bridge);
       await applyModelOverride(platform, ctx, "fix-pr", resolved);
 
-      // ── Step 1: Detect PR ──────────────────────────────────────────
-      let prNumber: number | null = null;
+      let prNumber = parsePrNumberArg(args);
       let repo: string | null = null;
+      const requestedTarget = parseTargetArg(args);
 
-      // Try to parse from args
-      const argTrimmed = args?.trim().replace("#", "") || "";
-      if (/^\d+$/.test(argTrimmed)) {
-        prNumber = parseInt(argTrimmed, 10);
-      }
-
-      // Detect repo
       try {
         const repoResult = await platform.exec("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"], { cwd: ctx.cwd });
         if (repoResult.code === 0) repo = repoResult.stdout.trim();
-      } catch { /* ignore */ }
+      } catch {
+        // ignore
+      }
 
       if (!repo) {
         notifyError(ctx, "Could not detect repository", "Run from a git repo with gh CLI configured");
         return;
       }
 
-      // Detect PR number from current branch if not provided
       if (!prNumber) {
         try {
           const prResult = await platform.exec("gh", ["pr", "view", "--json", "number", "-q", ".number"], { cwd: ctx.cwd });
           if (prResult.code === 0) prNumber = parseInt(prResult.stdout.trim(), 10);
-        } catch { /* ignore */ }
+        } catch {
+          // ignore
+        }
       }
 
       if (!prNumber) {
@@ -92,12 +185,23 @@ export function registerFixPrCommand(platform: Platform): void {
         return;
       }
 
-      // ── Step 2: Load or create config ──────────────────────────────
-      let config = loadFixPrConfig(platform.paths, ctx.cwd);
+      const repoRoot = await resolveRepoRoot(platform, ctx.cwd);
+      if (!repoRoot) {
+        notifyError(ctx, "Could not detect repository root", "Run from inside a git worktree");
+        return;
+      }
 
+      const packageManager = resolvePackageManager(repoRoot);
+      const workspaceTargets = discoverWorkspaceTargets(repoRoot, packageManager.id);
+      if (workspaceTargets.length === 0) {
+        notifyError(ctx, "No workspace targets found", `Could not discover package targets from ${repoRoot}`);
+        return;
+      }
+
+      let config = loadFixPrConfig(platform.paths, ctx.cwd);
       if (!config && ctx.hasUI) {
         config = await runSetupWizard(ctx);
-        if (!config) return; // user cancelled
+        if (!config) return;
         saveFixPrConfig(platform.paths, ctx.cwd, config);
         ctx.ui.notify(`Fix-PR config saved to ${platform.paths.dotDirDisplay}/supipowers/fix-pr.json`, "info");
       }
@@ -107,121 +211,196 @@ export function registerFixPrCommand(platform: Platform): void {
         return;
       }
 
-      // ── Step 3: Session handling ───────────────────────────────────
-      let activeSession = findActiveFixPrSession(platform.paths, ctx.cwd);
-
-      if (activeSession && ctx.hasUI) {
-        const choice = await ctx.ui.select(
-          "Fix-PR Session",
-          [
-            `Resume ${activeSession.id} (iteration ${activeSession.iteration}, PR #${activeSession.prNumber})`,
-            "Start new session",
-          ],
-          { helpText: "Select session · Esc to cancel" },
-        );
-        if (!choice) return;
-        if (choice.startsWith("Start new")) activeSession = null;
-      }
-
-      const ledger = activeSession ?? {
-        id: generateFixPrSessionId(),
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        prNumber,
-        repo,
-        status: "running" as const,
-        iteration: 0,
-        config,
-        commentsProcessed: [],
-      };
-
-      if (!activeSession) {
-        createFixPrSession(platform.paths, ctx.cwd, ledger);
-      }
-
-      // ── Step 4: Fetch initial comments ─────────────────────────────
-      const sessionDir = toBashPath(getSessionDir(platform.paths, ctx.cwd, ledger.id));
-      const scriptsDir = getScriptsDir();
-      const snapshotPath = path.join(sessionDir, "snapshots", `comments-${ledger.iteration}.jsonl`);
-
-      const fetchError = await fetchPrComments(platform, repo, prNumber, snapshotPath, ctx.cwd);
-
-      if (fetchError) {
-        notifyError(ctx, "Failed to fetch PR comments", fetchError);
-        return;
-      }
-
-      // Read the snapshot
-      let comments = "";
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "supi-fix-pr-"));
       try {
-        comments = fs.readFileSync(snapshotPath, "utf-8").trim();
-      } catch {
-        notifyWarning(ctx, "No comments found", "PR has no review comments to process");
-        return;
-      }
+        const fetchedCommentsPath = path.join(tempDir, "comments.jsonl");
+        const fetchError = await fetchPrComments(platform, repo, prNumber, fetchedCommentsPath, repoRoot);
+        if (fetchError) {
+          notifyError(ctx, "Failed to fetch PR comments", fetchError);
+          return;
+        }
+
+        const fetchedComments = fs.readFileSync(fetchedCommentsPath, "utf-8").trim();
+        if (!fetchedComments) {
+          notifyInfo(ctx, "No comments to process", "PR has no review comments");
+          return;
+        }
+
+        const parsedComments = parsePrCommentsJsonl(fetchedComments);
+        if (parsedComments.length === 0) {
+          notifyWarning(ctx, "No comments found", "PR comments could not be parsed from the fetched snapshot");
+          return;
+        }
+
+        const clusteredComments = clusterPrCommentsByTarget(workspaceTargets, parsedComments);
+        const targetOptions = buildCommentTargetOptions(
+          workspaceTargets,
+          clusteredComments.commentsByTargetId,
+        );
 
-      if (!comments) {
-        notifyInfo(ctx, "No comments to process", "PR has no review comments");
-        return;
-      }
+        if (targetOptions.length === 0) {
+          const detail = clusteredComments.unscopedComments.length > 0
+            ? `PR comments were fetched but only ${formatUnscopedCommentCount(clusteredComments.unscopedComments.length)} could not be assigned to a workspace target`
+            : "PR comments were fetched but could not be assigned to a package or root target";
+          notifyWarning(ctx, "No actionable comments found", detail);
+          return;
+        }
+
+        if (!requestedTarget && !ctx.hasUI && targetOptions.length > 1) {
+          notifyError(ctx, "Multiple comment targets found", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
+          return;
+        }
+
+        const selectedTarget = await selectWorkspaceTarget(ctx, targetOptions, requestedTarget, {
+          title: "Fix-PR target",
+          helpText: "Select one target to process for this run",
+        });
+        if (!selectedTarget) {
+          if (requestedTarget) {
+            notifyError(ctx, "Target has no review comments", buildAvailableTargetDetail(targetOptions, clusteredComments.unscopedComments.length));
+          }
+          return;
+        }
+
+        const selectedComments = clusteredComments.commentsByTargetId.get(selectedTarget.id) ?? [];
+        if (selectedComments.length === 0) {
+          notifyInfo(ctx, "No comments for selected target", `${selectedTarget.id} has no actionable comments in this PR snapshot`);
+          return;
+        }
+
+        let activeSession = findActiveFixPrSession(platform.paths, selectedTarget, repo, prNumber);
+        if (activeSession && ctx.hasUI) {
+          const choice = await ctx.ui.select(
+            "Fix-PR Session",
+            [
+              `Resume ${activeSession.id} (iteration ${activeSession.iteration}, PR #${activeSession.prNumber})`,
+              "Start new session",
+            ],
+            { helpText: "Select session · Esc to cancel" },
+          );
+          if (!choice) return;
+          if (choice.startsWith("Start new")) activeSession = null;
+        }
+
+        const ledger = activeSession ?? {
+          id: generateFixPrSessionId(),
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          prNumber,
+          repo,
+          status: "running" as const,
+          iteration: 0,
+          config,
+          commentsProcessed: [],
+        };
 
-      const commentCount = comments.split("\n").length;
+        if (!activeSession) {
+          createFixPrSession(platform.paths, selectedTarget, ledger);
+        }
+
+        const sessionDir = getSessionDir(platform.paths, selectedTarget, ledger.id);
+        const scriptsDir = getScriptsDir();
+        const snapshotPath = path.join(sessionDir, "snapshots", `comments-${ledger.iteration}.jsonl`);
+        const selectedCommentsJsonl = stringifyPrCommentsJsonl(selectedComments);
+        fs.mkdirSync(path.dirname(snapshotPath), { recursive: true });
+        fs.writeFileSync(snapshotPath, selectedCommentsJsonl);
+
+        const detectedBots = detectBotReviewers(selectedCommentsJsonl);
+        if (detectedBots.length > 0) {
+          config = {
+            ...config,
+            reviewer: {
+              type: detectedBots[0].type,
+              triggerMethod: detectedBots[0].triggerMethod,
+            },
+          };
+        }
+
+        let skillContent = "";
+        const skillPath = findSkillPath("fix-pr");
+        if (skillPath) {
+          try {
+            skillContent = fs.readFileSync(skillPath, "utf-8");
+          } catch {
+            // proceed without skill content
+          }
+        }
+
+        const taskResolved = resolveModelForAction("task", modelRegistry, modelConfig, bridge);
+        const taskModel = taskResolved.model ?? resolved.model ?? "claude-sonnet-4-6";
+        const deferredCommentsSummary = buildDeferredCommentsSummary(
+          targetOptions,
+          clusteredComments.commentsByTargetId,
+          selectedTarget,
+          clusteredComments.unscopedComments.length,
+        );
 
-      // Auto-detect bot reviewers from comment data
-      const detectedBots = detectBotReviewers(comments);
-      if (detectedBots.length > 0) {
-        config = {
-          ...config,
-          reviewer: {
-            type: detectedBots[0].type,
-            triggerMethod: detectedBots[0].triggerMethod,
+        const assessmentResult = await runFixPrAssessment({
+          createAgentSession: platform.createAgentSession,
+          paths: platform.paths,
+          cwd: ctx.cwd,
+          comments: selectedComments,
+          repo,
+          prNumber,
+          selectedTargetLabel: describeTarget(selectedTarget),
+          model: resolved.model,
+          thinkingLevel: resolved.thinkingLevel,
+        });
+        if (assessmentResult.status === "blocked") {
+          notifyError(ctx, "Fix-PR assessment failed", assessmentResult.error);
+          return;
+        }
+        const assessment = assessmentResult.output;
+        const unresolvedAssessmentCount = countUnresolvedAssessments(assessment);
+        const workBatches = groupAssessmentsIntoBatches(assessment);
+        ledger.assessment = assessment;
+        updateFixPrSession(platform.paths, selectedTarget, ledger);
+
+        if (unresolvedAssessmentCount > 0) {
+          notifyWarning(
+            ctx,
+            "Unresolved comments remain",
+            `${formatCommentCount(unresolvedAssessmentCount)} for ${describeTarget(selectedTarget)} still need rejection or investigation handling before this run can be considered complete.`,
+          );
+        }
+
+        const prompt = buildFixPrOrchestratorPrompt({
+          prNumber,
+          repo,
+          comments: selectedCommentsJsonl.trim(),
+          sessionDir,
+          scriptsDir,
+          config,
+          iteration: ledger.iteration,
+          skillContent,
+          taskModel,
+          selectedTargetLabel: describeTarget(selectedTarget),
+          deferredCommentsSummary,
+          assessment,
+          workBatches,
+        });
+
+        platform.sendMessage(
+          {
+            customType: "supi-fix-pr",
+            content: [{ type: "text", text: prompt }],
+            display: "none",
           },
-        };
-      }
+          { deliverAs: "steer", triggerTurn: true },
+        );
 
-      // ── Step 5: Load skill ─────────────────────────────────────────
-      let skillContent = "";
-      const skillPath = findSkillPath("fix-pr");
-      if (skillPath) {
-        try {
-          skillContent = fs.readFileSync(skillPath, "utf-8");
-        } catch { /* proceed without */ }
+        const detailParts = [`${formatCommentCount(selectedComments.length)} for ${describeTarget(selectedTarget)}`];
+        if (deferredCommentsSummary) {
+          detailParts.push(`deferred: ${deferredCommentsSummary}`);
+        }
+        notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${detailParts.join(" | ")} | session ${ledger.id}`);
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
       }
-
-      // ── Step 6: Build and send prompt ──────────────────────────────
-      // Resolve task model (sub-agents: planner, fixer). Falls back to fix-pr model.
-      const taskResolved = resolveModelForAction("task", modelRegistry, modelConfig, bridge);
-      const taskModel = taskResolved.model ?? resolved.model ?? "claude-sonnet-4-6";
-      const prompt = buildFixPrOrchestratorPrompt({
-        prNumber,
-        repo,
-        comments,
-        sessionDir,
-        scriptsDir,
-        config,
-        iteration: ledger.iteration,
-        skillContent,
-        taskModel,
-      });
-
-
-      platform.sendMessage(
-        {
-          customType: "supi-fix-pr",
-          content: [{ type: "text", text: prompt }],
-          display: "none",
-        },
-        { deliverAs: "steer", triggerTurn: true },
-      );
-
-      notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${commentCount} comments to assess | session ${ledger.id}`);
     },
   });
 }
 
-// ── Setup Wizard ───────────────────────────────────────────────────────
-
-
 const POLICY_OPTIONS = [
   "Answer all comments",
   "Only answer wrong/unnecessary ones (recommended)",
@@ -242,10 +421,7 @@ const ITERATION_OPTIONS = [
   "5",
 ];
 
-
 async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
-
-  // 2. Comment reply policy
   const policyChoice = await ctx.ui.select(
     "Comment reply policy",
     POLICY_OPTIONS,
@@ -257,7 +433,6 @@ async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
   if (policyChoice.startsWith("Answer all")) commentPolicy = "answer-all";
   else if (policyChoice.startsWith("Don't")) commentPolicy = "no-answer";
 
-  // 3. Loop timing
   const delayChoice = await ctx.ui.select(
     "Delay between review checks",
     DELAY_OPTIONS,