supipowers 1.5.3 → 2.0.0

package/src/fix-pr/assessment.ts

@@ -0,0 +1,200 @@
+// src/fix-pr/assessment.ts
+//
+// Runs the structured per-comment assessment for fix-pr. One schema-backed
+// AI call per cluster; the validated FixPrAssessmentBatch is the single
+// source of truth for downstream work batches.
+
+import type { Platform, PlatformPaths } from "../platform/types.js";
+import {
+  parseStructuredOutput,
+  runWithOutputValidation,
+  type StructuredOutputResult,
+} from "../ai/structured-output.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import {
+  FixPrAssessmentBatchSchema,
+  type FixPrAssessmentBatch,
+  type FixPrWorkBatch,
+} from "./contracts.js";
+import type { PrComment } from "./types.js";
+
+export interface RunFixPrAssessmentInput {
+  createAgentSession: Platform["createAgentSession"];
+  paths?: PlatformPaths;
+  cwd: string;
+  comments: readonly PrComment[];
+  repo: string;
+  prNumber: number;
+  selectedTargetLabel: string;
+  model?: string;
+  thinkingLevel?: string | null;
+  maxAttempts?: number;
+}
+
+interface BuildAssessmentPromptArgs {
+  schemaText: string;
+  comments: readonly PrComment[];
+  repo: string;
+  prNumber: number;
+  selectedTargetLabel: string;
+}
+
+function buildAssessmentPrompt(args: BuildAssessmentPromptArgs): string {
+  const commentsJsonl = args.comments.map((c) => JSON.stringify(c)).join("\n");
+  return [
+    "# Fix-PR Assessment",
+    "",
+    `You are assessing PR review comments on \`${args.repo}\` PR #${args.prNumber} for target: ${args.selectedTargetLabel}.`,
+    "",
+    "For each comment, emit one assessment object with:",
+    `- verdict: "apply" (reviewer is right, fix it), "reject" (reviewer is wrong, explain), "investigate" (needs more info before deciding)`,
+    "- rationale: 1-3 sentences of technical reasoning grounded in the actual code",
+    `- affectedFiles: files that would be edited if verdict is "apply"; empty array otherwise`,
+    "- rippleEffects: downstream impacts (callers, tests, docs); empty array if none",
+    "- verificationPlan: how to confirm the fix is correct (which tests to run, behaviour to check)",
+    "",
+    "Rules:",
+    "- Read the referenced code before assigning a verdict.",
+    "- Do not perform any code edits. This is a pure assessment pass.",
+    "- One assessment per comment. `commentId` ties back to the PR comment id.",
+    "",
+    "Comments (JSONL, one per line):",
+    "```jsonl",
+    commentsJsonl,
+    "```",
+    "",
+    "Respond with a JSON object that matches this TypeScript shape exactly:",
+    "",
+    "```ts",
+    args.schemaText,
+    "```",
+    "",
+    "Respond with only the JSON object. You may wrap it in a ```json fence.",
+  ].join("\n");
+}
+
+/**
+ * Run a schema-backed assessment over a cluster of PR comments.
+ *
+ * Empty clusters short-circuit with `{ assessments: [] }` without calling
+ * the AI, so a no-op target can be persisted and grouped without cost.
+ */
+export async function runFixPrAssessment(
+  input: RunFixPrAssessmentInput,
+): Promise<StructuredOutputResult<FixPrAssessmentBatch>> {
+  if (input.comments.length === 0) {
+    return {
+      status: "ok",
+      output: { assessments: [] },
+      rawOutput: "",
+      attempts: 0,
+    };
+  }
+
+  const schemaText = renderSchemaText(FixPrAssessmentBatchSchema);
+  const prompt = buildAssessmentPrompt({
+    schemaText,
+    comments: input.comments,
+    repo: input.repo,
+    prNumber: input.prNumber,
+    selectedTargetLabel: input.selectedTargetLabel,
+  });
+
+  return runWithOutputValidation<FixPrAssessmentBatch>(
+    input.createAgentSession as any,
+    {
+      cwd: input.cwd,
+      prompt,
+      schema: schemaText,
+      parse: (raw) =>
+        parseStructuredOutput<FixPrAssessmentBatch>(raw, FixPrAssessmentBatchSchema),
+      model: input.model,
+      thinkingLevel: input.thinkingLevel ?? null,
+      maxAttempts: input.maxAttempts,
+      reliability: input.paths
+        ? { paths: input.paths, cwd: input.cwd, command: "fix-pr", operation: "assessment" }
+        : undefined,
+    },
+  );
+}
+
+/**
+ * Deterministic grouping rule:
+ *
+ * 1. Only `apply` verdicts produce work batches; `reject` and `investigate`
+ *    are preserved in the artifact but excluded here.
+ * 2. Two `apply` assessments go in the same batch when their `affectedFiles`
+ *    sets share at least one path (connected components over the file graph).
+ * 3. An `apply` assessment with empty `affectedFiles` is its own singleton
+ *    batch — nothing to merge against.
+ * 4. Within a batch, commentIds are sorted ascending; batches are ordered by
+ *    their smallest commentId. Batch ids are `batch-<minCommentId>`.
+ *
+ * The rule depends only on the validated artifact, so batching is a pure
+ * function of `FixPrAssessmentBatch`.
+ */
+export function groupAssessmentsIntoBatches(
+  batch: FixPrAssessmentBatch,
+): FixPrWorkBatch[] {
+  const applies = batch.assessments.filter((a) => a.verdict === "apply");
+  if (applies.length === 0) return [];
+
+  const parent = applies.map((_, i) => i);
+  const find = (i: number): number => {
+    let root = i;
+    while (parent[root] !== root) root = parent[root];
+    // path compression
+    let cur = i;
+    while (parent[cur] !== root) {
+      const next = parent[cur];
+      parent[cur] = root;
+      cur = next;
+    }
+    return root;
+  };
+  const union = (a: number, b: number) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  };
+
+  const fileOwner = new Map<string, number>();
+  for (let i = 0; i < applies.length; i += 1) {
+    for (const file of applies[i].affectedFiles) {
+      const existing = fileOwner.get(file);
+      if (existing === undefined) {
+        fileOwner.set(file, i);
+      } else {
+        union(existing, i);
+      }
+    }
+  }
+
+  const groups = new Map<number, number[]>();
+  for (let i = 0; i < applies.length; i += 1) {
+    const root = find(i);
+    const list = groups.get(root);
+    if (list) list.push(i);
+    else groups.set(root, [i]);
+  }
+
+  const result: FixPrWorkBatch[] = [];
+  for (const members of groups.values()) {
+    const commentIds = members
+      .map((i) => applies[i].commentId)
+      .sort((a, b) => a - b);
+    const fileSet = new Set<string>();
+    for (const i of members) {
+      for (const f of applies[i].affectedFiles) fileSet.add(f);
+    }
+    const affectedFiles = [...fileSet].sort();
+    result.push({
+      id: `batch-${commentIds[0]}`,
+      commentIds,
+      affectedFiles,
+    });
+  }
+
+  result.sort((a, b) => a.commentIds[0] - b.commentIds[0]);
+  return result;
+}

