@mrclrchtr/supi-review 0.1.0

package/src/prompts.ts

@@ -0,0 +1,116 @@
+import type { ReviewTarget } from "./types.ts";
+
+export interface DiffStats {
+  files: number;
+  additions: number;
+  deletions: number;
+}
+
+export interface BuildPromptOptions {
+  truncated?: boolean;
+  truncatedBytes?: number;
+}
+
+export function buildReviewPrompt(
+  target: ReviewTarget,
+  diff: string = "",
+  options: BuildPromptOptions = {},
+): string {
+  const parts: string[] = [];
+
+  // Preamble with target metadata
+  parts.push(buildPreamble(target));
+  parts.push("");
+
+  if (options.truncated && options.truncatedBytes && options.truncatedBytes > 0) {
+    parts.push(
+      `> Note: the diff was truncated (${options.truncatedBytes} bytes omitted from the middle).`,
+    );
+    parts.push("");
+  }
+
+  // Diff or custom instructions
+  parts.push("## Changes to review");
+  parts.push("");
+
+  if (target.type === "custom") {
+    parts.push(target.instructions);
+  } else {
+    parts.push("```diff");
+    parts.push(diff);
+    parts.push("```");
+  }
+
+  return parts.join("\n");
+}
+
+export function parseDiffStats(text: string): DiffStats {
+  let files = 0;
+  let additions = 0;
+  let deletions = 0;
+  let inDiff = false;
+
+  for (const line of text.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      files++;
+      inDiff = true;
+    } else if (inDiff) {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        deletions++;
+      }
+    }
+  }
+
+  return { files, additions, deletions };
+}
+
+function buildPreamble(target: ReviewTarget): string {
+  const changedFilesLine =
+    target.changedFiles && target.changedFiles.length > 0
+      ? `**Changed files:** ${target.changedFiles.join(", ")}`
+      : undefined;
+
+  switch (target.type) {
+    case "base-branch": {
+      const stats = parseDiffStats(target.diff);
+      const lines = [
+        `# Review: changes on current branch vs ${target.branch}`,
+        `**Target:** base branch \`${target.branch}\``,
+        `**Files changed:** ${stats.files}`,
+        `**Changes:** +${stats.additions} / -${stats.deletions} lines`,
+      ];
+      if (changedFilesLine) lines.push(changedFilesLine);
+      return lines.join("\n");
+    }
+    case "uncommitted": {
+      const stats = parseDiffStats(target.diff);
+      const lines = [
+        "# Review: uncommitted changes",
+        "**Target:** working tree (staged + unstaged + untracked)",
+        `**Files changed:** ${stats.files}`,
+        `**Changes:** +${stats.additions} / -${stats.deletions} lines`,
+      ];
+      if (changedFilesLine) lines.push(changedFilesLine);
+      return lines.join("\n");
+    }
+    case "commit": {
+      const stats = parseDiffStats(target.show);
+      const lines = [
+        `# Review: commit ${target.sha}`,
+        `**Target:** commit \`${target.sha}\``,
+        `**Files changed:** ${stats.files}`,
+        `**Changes:** +${stats.additions} / -${stats.deletions} lines`,
+      ];
+      if (changedFilesLine) lines.push(changedFilesLine);
+      return lines.join("\n");
+    }
+    case "custom": {
+      const lines = ["# Review: custom instructions", "**Target:** user-provided review task"];
+      if (changedFilesLine) lines.push(changedFilesLine);
+      lines.push("No diff provided — follow the instructions below.");
+      return lines.join("\n");
+    }
+  }
+}

package/src/renderer.ts

