supipowers 0.3.0 → 0.5.0

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/qa/config.ts

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { E2eQaConfig } from "./types.js";
+
+const CONFIG_FILENAME = "e2e-qa.json";
+
+function getConfigPath(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", CONFIG_FILENAME);
+}
+
+export const DEFAULT_E2E_QA_CONFIG: E2eQaConfig = {
+  app: {
+    type: "generic",
+    devCommand: "npm run dev",
+    port: 3000,
+    baseUrl: "http://localhost:3000",
+  },
+  playwright: {
+    browser: "chromium",
+    headless: true,
+    timeout: 30000,
+  },
+  execution: {
+    maxRetries: 2,
+    maxFlows: 20,
+  },
+};
+
+export function loadE2eQaConfig(cwd: string): E2eQaConfig | null {
+  const configPath = getConfigPath(cwd);
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8")) as E2eQaConfig;
+  } catch {
+    return null;
+  }
+}
+
+export function saveE2eQaConfig(cwd: string, config: E2eQaConfig): void {
+  const configPath = getConfigPath(cwd);
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}

package/src/qa/matrix.ts

@@ -0,0 +1,84 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { E2eMatrix, E2eFlowRecord, E2eTestResult, E2eRegression } from "./types.js";
+
+const MATRIX_FILENAME = "e2e-matrix.json";
+
+function getMatrixPath(cwd: string): string {
+  return path.join(cwd, ".omp", "supipowers", MATRIX_FILENAME);
+}
+
+export function createEmptyMatrix(appType: string): E2eMatrix {
+  return {
+    version: "1.0.0",
+    updatedAt: new Date().toISOString(),
+    appType,
+    flows: [],
+  };
+}
+
+export function loadE2eMatrix(cwd: string): E2eMatrix | null {
+  const matrixPath = getMatrixPath(cwd);
+  if (!fs.existsSync(matrixPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(matrixPath, "utf-8")) as E2eMatrix;
+  } catch {
+    return null;
+  }
+}
+
+export function saveE2eMatrix(cwd: string, matrix: E2eMatrix): void {
+  const matrixPath = getMatrixPath(cwd);
+  fs.mkdirSync(path.dirname(matrixPath), { recursive: true });
+  fs.writeFileSync(matrixPath, JSON.stringify(matrix, null, 2));
+}
+
+export function detectRegressions(
+  previousFlows: E2eFlowRecord[],
+  results: E2eTestResult[],
+): E2eRegression[] {
+  const regressions: E2eRegression[] = [];
+
+  for (const result of results) {
+    if (result.status !== "fail") continue;
+
+    const previousFlow = previousFlows.find((f) => f.id === result.flowId);
+    if (!previousFlow || previousFlow.lastStatus !== "pass") continue;
+
+    regressions.push({
+      flowId: result.flowId,
+      flowName: previousFlow.name,
+      previousStatus: "pass",
+      currentStatus: "fail",
+      error: result.error ?? "Unknown error",
+    });
+  }
+
+  return regressions;
+}
+
+export function updateMatrixFromResults(
+  matrix: E2eMatrix,
+  results: E2eTestResult[],
+): E2eMatrix {
+  const now = new Date().toISOString();
+  const resultMap = new Map(results.map((r) => [r.flowId, r]));
+
+  const updatedFlows = matrix.flows.map((flow) => {
+    const result = resultMap.get(flow.id);
+    if (!result) return flow;
+
+    return {
+      ...flow,
+      lastStatus: result.status === "skip" ? flow.lastStatus : (result.status as "pass" | "fail"),
+      lastTestedAt: now,
+      lastError: result.status === "fail" ? result.error : undefined,
+    };
+  });
+
+  return {
+    ...matrix,
+    updatedAt: now,
+    flows: updatedFlows,
+  };
+}