supipowers 0.3.0 → 0.4.0

package/package.json

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

package/skills/fix-pr/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: fix-pr
+description: Critically assess PR review comments — verify, investigate ripple effects, then fix or reject with evidence
+---
+
+# PR Review Comment Assessment
+
+## Core Principle
+
+Review comments are suggestions to evaluate, not orders to follow.
+Assess each one critically before acting. The reviewer may lack context you have.
+
+## Assessment Framework
+
+### For Each Comment, Answer:
+
+1. **Is this valid?** Read the actual code being commented on. Does the concern apply?
+2. **Is this important?** Bug fix vs style preference vs premature optimization.
+3. **What breaks if we change this?** Trace callers, check tests, find ripple effects.
+4. **Does the reviewer have full context?** They often review diffs, not the full picture.
+5. **Is this YAGNI?** "You should also handle X" — but does X actually occur?
+
+### Verdict Categories
+
+- **ACCEPT**: Valid concern, should fix. Evidence: the code has the problem described.
+- **REJECT**: Invalid, unnecessary, or would cause harm. Evidence: why this doesn't apply.
+- **INVESTIGATE**: Need to check more before deciding. List what to check.
+
+### Investigation Protocol
+
+When INVESTIGATE:
+1. Read the file(s) mentioned in full (not just the diff)
+2. Search for usages of the symbol/pattern being discussed
+3. Check test coverage for the area
+4. Look at git blame — why is the code written this way?
+5. Then decide ACCEPT or REJECT with evidence
+
+## Ripple Effect Analysis
+
+Before accepting any change:
+1. **Who calls this?** Search for usages of the function/method/class
+2. **Who depends on this behavior?** Check tests that assert current behavior
+3. **What imports this?** Follow the dependency graph
+4. **Is this a public API?** Changes to public interfaces affect consumers
+
+If ripple effects are significant, note them in the plan so the fixer handles them.
+
+## Grouping Strategy
+
+Group comments that:
+- Touch the same file
+- Touch tightly coupled files (caller/callee, type/implementation)
+- Relate to the same logical concern (e.g., "error handling in module X")
+
+Keep separate:
+- Comments on unrelated files/areas
+- Cosmetic vs functional changes
+- Independent features or concerns
+
+## Comment Reply Guidelines
+
+### For ACCEPT:
+- "Fixed. [description of change]."
+- "Fixed in [file]. Also updated [related file] to maintain consistency."
+
+### For REJECT:
+- "Investigated — [reason this doesn't apply]. The current implementation [explanation]."
+- "This is intentional: [reason]. Changing it would [consequence]."
+
+### For grouped fixes:
+- "Addressed these comments together in [commit]. Changes: [bullet list]."
+
+**Never use performative agreement.** No "Great catch!", "You're absolutely right!", etc.
+Technical acknowledgment only.
+
+## Common Reviewer Mistakes to Watch For
+
+| Pattern | Reality |
+|---------|---------|
+| Suggesting abstraction for code used once | YAGNI — one usage doesn't need a helper |
+| Requesting error handling for impossible states | Trust internal code; only validate at boundaries |
+| Style preferences disguised as correctness | If it works and is readable, style is preference |
+| Suggesting patterns from a different language | Follow THIS codebase's patterns |
+| Not seeing the full file (diff-only context) | They may miss why code is structured this way |
+| "This could be a security issue" without specifics | Ask for the specific attack vector |
+| "Add tests for X" when X is already tested | Check before accepting |
+
+## Decision Record
+
+For each comment, record:
+```
+Comment #ID by @user on file:line
+Verdict: ACCEPT | REJECT | INVESTIGATE
+Reasoning: [1-2 sentences]
+Ripple effects: [list or "none"]
+Group: [group-id]
+```
+
+This record serves as the basis for reply content and fix planning.

package/src/commands/fix-pr.ts