package/src/fix-pr/contracts.ts

@@ -0,0 +1,47 @@
+// src/fix-pr/contracts.ts
+//
+// Schema-backed contract for the per-comment assessment artifact produced
+// before any code edits begin. Every fix-pr run must emit JSON that parses
+// against FixPrAssessmentBatchSchema; downstream work batches are derived
+// from this validated artifact, not from ad-hoc orchestration prose.
+
+import { Type, type Static } from "@sinclair/typebox";
+
+export const FIX_PR_ASSESSMENT_VERDICTS = ["apply", "reject", "investigate"] as const;
+export type FixPrAssessmentVerdict = (typeof FIX_PR_ASSESSMENT_VERDICTS)[number];
+
+export const FixPrCommentAssessmentSchema = Type.Object(
+  {
+    commentId: Type.Integer(),
+    verdict: Type.Union(
+      FIX_PR_ASSESSMENT_VERDICTS.map((value) => Type.Literal(value)),
+    ),
+    rationale: Type.String({ minLength: 1 }),
+    affectedFiles: Type.Array(Type.String({ minLength: 1 })),
+    rippleEffects: Type.Array(Type.String({ minLength: 1 })),
+    verificationPlan: Type.String({ minLength: 1 }),
+  },
+  { additionalProperties: false },
+);
+
+export const FixPrAssessmentBatchSchema = Type.Object(
+  {
+    assessments: Type.Array(FixPrCommentAssessmentSchema),
+    summary: Type.Optional(Type.String()),
+  },
+  { additionalProperties: false },
+);
+
+export type FixPrCommentAssessment = Static<typeof FixPrCommentAssessmentSchema>;
+export type FixPrAssessmentBatch = Static<typeof FixPrAssessmentBatchSchema>;
+
+/**
+ * A deterministic execution unit derived from a validated FixPrAssessmentBatch.
+ * Only `apply` verdicts produce work batches; reject/investigate are tracked in
+ * the assessment artifact but excluded from execution.
+ */
+export interface FixPrWorkBatch {
+  id: string;
+  commentIds: number[];
+  affectedFiles: string[];
+}

