@mrclrchtr/supi-review 1.3.1 → 1.5.0

package/src/model.ts

@@ -0,0 +1,100 @@
+import type { Model } from "@earendil-works/pi-ai";
+import { type ExtensionContext, SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { ReviewModelSelection } from "./types.ts";
+
+/** Build the canonical `provider/modelId` string used throughout the review flow. */
+export function toCanonicalModelId(
+  model: Pick<NonNullable<ExtensionContext["model"]>, "provider" | "id">,
+): string {
+  return `${model.provider}/${model.id}`;
+}
+
+/**
+ * List review models using Pi's scoped model configuration only.
+ *
+ * If no scoped model patterns are configured, the review picker is intentionally empty.
+ */
+export function getSelectableReviewModels(
+  ctx: Pick<ExtensionContext, "cwd" | "modelRegistry" | "model">,
+  enabledModelPatterns = SettingsManager.create(ctx.cwd).getEnabledModels(),
+): ReviewModelSelection[] {
+  if (!enabledModelPatterns || enabledModelPatterns.length === 0) {
+    return [];
+  }
+
+  const byCanonicalId = new Map<string, ReviewModelSelection>();
+  const availableModels = filterByEnabledModels(
+    enabledModelPatterns,
+    ctx.modelRegistry.getAvailable(),
+  );
+
+  const addModel = (
+    // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+    model: Model<any>,
+    isCurrent: boolean,
+  ) => {
+    const canonicalId = toCanonicalModelId(model);
+    const existing = byCanonicalId.get(canonicalId);
+    if (existing) {
+      if (isCurrent) existing.isCurrent = true;
+      return;
+    }
+
+    byCanonicalId.set(canonicalId, {
+      canonicalId,
+      provider: model.provider,
+      id: model.id,
+      model,
+      label: model.name ?? canonicalId,
+      description: canonicalId,
+      isCurrent,
+    });
+  };
+
+  if (ctx.model && matchModelPatterns(ctx.model, enabledModelPatterns)) {
+    addModel(ctx.model, true);
+  }
+
+  for (const model of availableModels) {
+    addModel(
+      model,
+      ctx.model ? toCanonicalModelId(model) === toCanonicalModelId(ctx.model) : false,
+    );
+  }
+
+  return Array.from(byCanonicalId.values()).sort((a, b) => {
+    if (a.isCurrent !== b.isCurrent) return a.isCurrent ? -1 : 1;
+    return a.canonicalId.localeCompare(b.canonicalId);
+  });
+}
+
+function filterByEnabledModels<T extends { provider: string; id: string }>(
+  patterns: string[],
+  models: T[],
+): T[] {
+  return models.filter((model) => matchModelPatterns(model, patterns));
+}
+
+function matchModelPatterns(model: { provider: string; id: string }, patterns: string[]): boolean {
+  return patterns.some((pattern) => matchModelPattern(model, pattern));
+}
+
+function matchModelPattern(model: { provider: string; id: string }, pattern: string): boolean {
+  const canonicalId = `${model.provider}/${model.id}`;
+  if (pattern.includes("/")) {
+    return simpleGlobMatch(canonicalId, pattern);
+  }
+  return simpleGlobMatch(model.id, pattern) || simpleGlobMatch(canonicalId, pattern);
+}
+
+function simpleGlobMatch(text: string, pattern: string): boolean {
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    return text.toLowerCase() === pattern.toLowerCase();
+  }
+
+  const regex = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${regex}$`, "i").test(text);
+}

package/src/review.ts

@@ -1,168 +1,164 @@
-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";
+import { buildSessionContext, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { resolveBranchSnapshot, resolveCommitSnapshot, resolveWorkingTreeSnapshot } from "./git.ts";
+import { collectHistoryEvidence } from "./history/collect.ts";
+import { synthesizeReviewBrief } from "./history/synthesize.ts";
+import { buildReviewPacket } from "./target/packet.ts";
+import { runReviewer } from "./tool/review-runner.ts";
+import type { BriefSynthesisRunResult } from "./tool/runner-types.ts";
+import type { ReviewPlan, ReviewResult, ReviewSnapshot, ReviewTargetSpec } from "./types.ts";
+import { collectReviewNote, previewReviewPlan, selectModel, selectTarget } from "./ui/flow.ts";
+import { formatReviewContent } from "./ui/format-content.ts";
+import { ReviewProgressWidget } from "./ui/progress-widget.ts";
+import { registerReviewRenderer } from "./ui/renderer.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",
+    description: "Run a structured code review informed by the current session history",
     handler: async (_args, ctx) => {
-      const settings = loadReviewSettings(ctx.cwd);
-      await handleInteractive(settings.maxDiffBytes, settings.autoFix, ctx, pi);
+      await handleInteractive(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;
+async function handleInteractive(ctx: CommandContext, pi: ExtensionAPI): Promise<void> {
+  if (!ctx.hasUI) {
+    return;
+  }
 
-  const target = await resolvePresetTarget(preset, ctx);
+  const target = await selectTarget(ctx);
   if (!target) return;
 
-  const result = await runReviewWithLoader(target, maxDiffBytes, ctx, pi);
-  injectReviewMessage(pi, result, autoFix);
+  const model = await selectModel(ctx);
+  if (!model) return;
+
+  const note = await collectReviewNote(ctx);
+  if (note === undefined) return;
+  const normalizedNote = note.trim() || undefined;
+
+  const snapshot = await resolveReviewSnapshot(target, ctx);
+  if (!snapshot) return;
+
+  const sessionContext = buildSessionContext(
+    ctx.sessionManager.getEntries(),
+    ctx.sessionManager.getLeafId(),
+  );
+  const evidence = collectHistoryEvidence(sessionContext.messages, snapshot, normalizedNote);
+  const synthesis = await runBriefWithLoader({
+    snapshot,
+    modelId: model.canonicalId,
+    ctx,
+    pi,
+    run: (signal, onProgress) =>
+      synthesizeReviewBrief({
+        model,
+        modelRegistry: ctx.modelRegistry,
+        cwd: ctx.cwd,
+        snapshot,
+        evidence,
+        note: normalizedNote,
+        signal,
+        onProgress,
+      }),
+  });
+
+  if (synthesis.kind !== "success") {
+    notifySynthesisFailure(synthesis, ctx);
+    return;
+  }
+
+  const brief = {
+    ...synthesis.brief,
+    note: normalizedNote,
+    evidenceCount: evidence.length,
+  };
+
+  const packet = buildReviewPacket(snapshot, brief, model);
+  const plan: ReviewPlan = { model, snapshot, brief, packet };
+
+  const approved = await previewReviewPlan(ctx, plan);
+  if (!approved) return;
+
+  const result = await runReviewWithLoader(plan, ctx, pi);
+  injectReviewMessage(pi, result);
 }
 
-async function resolvePresetTarget(
-  preset: import("./ui.ts").Preset,
+async function resolveReviewSnapshot(
+  target: ReviewTargetSpec,
   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 };
-    }
+): Promise<ReviewSnapshot | undefined> {
+  const snapshot =
+    target.kind === "working-tree"
+      ? await resolveWorkingTreeSnapshot(ctx.cwd)
+      : target.kind === "branch"
+        ? await resolveBranchSnapshot(ctx.cwd, target.base)
+        : await resolveCommitSnapshot(ctx.cwd, target.sha);
+
+  if (snapshot) {
+    return snapshot;
   }
-}
 
-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 };
+  switch (target.kind) {
+    case "working-tree":
+      ctx.ui.notify("No working tree changes found", "warning");
+      break;
+    case "branch":
+      ctx.ui.notify(`No reviewable changes found against ${target.base}`, "warning");
+      break;
+    case "commit":
+      ctx.ui.notify(`Unable to resolve commit ${target.sha}`, "error");
+      break;
   }
-  return runReview({ ...options, target: resolved.target });
+
+  return undefined;
+}
+
+async function runBriefWithLoader(options: {
+  snapshot: ReviewSnapshot;
+  modelId: string;
+  ctx: CommandContext;
+  pi: ExtensionAPI;
+  run: (
+    signal: AbortSignal,
+    onProgress: (progress: Parameters<ReviewProgressWidget["updateProgress"]>[0]) => void,
+  ) => Promise<BriefSynthesisRunResult>;
+}): Promise<BriefSynthesisRunResult> {
+  const { snapshot, modelId, ctx, pi, run } = options;
+  return ctx.ui.custom<BriefSynthesisRunResult>((tui, theme, _kb, done) => {
+    const widget = new ReviewProgressWidget(tui, theme, "Synthesizing review brief…");
+    let finished = false;
+
+    const finish = (result: BriefSynthesisRunResult) => {
+      if (finished) return;
+      finished = true;
+      pi.events.emit("supi:working:end", { source: "supi-review" });
+      widget.dispose();
+      done(result);
+    };
+
+    widget.onAbort = () => {
+      // The widget aborts its signal; the runner resolves with `canceled`.
+    };
+
+    pi.events.emit("supi:working:start", { source: "supi-review" });
+    run(widget.signal, (progress) => widget.updateProgress(progress))
+      .then((result) => finish(result))
+      .catch((error) => {
+        finish({
+          kind: "failed",
+          reason: `Brief synthesis failed for ${snapshot.title} on ${modelId}: ${error instanceof Error ? error.message : String(error)}`,
+        });
+      });
+
+    return widget;
+  });
 }
 
 async function runReviewWithLoader(
-  target: ReviewTarget,
-  maxDiffBytes: number,
+  plan: ReviewPlan,
   ctx: CommandContext,
   pi: ExtensionAPI,
 ): Promise<ReviewResult> {
@@ -174,30 +170,33 @@ async function runReviewWithLoader(
       if (finished) return;
       finished = true;
       pi.events.emit("supi:working:end", { source: "supi-review" });
+      widget.dispose();
       done(result);
     };
 
-    widget.onAbort = () => finish({ kind: "canceled", target });
+    widget.onAbort = () => {
+      // The widget aborts its signal; the runner resolves with `canceled`.
+    };
 
     pi.events.emit("supi:working:start", { source: "supi-review" });
-
-    executeReview({
-      target,
-      maxDiffBytes,
-      ctx,
+    runReviewer({
+      prompt: plan.packet.prompt,
+      model: plan.model,
+      modelRegistry: ctx.modelRegistry,
+      cwd: ctx.cwd,
       signal: widget.signal,
+      snapshot: plan.snapshot,
+      brief: plan.brief,
       onProgress: (progress) => widget.updateProgress(progress),
     })
-      .then((result) => {
-        if (widget.signal.aborted) return;
-        finish(result);
-      })
-      .catch((err) => {
-        if (widget.signal.aborted) return;
+      .then((result) => finish(result))
+      .catch((error) => {
         finish({
           kind: "failed",
-          reason: err instanceof Error ? err.message : String(err),
-          target,
+          reason: error instanceof Error ? error.message : String(error),
+          snapshot: plan.snapshot,
+          brief: plan.brief,
+          modelId: plan.model.canonicalId,
         });
       });
 
@@ -205,139 +204,27 @@ async function runReviewWithLoader(
   });
 }
 
-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 };
+function notifySynthesisFailure(
+  result: Exclude<BriefSynthesisRunResult, { kind: "success" }>,
+  ctx: CommandContext,
+): void {
+  switch (result.kind) {
+    case "failed":
+      ctx.ui.notify(result.reason, "error");
+      break;
+    case "timeout":
+      ctx.ui.notify(
+        `Brief synthesis timed out after ${(result.timeoutMs / 1000).toFixed(0)}s`,
+        "warning",
+      );
+      break;
+    case "canceled":
+      ctx.ui.notify("Review canceled", "warning");
+      break;
   }
-
-  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 {
+function injectReviewMessage(pi: ExtensionAPI, result: ReviewResult): void {
   pi.sendMessage({
     customType: "supi-review",
     content: formatReviewContent(result),
@@ -345,7 +232,48 @@ function injectReviewMessage(pi: ExtensionAPI, result: ReviewResult, autoFix: bo
     details: { result },
   });
 
-  if (autoFix && result.kind === "success" && result.output.findings.length > 0) {
-    pi.sendUserMessage("Fix all findings from the review above.");
+  maybeQueueReviewFollowUp(pi, result);
+}
+
+function maybeQueueReviewFollowUp(pi: ExtensionAPI, result: ReviewResult): void {
+  if (result.kind !== "success" || result.output.findings.length === 0) {
+    return;
   }
+
+  pi.sendMessage(
+    {
+      customType: "supi-review-followup",
+      content: buildReviewFollowUpInstruction(result),
+      display: false,
+      details: {
+        findingCount: result.output.findings.length,
+        findings: result.output.findings.map((finding, index) => ({
+          number: index + 1,
+          title: finding.title,
+        })),
+      },
+    },
+    { triggerTurn: true },
+  );
+}
+
+function buildReviewFollowUpInstruction(
+  result: Extract<ReviewResult, { kind: "success" }>,
+): string {
+  const findings = result.output.findings.map(
+    (finding, index) => `- #${index + 1}: ${finding.title}`,
+  );
+
+  return [
+    "A code review just completed and the result is available in the preceding `supi-review` message.",
+    "Do not start fixing code immediately.",
+    "Your next task is to ask the user what to do with the review findings.",
+    "If the `ask_user` tool is available, use it for this decision.",
+    "Offer exactly these options: Done, Fix all, Fix selected, Verify findings.",
+    "If the user chooses Fix selected, ask a follow-up question listing the findings by number/title.",
+    "If the user chooses Verify findings, verify the findings first and then ask again whether to Fix all or Fix selected.",
+    "",
+    "Current findings:",
+    ...findings,
+  ].join("\n");
 }