@@ -0,0 +1,324 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadFixPrConfig, saveFixPrConfig, DEFAULT_FIX_PR_CONFIG } from "../fix-pr/config.js";
+import { buildFixPrOrchestratorPrompt } from "../fix-pr/prompt-builder.js";
+import type { FixPrConfig, ReviewerType, CommentReplyPolicy } from "../fix-pr/types.js";
+import {
+  generateFixPrSessionId,
+  createFixPrSession,
+  findActiveFixPrSession,
+  getSessionDir,
+} from "../storage/fix-pr-sessions.js";
+import { notifyInfo, notifyError, notifyWarning } from "../notifications/renderer.js";
+
+function getScriptsDir(): string {
+  return path.join(path.dirname(new URL(import.meta.url).pathname), "..", "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"),
+  ];
+  for (const p of candidates) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+export function registerFixPrCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("supi:fix-pr", {
+    description: "Fix PR review comments with token-optimized agent orchestration",
+    async handler(args, ctx) {
+      // ── Step 1: Detect PR ──────────────────────────────────────────
+      let prNumber: number | null = null;
+      let repo: string | null = null;
+
+      // Try to parse from args
+      const argTrimmed = args?.trim().replace("#", "") || "";
+      if (/^\d+$/.test(argTrimmed)) {
+        prNumber = parseInt(argTrimmed, 10);
+      }
+
+      // Detect repo
+      try {
+        const repoResult = await pi.exec("gh", ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"], { cwd: ctx.cwd });
+        if (repoResult.code === 0) repo = repoResult.stdout.trim();
+      } 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 pi.exec("gh", ["pr", "view", "--json", "number", "-q", ".number"], { cwd: ctx.cwd });
+          if (prResult.code === 0) prNumber = parseInt(prResult.stdout.trim(), 10);
+        } catch { /* ignore */ }
+      }
+
+      if (!prNumber) {
+        notifyError(ctx, "No PR found", "Provide PR number as argument or run from a PR branch");
+        return;
+      }
+
+      // ── Step 2: Load or create config ──────────────────────────────
+      let config = loadFixPrConfig(ctx.cwd);
+
+      if (!config && ctx.hasUI) {
+        config = await runSetupWizard(ctx);
+        if (!config) return; // user cancelled
+        saveFixPrConfig(ctx.cwd, config);
+        ctx.ui.notify("Fix-PR config saved to .omp/supipowers/fix-pr.json", "info");
+      }
+
+      if (!config) {
+        notifyError(ctx, "No fix-pr config", "Run interactively first to set up configuration");
+        return;
+      }
+
+      // ── Step 3: Session handling ───────────────────────────────────
+      let activeSession = findActiveFixPrSession(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(ctx.cwd, ledger);
+      }
+
+      // ── Step 4: Fetch initial comments ─────────────────────────────
+      const sessionDir = getSessionDir(ctx.cwd, ledger.id);
+      const scriptsDir = getScriptsDir();
+      const snapshotPath = path.join(sessionDir, "snapshots", `comments-${ledger.iteration}.jsonl`);
+
+      const fetchResult = await pi.exec("bash", [
+        path.join(scriptsDir, "fetch-pr-comments.sh"),
+        repo,
+        String(prNumber),
+        snapshotPath,
+      ], { cwd: ctx.cwd });
+
+      if (fetchResult.code !== 0) {
+        notifyError(ctx, "Failed to fetch PR comments", fetchResult.stderr);
+        return;
+      }
+
+      // Read the snapshot
+      let comments = "";
+      try {
+        comments = fs.readFileSync(snapshotPath, "utf-8").trim();
+      } catch {
+        notifyWarning(ctx, "No comments found", "PR has no review comments to process");
+        return;
+      }
+
+      if (!comments) {
+        notifyInfo(ctx, "No comments to process", "PR has no review comments");
+        return;
+      }
+
+      const commentCount = comments.split("\n").length;
+
+      // ── Step 5: Load skill ─────────────────────────────────────────
+      let skillContent = "";
+      const skillPath = findSkillPath("fix-pr");
+      if (skillPath) {
+        try {
+          skillContent = fs.readFileSync(skillPath, "utf-8");
+        } catch { /* proceed without */ }
+      }
+
+      // ── Step 6: Build and send prompt ──────────────────────────────
+      const prompt = buildFixPrOrchestratorPrompt({
+        prNumber,
+        repo,
+        comments,
+        sessionDir,
+        scriptsDir,
+        config,
+        iteration: ledger.iteration,
+        skillContent,
+      });
+
+      pi.sendMessage(
+        {
+          customType: "supi-fix-pr",
+          content: [{ type: "text", text: prompt }],
+          display: "none",
+        },
+        { deliverAs: "steer" },
+      );
+
+      notifyInfo(ctx, `Fix-PR started: PR #${prNumber}`, `${commentCount} comments to assess | session ${ledger.id}`);
+    },
+  });
+}
+
+// ── Setup Wizard ───────────────────────────────────────────────────────
+
+const REVIEWER_OPTIONS = [
+  "CodeRabbit",
+  "GitHub Copilot",
+  "Gemini Code Review",
+  "None",
+];
+
+const REVIEWER_DEFAULTS: Record<string, string> = {
+  "CodeRabbit": "/review",
+  "GitHub Copilot": "@copilot review",
+  "Gemini Code Review": "/gemini review",
+};
+
+const POLICY_OPTIONS = [
+  "Answer all comments",
+  "Only answer wrong/unnecessary ones (recommended)",
+  "Don't answer, just fix",
+];
+
+const DELAY_OPTIONS = [
+  "60 seconds",
+  "120 seconds",
+  "180 seconds (recommended)",
+  "300 seconds",
+];
+
+const ITERATION_OPTIONS = [
+  "1",
+  "2",
+  "3 (recommended)",
+  "5",
+];
+
+const MODEL_TIER_OPTIONS = [
+  "high — thorough reasoning, more tokens",
+  "low — fast execution, fewer tokens",
+];
+
+async function runSetupWizard(ctx: any): Promise<FixPrConfig | null> {
+  // 1. Automated reviewer
+  const reviewerChoice = await ctx.ui.select(
+    "Automated PR reviewer",
+    REVIEWER_OPTIONS,
+    { helpText: "Select your automated reviewer, if any" },
+  );
+  if (!reviewerChoice) return null;
+
+  let reviewerType: ReviewerType = "none";
+  let triggerMethod: string | null = null;
+
+  if (reviewerChoice !== "None") {
+    reviewerType = reviewerChoice.toLowerCase().replace(/ /g, "").replace("github", "") as ReviewerType;
+    // Normalize to our type names
+    if (reviewerChoice === "CodeRabbit") reviewerType = "coderabbit";
+    else if (reviewerChoice === "GitHub Copilot") reviewerType = "copilot";
+    else if (reviewerChoice === "Gemini Code Review") reviewerType = "gemini";
+
+    const defaultTrigger = REVIEWER_DEFAULTS[reviewerChoice] || "";
+    triggerMethod = await ctx.ui.input(
+      "How to trigger re-review?",
+      defaultTrigger,
+      { helpText: `Default for ${reviewerChoice}: ${defaultTrigger}` },
+    );
+    if (triggerMethod === undefined) return null;
+    if (!triggerMethod) triggerMethod = defaultTrigger;
+  }
+
+  // 2. Comment reply policy
+  const policyChoice = await ctx.ui.select(
+    "Comment reply policy",
+    POLICY_OPTIONS,
+    { helpText: "How should we handle replying to comments?" },
+  );
+  if (!policyChoice) return null;
+
+  let commentPolicy: CommentReplyPolicy = "answer-selective";
+  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,
+    { helpText: "How long to wait for reviewer after pushing changes" },
+  );
+  if (!delayChoice) return null;
+  const delaySeconds = parseInt(delayChoice, 10);
+
+  const iterChoice = await ctx.ui.select(
+    "Max review iterations",
+    ITERATION_OPTIONS,
+    { helpText: "Maximum fix-check-fix cycles" },
+  );
+  if (!iterChoice) return null;
+  const maxIterations = parseInt(iterChoice, 10);
+
+  // 4. Model preferences
+  const orchestratorTier = await ctx.ui.select(
+    "Orchestrator model tier (assessment & grouping)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Higher tier = more thorough analysis" },
+  );
+  if (!orchestratorTier) return null;
+
+  const plannerTier = await ctx.ui.select(
+    "Planner model tier (fix planning)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Higher tier = more detailed plans" },
+  );
+  if (!plannerTier) return null;
+
+  const fixerTier = await ctx.ui.select(
+    "Fixer model tier (code changes)",
+    MODEL_TIER_OPTIONS,
+    { helpText: "Lower tier usually sufficient for execution" },
+  );
+  if (!fixerTier) return null;
+
+  const config: FixPrConfig = {
+    reviewer: { type: reviewerType, triggerMethod },
+    commentPolicy,
+    loop: { delaySeconds, maxIterations },
+    models: {
+      orchestrator: {
+        ...DEFAULT_FIX_PR_CONFIG.models.orchestrator,
+        tier: orchestratorTier.startsWith("high") ? "high" : "low",
+      },
+      planner: {
+        ...DEFAULT_FIX_PR_CONFIG.models.planner,
+        tier: plannerTier.startsWith("high") ? "high" : "low",
+      },
+      fixer: {
+        ...DEFAULT_FIX_PR_CONFIG.models.fixer,
+        tier: fixerTier.startsWith("high") ? "high" : "low",
+      },
+    },
+  };
+
+  return config;
+}