package/src/fix-pr/fetch-comments.ts

@@ -1,6 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Platform } from "../platform/types.js";
+import type { WorkspaceTarget } from "../types.js";
+import { findWorkspaceTargetForPath } from "../workspace/path-mapping.js";
+import type { PrComment } from "./types.js";
 
 const INLINE_COMMENTS_JQ =
   '.[] | {id, path, line: .line, body, user: .user.login, userType: .user.type, createdAt: .created_at, updatedAt: .updated_at, inReplyToId: .in_reply_to_id, diffHunk: .diff_hunk, state: "COMMENTED"}';
@@ -8,6 +11,83 @@ const INLINE_COMMENTS_JQ =
 const REVIEW_COMMENTS_JQ =
   '.[] | select(.body != null and .body != "") | {id, path: null, line: null, body, user: .user.login, userType: .user.type, createdAt: .submitted_at, updatedAt: .submitted_at, inReplyToId: null, diffHunk: null, state}';
 
+export interface ClusteredPrComments<TTarget extends WorkspaceTarget = WorkspaceTarget> {
+  allComments: PrComment[];
+  commentsByTargetId: Map<string, PrComment[]>;
+  unscopedComments: PrComment[];
+}
+
+function appendComment(commentsByTargetId: Map<string, PrComment[]>, targetId: string, comment: PrComment): void {
+  const existing = commentsByTargetId.get(targetId);
+  if (existing) {
+    existing.push(comment);
+    return;
+  }
+
+  commentsByTargetId.set(targetId, [comment]);
+}
+
+export function parsePrCommentsJsonl(content: string): PrComment[] {
+  return content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .flatMap((line) => {
+      try {
+        return [JSON.parse(line) as PrComment];
+      } catch {
+        return [];
+      }
+    });
+}
+
+export function stringifyPrCommentsJsonl(comments: readonly PrComment[]): string {
+  if (comments.length === 0) {
+    return "";
+  }
+
+  return `${comments.map((comment) => JSON.stringify(comment)).join("\n")}\n`;
+}
+
+export function clusterPrCommentsByTarget<TTarget extends WorkspaceTarget>(
+  targets: readonly TTarget[],
+  comments: readonly PrComment[],
+): ClusteredPrComments<TTarget> {
+  const commentsByTargetId = new Map<string, PrComment[]>();
+  const rootTarget = targets.find((target) => target.kind === "root") ?? null;
+  const unscopedComments: PrComment[] = [];
+
+  for (const target of targets) {
+    commentsByTargetId.set(target.id, []);
+  }
+
+  for (const comment of comments) {
+    const commentPath = comment.path?.trim();
+    if (!commentPath) {
+      if (targets.length === 1 && rootTarget) {
+        appendComment(commentsByTargetId, rootTarget.id, comment);
+      } else {
+        unscopedComments.push(comment);
+      }
+      continue;
+    }
+
+    const owner = findWorkspaceTargetForPath([...targets], commentPath);
+    if (!owner) {
+      unscopedComments.push(comment);
+      continue;
+    }
+
+    appendComment(commentsByTargetId, owner.id, comment);
+  }
+
+  return {
+    allComments: [...comments],
+    commentsByTargetId,
+    unscopedComments,
+  };
+}
+
 /**
  * Fetch all review comments for a PR and write them as JSONL to outputPath.
  *

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

@@ -1,4 +1,7 @@
 import type { FixPrConfig } from "./types.js";
+import type { FixPrAssessmentBatch, FixPrWorkBatch } from "./contracts.js";
+import { FixPrAssessmentBatchSchema } from "./contracts.js";
+import { renderSchemaText } from "../ai/schema-text.js";
 import { buildReceivingReviewInstructions } from "../discipline/receiving-review.js";
 
 export interface FixPrPromptOptions {
@@ -10,8 +13,11 @@ export interface FixPrPromptOptions {
   config: FixPrConfig;
   iteration: number;
   skillContent: string;
-  /** Resolved model ID for sub-agent tasks (planner, fixer roles). */
   taskModel: string;