@@ -0,0 +1,181 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Spacer, Text } from "@earendil-works/pi-tui";
+import type { ReviewFinding, ReviewResult } from "./types.ts";
+
+export function registerReviewRenderer(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer("supi-review", (message, { expanded }, theme) => {
+    const result = (message.details as { result?: ReviewResult } | undefined)?.result;
+    if (!result) {
+      return new Text(theme.fg("dim", "No review data"), 1, 0);
+    }
+
+    switch (result.kind) {
+      case "success":
+        return renderSuccess(result, theme, expanded);
+      case "failed":
+        return renderFailed(result, theme);
+      case "canceled":
+        return renderCanceled(result, theme);
+      case "timeout":
+        return renderTimeout(result, theme);
+      default:
+        return new Text(theme.fg("dim", "Unknown review state"), 1, 0);
+    }
+  });
+}
+
+function renderSuccess(
+  result: Extract<ReviewResult, { kind: "success" }>,
+  theme: Parameters<Parameters<ExtensionAPI["registerMessageRenderer"]>[1]>[2],
+  expanded: boolean,
+): Container {
+  const container = new Container();
+  const output = result.output;
+
+  container.addChild(new Text(theme.fg("accent", "◆ Code Review Results"), 1, 0));
+  container.addChild(new Spacer(1));
+
+  const normalizedVerdict = output.overall_correctness.toLowerCase();
+  const verdictColor = normalizedVerdict.includes("incorrect")
+    ? "warning"
+    : normalizedVerdict.includes("correct")
+      ? "success"
+      : "warning";
+  container.addChild(
+    new Text(
+      `${theme.fg(verdictColor, "●")} ${theme.fg(verdictColor, output.overall_correctness)}` +
+        theme.fg("dim", `  (confidence: ${(output.overall_confidence_score * 100).toFixed(0)}%)`),
+      1,
+      0,
+    ),
+  );
+
+  if (output.overall_explanation) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("dim", output.overall_explanation), 1, 0));
+  }
+
+  if (expanded) {
+    container.addChild(new Spacer(1));
+
+    if (output.findings.length === 0) {
+      container.addChild(new Text(theme.fg("success", "✓ No issues found"), 1, 0));
+    } else {
+      container.addChild(
+        new Text(theme.fg("accent", `Findings (${output.findings.length})`), 1, 0),
+      );
+      for (const finding of output.findings) {
+        container.addChild(renderFinding(finding, theme));
+      }
+    }
+  }
+
+  return container;
+}
+
+function renderFinding(
+  finding: ReviewFinding,
+  theme: Parameters<Parameters<ExtensionAPI["registerMessageRenderer"]>[1]>[2],
+): Container {
+  const container = new Container();
+  const priorityColor = priorityColorName(finding.priority);
+  const priorityLabel = priorityText(finding.priority);
+
+  const loc = finding.code_location;
+  const locText =
+    loc.absolute_file_path +
+    (loc.line_range.start === loc.line_range.end
+      ? `:${loc.line_range.start}`
+      : `:${loc.line_range.start}-${loc.line_range.end}`);
+
+  container.addChild(new Spacer(1));
+  container.addChild(
+    new Text(
+      `${theme.fg(priorityColor, "●")} ${theme.fg("text", finding.title)}  ${theme.fg("dim", priorityLabel)}`,
+      1,
+      0,
+    ),
+  );
+  container.addChild(new Text(theme.fg("dim", locText), 2, 0));
+
+  if (finding.body) {
+    const box = new Box(1, 0);
+    box.addChild(new Text(theme.fg("text", finding.body), 0, 0));
+    container.addChild(box);
+  }
+
+  return container;
+}
+
+function renderFailed(
+  result: Extract<ReviewResult, { kind: "failed" }>,
+  theme: Parameters<Parameters<ExtensionAPI["registerMessageRenderer"]>[1]>[2],
+): Container {
+  const container = new Container();
+  container.addChild(new Text(theme.fg("error", "◆ Review Failed"), 1, 0));
+  container.addChild(new Spacer(1));
+  container.addChild(new Text(theme.fg("error", result.reason), 1, 0));
+  return container;
+}
+
+function renderTimeout(
+  result: Extract<ReviewResult, { kind: "timeout" }>,
+  theme: Parameters<Parameters<ExtensionAPI["registerMessageRenderer"]>[1]>[2],
+): Container {
+  const container = new Container();
+  container.addChild(new Text(theme.fg("warning", "◆ Review Timed Out"), 1, 0));
+  container.addChild(new Spacer(1));
+  container.addChild(
+    new Text(
+      theme.fg("warning", `Reviewer exceeded the ${(result.timeoutMs / 1000).toFixed(0)}s timeout`),
+      1,
+      0,
+    ),
+  );
+  if (result.partialOutput) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("dim", "Partial output:"), 1, 0));
+    const excerpt = result.partialOutput.slice(0, 500);
+    container.addChild(new Text(theme.fg("dim", excerpt), 1, 0));
+  }
+  return container;
+}
+
+function renderCanceled(
+  _result: Extract<ReviewResult, { kind: "canceled" }>,
+  theme: Parameters<Parameters<ExtensionAPI["registerMessageRenderer"]>[1]>[2],
+): Container {
+  const container = new Container();
+  container.addChild(new Text(theme.fg("warning", "◆ Review Canceled"), 1, 0));
+  return container;
+}
+
+function priorityColorName(priority: number): "success" | "warning" | "error" {
+  switch (priority) {
+    case 0:
+      return "success";
+    case 1:
+      return "success";
+    case 2:
+      return "warning";
+    case 3:
+      return "error";
+    default:
+      return "success";
+  }
+}
+
+function priorityText(priority: number): string {
+  switch (priority) {
+    case 0:
+      return "info";
+    case 1:
+      return "minor";
+    case 2:
+      return "major";
+    case 3:
+      return "critical";
+    default:
+      return "info";
+  }
+}