package/src/commands/supi.ts

@@ -16,6 +16,7 @@ export function handleSupi(pi: ExtensionAPI, ctx: ExtensionContext): void {
       "/supi:run      — Execute a plan with sub-agents",
       "/supi:review   — Run quality gates",
       "/supi:qa       — Run QA pipeline",
+      "/supi:fix-pr   — Fix PR review comments",
       "/supi:release  — Release automation",
       "/supi:config   — Manage configuration",
       "/supi:status   — Check running tasks",

package/src/fix-pr/config.ts

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { FixPrConfig } from "./types.js";
+
+const CONFIG_FILENAME = "fix-pr.json";
+
+function getConfigPath(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", CONFIG_FILENAME);
+}
+
+export const DEFAULT_FIX_PR_CONFIG: FixPrConfig = {
+  reviewer: { type: "none", triggerMethod: null },
+  commentPolicy: "answer-selective",
+  loop: { delaySeconds: 180, maxIterations: 3 },
+  models: {
+    orchestrator: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
+    planner: { provider: "anthropic", model: "claude-opus-4-6", tier: "high" },
+    fixer: { provider: "anthropic", model: "claude-sonnet-4-6", tier: "low" },
+  },
+};
+
+export function loadFixPrConfig(cwd: string): FixPrConfig | null {
+  const configPath = getConfigPath(cwd);
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8")) as FixPrConfig;
+  } catch {
+    return null;
+  }
+}
+
+export function saveFixPrConfig(cwd: string, config: FixPrConfig): void {
+  const configPath = getConfigPath(cwd);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}