+  selectedTargetLabel: string;
+  deferredCommentsSummary: string | null;
+  assessment: FixPrAssessmentBatch;
+  workBatches: FixPrWorkBatch[];
 }
 
 function buildReplyInstructions(config: FixPrConfig): string {
@@ -49,7 +55,21 @@ function buildReplyInstructions(config: FixPrConfig): string {
 }
 
 export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): string {
-  const { prNumber, repo, comments, sessionDir, scriptsDir, config, iteration, skillContent, taskModel } = options;
+  const {
+    prNumber,
+    repo,
+    comments,
+    sessionDir,
+    scriptsDir,
+    config,
+    iteration,
+    skillContent,
+    taskModel,
+    selectedTargetLabel,
+    deferredCommentsSummary,
+    assessment,
+    workBatches,
+  } = options;
   const { loop, reviewer } = config;
   const maxIter = loop.maxIterations;
   const delay = loop.delaySeconds;
@@ -63,8 +83,20 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
     `- Session dir: \`${sessionDir}\``,
     `- Iteration: ${iteration} of ${maxIter}`,
+    `- Selected target: ${selectedTargetLabel}`,
     `- Comment reply policy: ${config.commentPolicy}`,
     `- Reviewer: ${reviewer.type}${reviewer.triggerMethod ? ` (trigger: ${reviewer.triggerMethod})` : ""}`,
+    deferredCommentsSummary
+      ? `- Deferred comments outside this target: ${deferredCommentsSummary}`
+      : "- Deferred comments outside this target: none",
+    "",
+    "## Review Scope Rules",
+    "",
+    "- Process only the comments listed below for the selected target.",
+    deferredCommentsSummary
+      ? "- Comments outside the selected target were intentionally excluded for a separate run. Do not remediate them here."
+      : "- There are no deferred comments outside this target in this snapshot.",
+    "- After each wait-and-check cycle, keep enforcing the same target boundary. If new root or sibling-package comments appear, surface them explicitly and leave them for a separate run.",
     "",
     "## Review Comments to Process",
     "",
@@ -76,7 +108,6 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
   ];
 
-  // Embedded skill
   if (skillContent) {
     sections.push(
       "## Assessment Methodology",
@@ -86,7 +117,6 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     );
   }
 