package/src/review.ts

@@ -0,0 +1,351 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { formatReviewContent } from "./format-content.ts";
+import {
+  getCommitFileNames,
+  getCommitShow,
+  getDiff,
+  getDiffFileNames,
+  getMergeBase,
+  getUncommittedDiff,
+  getUncommittedFileNames,
+} from "./git.ts";
+import { ReviewProgressWidget } from "./progress-widget.ts";
+import { buildReviewPrompt } from "./prompts.ts";
+import { registerReviewRenderer } from "./renderer.ts";
+import { runReviewer } from "./runner.ts";
+import type { ReviewerInvocation } from "./runner-types.ts";
+import {
+  filterByEnabledModels,
+  loadReviewSettings,
+  readPiEnabledModels,
+  registerReviewSettings,
+  setReviewModelChoices,
+} from "./settings.ts";
+import { resolveGitTarget } from "./target-resolution.ts";
+import type { ReviewResult, ReviewTarget } from "./types.ts";
+import { selectAutoFix, selectBranch, selectCommit, selectPreset } from "./ui.ts";
+
+type CommandContext = Parameters<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>[1];
+
+interface ReviewExecutionOptions {
+  target: ReviewTarget;
+  maxDiffBytes: number;
+  ctx: CommandContext;
+  signal?: AbortSignal;
+  onToolActivity?: ReviewerInvocation["onToolActivity"];
+  onProgress?: ReviewerInvocation["onProgress"];
+}
+
+export default function reviewExtension(pi: ExtensionAPI) {
+  registerReviewSettings();
+  registerReviewRenderer(pi);
+
+  const syncReviewModelChoices = (ctx: {
+    modelRegistry: {
+      getAvailable(): Array<{ provider: string; id: string }> | undefined;
+    };
+  }) => {
+    const allModels = ctx.modelRegistry.getAvailable();
+    if (!allModels) {
+      setReviewModelChoices([]);
+      return;
+    }
+
+    // Try to respect PI’s scoped models (enabledModels).
+    // Workaround for pi-mono#3535 — swap to ctx.scopedModels when exposed by PI.
+    const enabledPatterns = readPiEnabledModels();
+    const models = enabledPatterns ? filterByEnabledModels(enabledPatterns, allModels) : allModels;
+
+    setReviewModelChoices(toCanonicalModelIds(models));
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    syncReviewModelChoices(ctx);
+  });
+
+  pi.on("model_select", async (_event, ctx) => {
+    syncReviewModelChoices(ctx);
+  });
+
+  pi.registerCommand("supi-review", {
+    description: "Run a structured code review",
+    handler: async (_args, ctx) => {
+      const settings = loadReviewSettings(ctx.cwd);
+      await handleInteractive(settings.maxDiffBytes, settings.autoFix, ctx, pi);
+    },
+  });
+}
+
+async function handleInteractive(
+  maxDiffBytes: number,
+  autoFixDefault: boolean,
+  ctx: CommandContext,
+  pi: ExtensionAPI,
+): Promise<void> {
+  const preset = await selectPreset(ctx);
+  if (!preset) return;
+
+  const autoFix = await selectAutoFix(ctx, autoFixDefault);
+  if (autoFix === undefined) return;
+
+  const target = await resolvePresetTarget(preset, ctx);
+  if (!target) return;
+
+  const result = await runReviewWithLoader(target, maxDiffBytes, ctx, pi);
+  injectReviewMessage(pi, result, autoFix);
+}
+
+async function resolvePresetTarget(
+  preset: import("./ui.ts").Preset,
+  ctx: CommandContext,
+): Promise<ReviewTarget | undefined> {
+  switch (preset) {
+    case "base-branch": {
+      const branch = await selectBranch(ctx);
+      if (!branch) return undefined;
+      const baseSha = await getMergeBase(ctx.cwd, branch);
+      if (!baseSha) {
+        ctx.ui.notify(`No merge base found for ${branch}`, "error");
+        return undefined;
+      }
+      const [diff, changedFiles] = await Promise.all([
+        getDiff(ctx.cwd, baseSha),
+        getDiffFileNames(ctx.cwd, baseSha),
+      ]);
+      return { type: "base-branch", branch, diff, changedFiles };
+    }
+    case "uncommitted": {
+      const [diff, changedFiles] = await Promise.all([
+        getUncommittedDiff(ctx.cwd),
+        getUncommittedFileNames(ctx.cwd),
+      ]);
+      if (!diff) {
+        ctx.ui.notify("No uncommitted changes", "warning");
+        return undefined;
+      }
+      return { type: "uncommitted", diff, changedFiles };
+    }
+    case "commit": {
+      const sha = await selectCommit(ctx);
+      if (!sha) return undefined;
+      const [show, changedFiles] = await Promise.all([
+        getCommitShow(ctx.cwd, sha),
+        getCommitFileNames(ctx.cwd, sha),
+      ]);
+      return { type: "commit", sha, show, changedFiles };
+    }
+    case "custom": {
+      const instructions = await ctx.ui.editor(
+        "Review instructions",
+        "Focus on security, performance, and correctness…",
+      );
+      if (!instructions?.trim()) {
+        ctx.ui.notify("No instructions provided", "warning");
+        return undefined;
+      }
+      const changedFiles = await getUncommittedFileNames(ctx.cwd);
+      return { type: "custom", instructions: instructions.trim(), changedFiles };
+    }
+  }
+}
+
+async function executeReview(options: ReviewExecutionOptions): Promise<ReviewResult> {
+  const { target, ctx, signal } = options;
+  const resolved = await resolveGitTarget(target, ctx);
+  if (resolved.kind !== "success") return resolved;
+  if (signal?.aborted) {
+    return { kind: "canceled", target: resolved.target };
+  }
+  return runReview({ ...options, target: resolved.target });
+}
+
+async function runReviewWithLoader(
+  target: ReviewTarget,
+  maxDiffBytes: number,
+  ctx: CommandContext,
+  pi: ExtensionAPI,
+): Promise<ReviewResult> {
+  return ctx.ui.custom<ReviewResult>((tui, theme, _kb, done) => {
+    const widget = new ReviewProgressWidget(tui, theme, "Running code review…");
+    let finished = false;
+
+    const finish = (result: ReviewResult) => {
+      if (finished) return;
+      finished = true;
+      pi.events.emit("supi:working:end", { source: "supi-review" });
+      done(result);
+    };
+
+    widget.onAbort = () => finish({ kind: "canceled", target });
+
+    pi.events.emit("supi:working:start", { source: "supi-review" });
+
+    executeReview({
+      target,
+      maxDiffBytes,
+      ctx,
+      signal: widget.signal,
+      onProgress: (progress) => widget.updateProgress(progress),
+    })
+      .then((result) => {
+        if (widget.signal.aborted) return;
+        finish(result);
+      })
+      .catch((err) => {
+        if (widget.signal.aborted) return;
+        finish({
+          kind: "failed",
+          reason: err instanceof Error ? err.message : String(err),
+          target,
+        });
+      });
+
+    return widget;
+  });
+}
+
+function runReview(options: ReviewExecutionOptions): Promise<ReviewResult> {
+  const { target, maxDiffBytes, ctx, signal, onToolActivity, onProgress } = options;
+  const settings = loadReviewSettings(ctx.cwd);
+  // ctx.modelRegistry is available because CommandContext extends ExtensionContext
+  const model = resolveReviewerModel(settings, ctx.modelRegistry, ctx.model);
+  if (!model) {
+    return Promise.resolve({
+      kind: "failed",
+      reason:
+        "No review model configured. Set a review model in settings or load a model in the session.",
+      target,
+    });
+  }
+
+  let diffOrBody = "";
+  if (target.type === "base-branch" || target.type === "uncommitted") {
+    diffOrBody = target.diff;
+  } else if (target.type === "commit") {
+    diffOrBody = target.show;
+  }
+
+  const truncated =
+    target.type === "custom"
+      ? { text: "", wasTruncated: false, truncatedBytes: 0 }
+      : maybeTruncateDiff(diffOrBody, maxDiffBytes);
+  const prompt = buildReviewPrompt(
+    target,
+    truncated.text,
+    truncated.wasTruncated
+      ? { truncated: true, truncatedBytes: truncated.truncatedBytes }
+      : undefined,
+  );
+
+  const invocation: ReviewerInvocation = {
+    prompt,
+    model,
+    modelRegistry: ctx.modelRegistry,
+    cwd: ctx.cwd,
+    target,
+    signal,
+    onToolActivity,
+    onProgress,
+  };
+
+  return runReviewer(invocation);
+}
+
+function toCanonicalModelIds(
+  models: Array<{ provider: string; id: string }> | undefined,
+): string[] {
+  if (!models) return [];
+  return Array.from(new Set(models.map((model) => `${model.provider}/${model.id}`)));
+}
+
+function resolveReviewerModel(
+  settings: ReturnType<typeof loadReviewSettings>,
+  modelRegistry: ModelRegistry,
+  // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+  sessionModel: Model<any> | undefined,
+  // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+): Model<any> | undefined {
+  const modelString = settings.reviewModel || resolveSessionModelId(sessionModel);
+  if (!modelString) return undefined;
+
+  // Parse "provider/model-id" format
+  const slashIndex = modelString.indexOf("/");
+  if (slashIndex === -1) {
+    throw new Error(`Invalid review model format: "${modelString}". Expected "provider/model-id".`);
+  }
+
+  const provider = modelString.slice(0, slashIndex);
+  const modelId = modelString.slice(slashIndex + 1);
+  const found = modelRegistry.find(provider, modelId);
+  if (!found) {
+    throw new Error(`Review model "${modelString}" not found. Check your review model setting.`);
+  }
+  return found;
+}
+
+function resolveSessionModelId(
+  model: Pick<NonNullable<CommandContext["model"]>, "id" | "provider"> | undefined,
+): string | undefined {
+  if (!model?.id) return undefined;
+  return model.provider ? `${model.provider}/${model.id}` : model.id;
+}
+
+function maybeTruncateDiff(
+  diff: string,
+  maxBytes: number,
+): { text: string; wasTruncated: boolean; truncatedBytes: number } {
+  const encoder = new TextEncoder();
+  const bytes = encoder.encode(diff);
+  if (bytes.length <= maxBytes) {
+    return { text: diff, wasTruncated: false, truncatedBytes: 0 };
+  }
+
+  const headBytes = Math.floor(maxBytes / 2);
+  const tailBytes = maxBytes - headBytes;
+
+  let headEnd = 0;
+  let headCount = 0;
+  for (let i = 0; i < diff.length; i++) {
+    const b = encoder.encode(diff[i] ?? "");
+    if (headCount + b.length > headBytes) break;
+    headCount += b.length;
+    headEnd = i + 1;
+  }
+
+  let tailStart = diff.length;
+  let tailCount = 0;
+  for (let i = diff.length - 1; i >= 0; i--) {
+    const b = encoder.encode(diff[i] ?? "");
+    if (tailCount + b.length > tailBytes) break;
+    tailCount += b.length;
+    tailStart = i;
+  }
+
+  if (tailStart <= headEnd) {
+    const truncated = new TextDecoder().decode(bytes.slice(0, maxBytes));
+    return { text: truncated, wasTruncated: true, truncatedBytes: bytes.length - maxBytes };
+  }
+
+  const head = diff.slice(0, headEnd);
+  const tail = diff.slice(tailStart);
+  const omitted = bytes.length - headCount - tailCount;
+  return {
+    text: `${head}\n[... truncated ${omitted} bytes ...]\n${tail}`,
+    wasTruncated: true,
+    truncatedBytes: omitted,
+  };
+}
+
+function injectReviewMessage(pi: ExtensionAPI, result: ReviewResult, autoFix: boolean): void {
+  pi.sendMessage({
+    customType: "supi-review",
+    content: formatReviewContent(result),
+    display: true,
+    details: { result },
+  });
+
+  if (autoFix && result.kind === "success" && result.output.findings.length > 0) {
+    pi.sendUserMessage("Fix all findings from the review above.");
+  }
+}

package/src/runner-types.ts

@@ -0,0 +1,32 @@
+import type { Model } from "@earendil-works/pi-ai";
+import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { ReviewTarget } from "./types.ts";
+
+/** Progress state exposed by the runner for widget integration. */
+export interface ReviewProgress {
+  /** Number of agentic turns completed. */
+  turns: number;
+  /** Number of tool executions started. */
+  toolUses: number;
+  /** Human-readable activity descriptions for active tools. */
+  activities: string[];
+  /** Token usage stats, if available. */
+  tokens?: { input: number; output: number; total: number };
+}
+
+export interface ReviewerInvocation {
+  prompt: string;
+  // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+  model: Model<any>;
+  /** Model registry from the parent session — passed to createAgentSession
+   *  so that provider registrations, auth, and streaming work correctly. */
+  modelRegistry?: ModelRegistry;
+  cwd: string;
+  signal?: AbortSignal;
+  target: ReviewTarget;
+  timeoutMs?: number;
+  /** Callback for tool activity events (starts/ends) for widget integration. */
+  onToolActivity?: (event: { toolName: string; phase: "start" | "end" }) => void;
+  /** Callback for progress state updates (turn count, tool uses, tokens). */
+  onProgress?: (progress: ReviewProgress) => void;
+}