package/src/fix-pr/prompt-builder.ts

@@ -0,0 +1,201 @@
+import type { FixPrConfig } from "./types.js";
+import { buildReceivingReviewInstructions } from "../discipline/receiving-review.js";
+
+export interface FixPrPromptOptions {
+  prNumber: number;
+  repo: string;
+  comments: string;
+  sessionDir: string;
+  scriptsDir: string;
+  config: FixPrConfig;
+  iteration: number;
+  skillContent: string;
+}
+
+function buildReplyInstructions(config: FixPrConfig): string {
+  const { commentPolicy, repo, } = config;
+  const replyCmd = `gh api repos/REPO/pulls/PR/comments/COMMENT_ID/replies -f body="..."`;
+
+  switch (commentPolicy) {
+    case "no-answer":
+      return [
+        "### Comment Replies",
+        "",
+        "Policy: **Do not reply** to any comments. Focus only on fixing the code.",
+        "Do not post any replies via gh api.",
+      ].join("\n");
+    case "answer-all":
+      return [
+        "### Comment Replies",
+        "",
+        "Policy: **Answer all** comments — both accepted and rejected.",
+        "For each comment, post a reply explaining what was done or why it was rejected.",
+        `Use: \`${replyCmd}\``,
+        "Keep replies factual and technical. No performative agreement.",
+      ].join("\n");
+    case "answer-selective":
+      return [
+        "### Comment Replies",
+        "",
+        "Policy: **Answer selectively** — only reply to comments you reject or where clarification adds value.",
+        "For ACCEPT: fix silently (the code change speaks for itself).",
+        "For REJECT: explain why with technical reasoning.",
+        `Use: \`${replyCmd}\``,
+        "Keep replies factual. No performative agreement.",
+      ].join("\n");
+  }
+}
+
+export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): string {
+  const { prNumber, repo, comments, sessionDir, scriptsDir, config, iteration, skillContent } = options;
+  const { loop, models, reviewer } = config;
+  const maxIter = loop.maxIterations;
+  const delay = loop.delaySeconds;
+
+  const sections: string[] = [
+    "# PR Review Fix Orchestration",
+    "",
+    `You are the orchestrator for fixing PR #${prNumber} on \`${repo}\`.`,
+    "",
+    "## Session Context",
+    "",
+    `- Session dir: \`${sessionDir}\``,
+    `- Iteration: ${iteration} of ${maxIter}`,
+    `- Comment reply policy: ${config.commentPolicy}`,
+    `- Reviewer: ${reviewer.type}${reviewer.triggerMethod ? ` (trigger: ${reviewer.triggerMethod})` : ""}`,
+    "",
+    "## Review Comments to Process",
+    "",
+    "Each line is a JSON object with comment data:",
+    "",
+    "```jsonl",
+    comments,
+    "```",
+    "",
+  ];
+
+  // Embedded skill
+  if (skillContent) {
+    sections.push(
+      "## Assessment Methodology",
+      "",
+      skillContent,
+      "",
+    );
+  }
+
+  // Receiving review discipline
+  sections.push(
+    "## Review Discipline",
+    "",
+    buildReceivingReviewInstructions(),
+    "",
+  );
+
+  // Step 1: Assess
+  sections.push(
+    "## Step 1: Assess Each Comment",
+    "",
+    "For each comment:",
+    "1. Read the actual code at the file and line referenced",
+    "2. Determine the verdict: **ACCEPT** / **REJECT** / **INVESTIGATE**",
+    "3. Check ripple effects — who calls this, what tests cover it",
+    "4. YAGNI check — does the reviewer's suggestion address a real problem?",
+    "",
+    "Record your assessment:",
+    "```",
+    "Comment #ID by @user on file:line",
+    "Verdict: ACCEPT | REJECT | INVESTIGATE",
+    "Reasoning: [1-2 sentences]",
+    "Ripple effects: [list or none]",
+    "Group: [group-id]",
+    "```",
+    "",
+  );
+
+  // Step 2: Group
+  sections.push(
+    "## Step 2: Group Comments",
+    "",
+    "Group accepted comments for parallel execution:",
+    "- Same file or tightly coupled files → same group",
+    "- Independent files/areas → separate groups",
+    "- Cosmetic vs functional → separate groups",
+    "",
+  );
+
+  // Step 3: Plan
+  sections.push(
+    "## Step 3: Plan Each Group",
+    "",
+    "For each group, create a fix plan:",
+    "- What changes are needed and why",
+    "- Which files to modify",
+    "- Expected ripple effects and how to handle them",
+    "- How to verify the fix (which tests to run)",
+    "",
+  );
+
+  // Step 4: Execute
+  sections.push(
+    "## Step 4: Execute Fixes",
+    "",
+    "For each group:",
+    "1. Make the code changes",
+    "2. Run relevant tests to verify",
+    "3. If tests fail, fix before moving on",
+    "",
+  );
+
+  // Step 5: Reply
+  sections.push(buildReplyInstructions(config), "");
+
+  // Step 6: Push and loop
+  sections.push(
+    "## Step 6: Push and Check for New Comments",
+    "",
+    '1. Stage and commit: `git add -A && git commit -m "fix: address PR review comments (iteration ' + iteration + ')"`',
+    "2. Push: `git push`",
+  );
+
+  if (reviewer.type !== "none" && reviewer.triggerMethod) {
+    sections.push(
+      `3. Trigger re-review: \`bash ${scriptsDir}/trigger-review.sh "${repo}" ${prNumber} "${reviewer.type}" "${reviewer.triggerMethod}"\``,
+    );
+  }
+
+  sections.push(
+    `${reviewer.type !== "none" ? "4" : "3"}. Run the check script:`,
+    "```bash",
+    `bash ${scriptsDir}/wait-and-check.sh "${sessionDir}" ${delay} ${iteration + 1} "${repo}" ${prNumber}`,
+    "```",
+    `${reviewer.type !== "none" ? "5" : "4"}. Read the last line of output:`,
+    `   - If \`hasNewComments: true\` and iteration < ${maxIter}: process the new comments (go back to Step 1)`,
+    `   - If \`hasNewComments: false\` or iteration >= ${maxIter}: report done`,
+    "",
+  );
+
+  // Script paths reference
+  sections.push(
+    "## Script Paths",
+    "",
+    `- fetch-pr-comments.sh: \`${scriptsDir}/fetch-pr-comments.sh\``,
+    `- diff-comments.sh: \`${scriptsDir}/diff-comments.sh\``,
+    `- trigger-review.sh: \`${scriptsDir}/trigger-review.sh\``,
+    `- wait-and-check.sh: \`${scriptsDir}/wait-and-check.sh\``,
+    "",
+  );
+
+  // Model guidance
+  sections.push(
+    "## Model Guidance",
+    "",
+    `- **Orchestrator** (assessment, grouping): ${models.orchestrator.model} (${models.orchestrator.tier} tier) — thorough analysis`,
+    `- **Planner** (fix planning): ${models.planner.model} (${models.planner.tier} tier) — detailed planning`,
+    `- **Fixer** (code changes): ${models.fixer.model} (${models.fixer.tier} tier) — focused execution`,
+    "",
+    "These indicate the expected reasoning depth for each phase of work.",
+  );
+
+  return sections.join("\n");
+}