-  // Receiving review discipline
   sections.push(
     "## Review Discipline",
     "",
@@ -94,39 +124,34 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
   );
 
-  // Step 1: Assess
   sections.push(
-    "## Step 1: Assess Each Comment",
+    "## Step 1: Validated Assessment Artifact",
     "",
-    "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?",
+    "The per-comment assessment for this run has already been validated against the `FixPrAssessmentBatchSchema` contract. Treat it as the source of truth: do not re-assess, do not change verdicts. Each entry has a verdict (`apply` / `reject` / `investigate`), rationale, affectedFiles, rippleEffects (downstream callers/tests/docs), and a verificationPlan.",
     "",
-    "Record your assessment:",
+    "Schema:",
+    "```ts",
+    renderSchemaText(FixPrAssessmentBatchSchema),
     "```",
-    "Comment #ID by @user on file:line",
-    "Verdict: ACCEPT | REJECT | INVESTIGATE",
-    "Reasoning: [1-2 sentences]",
-    "Ripple effects: [list or none]",
-    "Group: [group-id]",
+    "",
+    "Validated artifact:",
+    "```json",
+    JSON.stringify(assessment, null, 2),
     "```",
     "",
   );
 
-  // Step 2: Group
   sections.push(
-    "## Step 2: Group Comments",
+    "## Step 2: Work Batches (Parallel Execution Groups)",
+    "",
+    "Batches were derived deterministically from the artifact above by grouping `apply` assessments whose `affectedFiles` overlap. Independent batches may run in parallel; a batch's commentIds share at least one file and must execute together. `reject` and `investigate` verdicts produce no batch — handle those per the reply policy below.",
     "",
-    "Group accepted comments for parallel execution:",
-    "- Same file or tightly coupled files → same group",
-    "- Independent files/areas → separate groups",
-    "- Cosmetic vs functional → separate groups",
+    "```json",
+    JSON.stringify(workBatches, null, 2),
+    "```",
     "",
   );
 
-  // Step 3: Plan
   sections.push(
     "## Step 3: Plan Each Group",
     "",
@@ -138,7 +163,6 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
   );
 
-  // Step 4: Execute
   sections.push(
     "## Step 4: Execute Fixes",
     "",
@@ -149,27 +173,25 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
   );
 
-  // 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 + ')"`',
+    `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}"\``,
+      `3. Trigger re-review: \`bun \"${scriptsDir}/trigger-review.ts\" \"${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" ? "4" : "3"}. Run the wait-and-check runner:`,
+    "```text",
+    `bun \"${scriptsDir}/wait-and-check.ts\" \"${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)`,
@@ -177,22 +199,18 @@ export function buildFixPrOrchestratorPrompt(options: FixPrPromptOptions): strin
     "",
   );
 
-  // Script paths reference
   sections.push(
-    "## Script Paths",
+    "## Runner 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\``,
+    `- trigger-review.ts: \`${scriptsDir}/trigger-review.ts\``,
+    `- wait-and-check.ts: \`${scriptsDir}/wait-and-check.ts\``,
     "",
   );
 