package/src/fix-pr/scripts/diff-comments.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Compares two JSONL comment snapshots, outputs only new/changed comments
+# Usage: diff-comments.sh <prev_snapshot> <new_snapshot>
+# Exit 0 if new comments found, exit 1 if identical
+set -euo pipefail
+
+PREV="$1"
+NEW="$2"
+
+# If no previous snapshot, all comments are new
+if [[ ! -f "$PREV" ]]; then
+  cat "$NEW"
+  exit 0
+fi
+
+# Build fingerprint: id + updatedAt for each comment
+prev_fingerprints=$(jq -r '[.id, .updatedAt] | @tsv' "$PREV" 2>/dev/null | sort)
+new_fingerprints=$(jq -r '[.id, .updatedAt] | @tsv' "$NEW" 2>/dev/null | sort)
+
+# Find IDs that are new or changed
+new_ids=$(comm -13 <(echo "$prev_fingerprints") <(echo "$new_fingerprints") | cut -f1)
+
+if [[ -z "$new_ids" ]]; then
+  exit 1
+fi
+
+# Output the full comment objects for new/changed IDs
+while IFS= read -r id; do
+  [[ -z "$id" ]] && continue
+  jq -c "select(.id == $id)" "$NEW"
+done <<< "$new_ids"
+
+exit 0

package/src/fix-pr/scripts/fetch-pr-comments.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+# Fetches all review comments for a PR, outputs JSONL
+# Usage: fetch-pr-comments.sh <owner/repo> <pr_number> <output_file>
+set -euo pipefail
+
+REPO="$1"
+PR="$2"
+OUTPUT="$3"
+
+# Ensure output directory exists
+mkdir -p "$(dirname "$OUTPUT")"
+
+# Fetch inline review comments (code-level)
+gh api --paginate "repos/${REPO}/pulls/${PR}/comments" \
+  --jq '.[] | {id, path, line: .line, body, user: .user.login, createdAt: .created_at, updatedAt: .updated_at, inReplyToId: .in_reply_to_id, diffHunk: .diff_hunk, state: "COMMENTED"}' \
+  > "$OUTPUT" 2>/dev/null || true
+
+# Fetch review-level comments (top-level reviews with body text)
+gh api --paginate "repos/${REPO}/pulls/${PR}/reviews" \
+  --jq '.[] | select(.body != null and .body != "") | {id, path: null, line: null, body, user: .user.login, createdAt: .submitted_at, updatedAt: .submitted_at, inReplyToId: null, diffHunk: null, state}' \
+  >> "$OUTPUT" 2>/dev/null || true
+
+# Output summary to stderr for caller
+TOTAL=$(wc -l < "$OUTPUT" | tr -d ' ')
+echo "{\"total\": ${TOTAL}}" >&2