-  // Model guidance
   sections.push(
     "## Model Guidance",
     "",
-    `- **Orchestrator** (this session): handles assessment & grouping`,
+    "- **Orchestrator** (this session): handles assessment & grouping",
     `- **Planner & Fixer** (sub-agents): use model \`${taskModel}\``,
     "",
     "Sub-agents inherit the task model for planning and code changes.",

package/src/fix-pr/scripts/exec.ts

@@ -0,0 +1,34 @@
+import { spawnSync } from "node:child_process";
+import type { ExecOptions, ExecResult, Platform } from "../../platform/types.js";
+import { findExecutable } from "../../utils/executable.js";
+
+export function runCliCommand(
+  command: string,
+  args: string[],
+  options?: ExecOptions,
+): ExecResult {
+  const env = options?.env ? { ...process.env, ...options.env } : process.env;
+  const resolvedCommand = findExecutable(command, {
+    searchPath: env.PATH,
+    pathext: env.PATHEXT,
+  }) ?? command;
+
+  const result = spawnSync(resolvedCommand, args, {
+    cwd: options?.cwd,
+    env,
+    encoding: "utf8",
+  });
+
+  return {
+    stdout: result.stdout ?? "",
+    stderr: result.stderr || (result.error instanceof Error ? result.error.message : ""),
+    code: result.status ?? (result.error ? 1 : 0),
+    killed: result.signal != null,
+  };
+}
+
+export function createCliPlatformExec(): Pick<Platform, "exec"> {
+  return {
+    exec: async (command, args, options) => runCliCommand(command, args, options),
+  };
+}

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

@@ -0,0 +1,106 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { runCliCommand } from "./exec.js";
+
+export interface TriggerReviewResult {
+  triggered: boolean;
+  reviewer: string;
+  error?: string;
+}
+
+function buildResult(result: TriggerReviewResult): string {
+  return JSON.stringify(result);
+}
+
+function postIssueComment(repo: string, prNumber: number, body: string): TriggerReviewResult {
+  const result = runCliCommand("gh", [
+    "api",
+    `repos/${repo}/issues/${prNumber}/comments`,
+    "-f",
+    `body=${body}`,
+  ]);
+
+  if (result.code !== 0) {
+    throw new Error(result.stderr || result.stdout || "gh api comment request failed");
+  }
+
+  return { triggered: true, reviewer: "comment" };
+}
+
+export function triggerReview(
+  repo: string,
+  prNumber: number,
+  reviewer: string,
+  triggerMethod = "",
+): { exitCode: number; output: string } {
+  try {
+    switch (reviewer) {
+      case "coderabbit": {
+        postIssueComment(repo, prNumber, triggerMethod);
+        return { exitCode: 0, output: buildResult({ triggered: true, reviewer: "coderabbit" }) };
+      }
+      case "copilot": {
+        if (triggerMethod) {
+          postIssueComment(repo, prNumber, triggerMethod);
+        } else {
+          runCliCommand("gh", [
+            "api",
+            `repos/${repo}/pulls/${prNumber}/requested_reviewers`,
+            "--method",
+            "POST",
+            "-f",
+            "reviewers[]=copilot",
+          ]);
+        }
+        return { exitCode: 0, output: buildResult({ triggered: true, reviewer: "copilot" }) };
+      }
+      case "gemini": {
+        postIssueComment(repo, prNumber, triggerMethod);
+        return { exitCode: 0, output: buildResult({ triggered: true, reviewer: "gemini" }) };
+      }
+      case "none":
+        return { exitCode: 0, output: buildResult({ triggered: false, reviewer: "none" }) };
+      default:
+        return {
+          exitCode: 1,
+          output: buildResult({
+            triggered: false,
+            reviewer,
+            error: `unknown reviewer type: ${reviewer}`,
+          }),
+        };
+    }
+  } catch (error) {
+    return {
+      exitCode: 1,
+      output: buildResult({
+        triggered: false,
+        reviewer,
+        error: error instanceof Error ? error.message : String(error),
+      }),
+    };
+  }
+}
+
+function main(): void {
+  const [repo, prNumberArg, reviewer, triggerMethod = ""] = process.argv.slice(2);
+  const prNumber = Number.parseInt(prNumberArg ?? "", 10);
+
+  if (!repo || !Number.isInteger(prNumber) || !reviewer) {
+    console.log(buildResult({
+      triggered: false,
+      reviewer: reviewer ?? "unknown",
+      error: "Usage: trigger-review.ts <owner/repo> <pr_number> <reviewer_type> <trigger_method>",
+    }));
+    process.exit(1);
+  }
+
+  const result = triggerReview(repo, prNumber, reviewer, triggerMethod);
+  console.log(result.output);
+  process.exit(result.exitCode);
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  main();
+}