package/src/fix-pr/scripts/trigger-review.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Triggers automated reviewer to re-review a PR
+# Usage: trigger-review.sh <owner/repo> <pr_number> <reviewer_type> <trigger_method>
+set -euo pipefail
+
+REPO="$1"
+PR="$2"
+REVIEWER="$3"
+METHOD="${4:-}"
+
+case "$REVIEWER" in
+  coderabbit)
+    gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
+    echo '{"triggered": true, "reviewer": "coderabbit"}'
+    ;;
+  copilot)
+    if [[ -n "$METHOD" ]]; then
+      gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
+    else
+      gh api "repos/${REPO}/pulls/${PR}/requested_reviewers" \
+        --method POST -f "reviewers[]=copilot" >/dev/null 2>&1 || true
+    fi
+    echo '{"triggered": true, "reviewer": "copilot"}'
+    ;;
+  gemini)
+    gh api "repos/${REPO}/issues/${PR}/comments" -f body="$METHOD" >/dev/null 2>&1
+    echo '{"triggered": true, "reviewer": "gemini"}'
+    ;;
+  none)
+    echo '{"triggered": false, "reviewer": "none"}'
+    ;;
+  *)
+    echo '{"triggered": false, "error": "unknown reviewer type: '"$REVIEWER"'"}'
+    exit 1
+    ;;
+esac

package/src/fix-pr/scripts/wait-and-check.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Waits for delay, fetches new PR comments, diffs against previous snapshot
+# Usage: wait-and-check.sh <session_dir> <delay_seconds> <iteration> <owner/repo> <pr_number>
+# Output: new comment lines + JSON summary on last line
+set -euo pipefail
+
+SESSION_DIR="$1"
+DELAY="$2"
+ITERATION="$3"
+REPO="$4"
+PR="$5"
+
+SNAPSHOTS_DIR="${SESSION_DIR}/snapshots"
+PREV_ITERATION=$((ITERATION - 1))
+PREV_SNAPSHOT="${SNAPSHOTS_DIR}/comments-${PREV_ITERATION}.jsonl"
+NEW_SNAPSHOT="${SNAPSHOTS_DIR}/comments-${ITERATION}.jsonl"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+# Wait for reviewer to process
+echo "Waiting ${DELAY}s for reviewer to process changes..." >&2
+sleep "$DELAY"
+
+# Fetch new comments
+echo "Fetching PR comments (iteration ${ITERATION})..." >&2
+bash "${SCRIPT_DIR}/fetch-pr-comments.sh" "$REPO" "$PR" "$NEW_SNAPSHOT"
+
+# Diff against previous
+DIFF_OUTPUT=$(bash "${SCRIPT_DIR}/diff-comments.sh" "$PREV_SNAPSHOT" "$NEW_SNAPSHOT" 2>/dev/null) || true
+
+if [[ -n "$DIFF_OUTPUT" ]]; then
+  DIFF_COUNT=$(echo "$DIFF_OUTPUT" | wc -l | tr -d ' ')
+  echo "$DIFF_OUTPUT"
+  echo "{\"hasNewComments\": true, \"count\": ${DIFF_COUNT}, \"iteration\": ${ITERATION}}"
+else
+  echo "{\"hasNewComments\": false, \"count\": 0, \"iteration\": ${ITERATION}}"
+fi

package/src/fix-pr/types.ts

@@ -0,0 +1,71 @@
+/** Supported automated PR reviewers */
+export type ReviewerType = "coderabbit" | "copilot" | "gemini" | "none";
+
+/** How to handle comment replies */
+export type CommentReplyPolicy = "answer-all" | "answer-selective" | "no-answer";
+
+/** Model preference for a specific role */
+export interface ModelPref {
+  provider: string;
+  model: string;
+  tier: "low" | "high";
+}
+
+/** Per-repo fix-pr configuration */
+export interface FixPrConfig {
+  reviewer: {
+    type: ReviewerType;
+    triggerMethod: string | null;
+  };
+  commentPolicy: CommentReplyPolicy;
+  loop: {
+    delaySeconds: number;
+    maxIterations: number;
+  };
+  models: {
+    orchestrator: ModelPref;
+    planner: ModelPref;
+    fixer: ModelPref;
+  };
+}
+
+/** A PR review comment from GitHub API */
+export interface PrComment {
+  id: number;
+  path: string | null;
+  line: number | null;
+  body: string;
+  user: string;
+  createdAt: string;
+  updatedAt: string;
+  inReplyToId: number | null;
+  diffHunk: string | null;
+  state: string;
+}
+
+/** Assessment verdict for a single comment */
+export type CommentVerdict = "accept" | "reject" | "investigate";
+
+/** A group of related comments to fix together */
+export interface FixGroup {
+  id: string;
+  commentIds: number[];
+  files: string[];
+  description: string;
+}
+
+/** Session status */
+export type FixPrSessionStatus = "running" | "completed" | "failed";
+
+/** Session ledger for a fix-pr run */
+export interface FixPrSessionLedger {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  prNumber: number;
+  repo: string;
+  status: FixPrSessionStatus;
+  iteration: number;
+  config: FixPrConfig;
+  commentsProcessed: number[];
+}

package/src/index.ts

@@ -12,6 +12,7 @@ import { registerReviewCommand } from "./commands/review.js";
 import { registerQaCommand } from "./commands/qa.js";
 import { registerReleaseCommand } from "./commands/release.js";
 import { registerUpdateCommand, handleUpdate } from "./commands/update.js";
+import { registerFixPrCommand } from "./commands/fix-pr.js";
 
 // TUI-only commands — intercepted at the input level to prevent
 // message submission and "Working..." indicator
@@ -43,6 +44,7 @@ export default function supipowers(pi: ExtensionAPI): void {
   registerQaCommand(pi);
   registerReleaseCommand(pi);
   registerUpdateCommand(pi);
+  registerFixPrCommand(pi);
 
   // Intercept TUI-only commands at the input level — this runs BEFORE
   // message submission, so no chat message appears and no "Working..." indicator

package/src/storage/fix-pr-sessions.ts

@@ -0,0 +1,59 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { FixPrSessionLedger } from "../fix-pr/types.js";
+
+const SESSIONS_DIR = "fix-pr-sessions";
+
+function getBaseDir(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", SESSIONS_DIR);
+}
+
+export function getSessionDir(cwd: string, sessionId: string): string {
+  return path.join(getBaseDir(cwd), sessionId);
+}
+
+export function generateFixPrSessionId(): string {
+  const now = new Date();
+  const date = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const time = now.toTimeString().slice(0, 8).replace(/:/g, "");
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `fpr-${date}-${time}-${rand}`;
+}
+
+export function createFixPrSession(cwd: string, ledger: FixPrSessionLedger): void {
+  const sessionDir = getSessionDir(cwd, ledger.id);
+  fs.mkdirSync(path.join(sessionDir, "snapshots"), { recursive: true });
+  fs.writeFileSync(path.join(sessionDir, "ledger.json"), JSON.stringify(ledger, null, 2));
+}
+
+export function loadFixPrSession(cwd: string, sessionId: string): FixPrSessionLedger | null {
+  const ledgerPath = path.join(getSessionDir(cwd, sessionId), "ledger.json");
+  if (!fs.existsSync(ledgerPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(ledgerPath, "utf-8")) as FixPrSessionLedger;
+  } catch {
+    return null;
+  }
+}
+
+export function updateFixPrSession(cwd: string, ledger: FixPrSessionLedger): void {
+  const ledgerPath = path.join(getSessionDir(cwd, ledger.id), "ledger.json");
+  ledger.updatedAt = new Date().toISOString();
+  fs.writeFileSync(ledgerPath, JSON.stringify(ledger, null, 2));
+}
+
+export function findActiveFixPrSession(cwd: string): FixPrSessionLedger | null {
+  const baseDir = getBaseDir(cwd);
+  if (!fs.existsSync(baseDir)) return null;
+
+  const dirs = fs.readdirSync(baseDir)
+    .filter((d) => d.startsWith("fpr-"))
+    .sort()
+    .reverse();
+
+  for (const dir of dirs) {
+    const ledger = loadFixPrSession(cwd, dir);
+    if (ledger && ledger.status === "running") return ledger;
+  }
+  return null;
+}