@mrclrchtr/supi-review 2.7.0 → 3.0.0

package/src/history/collect.ts

@@ -1,135 +1,58 @@
 import type { SessionContext } from "@earendil-works/pi-coding-agent";
-import { extractAssistantText } from "../tool/runner-helpers.ts";
+import { extractVisibleText } from "../tool/runner-helpers.ts";
 
-type ResolvedSessionMessage = SessionContext["messages"][number];
+const MAX_PLANNER_CONTEXT_CHARS = 8_000;
+type Message = SessionContext["messages"][number];
 
-const DEFAULT_MAX_CHARS = 8_000;
-
-export interface SerializeSessionContextOptions {
-  maxChars?: number;
+interface PlannerRow {
+  kind: "summary" | "visible";
+  text: string;
 }
 
-/**
- * Serialize the resolved LLM-visible session context into a compaction-style
- * readable transcript for the brief synthesizer.
- *
- * This mirrors the overall approach Pi uses for compaction:
- * - messages are labeled by role and rendered in chronological order
- * - compaction and branch summaries appear with their own labels
- * - the output is bounded so the synthesizer stays predictable on long sessions
- * - no heuristic ranking or scoring is applied
- */
-export function serializeSessionContext(
-  messages: ResolvedSessionMessage[],
-  options?: SerializeSessionContextOptions,
-): string {
-  const maxChars = options?.maxChars ?? DEFAULT_MAX_CHARS;
-  if (messages.length === 0) return "";
-
-  const entries = messages
-    .map((message) => serializeEntry(message))
-    .filter(
-      (entry): entry is { label: string; text: string; isSummary: boolean } => entry !== undefined,
-    );
-
-  if (entries.length === 0) return "";
-
-  // Separate summary entries (compaction/branch summaries) from regular entries
-  const summaryEntries = entries.filter((e) => e.isSummary);
-  const regularEntries = entries.filter((e) => !e.isSummary);
-
-  // Estimate the total size if we keep everything
-  const allLines = entries.map(formatEntry);
-  const totalSize = measureLines(allLines);
-
-  if (totalSize <= maxChars) {
-    return allLines.join("\n");
+function toPlannerRow(message: Message): PlannerRow | undefined {
+  if (message.role === "compactionSummary") {
+    return { kind: "summary", text: `[Summary]\n${message.summary}` };
   }
-
-  // Build the output: always include summaries, then as many recent regular entries as fit
-  const summaryLines = summaryEntries.map(formatEntry);
-
-  // Walk regular entries from newest to oldest, keeping as many as fit
-  const keptRegular: typeof regularEntries = [];
-  let size = measureLines(summaryLines);
-
-  for (let i = regularEntries.length - 1; i >= 0; i--) {
-    const line = formatEntry(regularEntries[i]);
-    const lineLen = line.length + 1; // +1 for newline
-    if (keptRegular.length > 0 && size + lineLen > maxChars) {
-      break;
-    }
-    keptRegular.unshift(regularEntries[i]);
-    size += lineLen;
-  }
-
-  // Build final output: summaries first, then kept recent entries
-  const keptLines = [...summaryLines, ...keptRegular.map(formatEntry)];
-
-  // If still nothing fits with summaries alone, truncate the summaries
-  if (keptLines.length > 0) {
-    const output = keptLines.join("\n");
-    if (output.length <= maxChars) return output;
+  if (message.role === "branchSummary") {
+    return { kind: "summary", text: `[Branch summary]\n${message.summary}` };
   }
-
-  // Last resort: truncate the full output
-  return keepFirstLines(keptLines, maxChars);
-}
-
-function formatEntry(entry: { label: string; text: string }): string {
-  return `[${entry.label}]\n${entry.text}`;
+  if (message.role !== "user" && message.role !== "assistant") return undefined;
+  const text = extractVisibleText(message.content)?.trim();
+  if (!text) return undefined;
+  const label = message.role === "user" ? "User" : "Assistant";
+  return { kind: "visible", text: `[${label}]\n${text}` };
 }
 
-function measureLines(lines: string[]): number {
-  return lines.reduce((acc, line) => acc + line.length + 1, 0); // +1 for newline
-}
-
-function keepFirstLines(lines: string[], maxChars: number): string {
-  const kept: string[] = [];
+function takeRecentRows(rows: string[], maxChars: number): string {
+  const recent: string[] = [];
   let size = 0;
-  for (const line of lines) {
-    const lineLen = line.length + 1;
-    if (size + lineLen > maxChars) break;
-    kept.push(line);
-    size += lineLen;
-  }
-  return kept.join("\n");
-}
-
-function serializeEntry(
-  message: ResolvedSessionMessage,
-): { label: string; text: string; isSummary: boolean } | undefined {
-  switch (message.role) {
-    case "user":
-    case "assistant": {
-      const text = normalizeText(extractAssistantText(message.content) ?? "");
-      if (!text) return undefined;
-      return {
-        label: message.role === "user" ? "User" : "Assistant",
-        text,
-        isSummary: false,
-      };
-    }
-    case "custom": {
-      const text = normalizeText(extractAssistantText(message.content) ?? "");
-      if (!text) return undefined;
-      return { label: "Custom", text, isSummary: false };
-    }
-    case "compactionSummary": {
-      const text = normalizeText(message.summary);
-      if (!text) return undefined;
-      return { label: "Compaction summary", text, isSummary: true };
-    }
-    case "branchSummary": {
-      const text = normalizeText(message.summary);
-      if (!text) return undefined;
-      return { label: "Branch summary", text, isSummary: true };
+  for (let index = rows.length - 1; index >= 0; index--) {
+    const row = rows[index];
+    const separator = recent.length > 0 ? 1 : 0;
+    const remaining = maxChars - size - separator;
+    if (row.length > remaining) {
+      if (recent.length === 0 && remaining > 0) recent.unshift(row.slice(0, remaining));
+      break;
     }
-    default:
-      return undefined;
+    recent.unshift(row);
+    size += row.length + separator;
   }
+  return recent.join("\n");
 }
 
-function normalizeText(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
+/** Build a small planning-only projection of summaries and recent visible conversation. */
+export function collectPlannerContext(messages: Message[]): string {
+  const rows = messages.flatMap((message) => {
+    const row = toPlannerRow(message);
+    return row ? [row] : [];
+  });
+  const summaries = rows
+    .filter((row) => row.kind === "summary")
+    .map((row) => row.text)
+    .join("\n")
+    .slice(0, MAX_PLANNER_CONTEXT_CHARS);
+  const visible = rows.filter((row) => row.kind === "visible").map((row) => row.text);
+  const separator = summaries && visible.length > 0 ? 1 : 0;
+  const recent = takeRecentRows(visible, MAX_PLANNER_CONTEXT_CHARS - summaries.length - separator);
+  return [summaries, recent].filter(Boolean).join("\n");
 }

package/src/model.ts

@@ -2,6 +2,9 @@ import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { getSelectableModels } from "@mrclrchtr/supi-core/model-selection";
 import type { ReviewModelSelection } from "./types.ts";
 
+/** Sentinel that resolves to the model active when an agent review operation starts. */
+export const CURRENT_SESSION_REVIEW_MODEL = "current";
+
 /** Build the canonical `provider/modelId` string used throughout the review flow. */
 export { toCanonicalModelId } from "@mrclrchtr/supi-core/model-selection";
 
@@ -12,6 +15,7 @@ export { toCanonicalModelId } from "@mrclrchtr/supi-core/model-selection";
  */
 export function getSelectableReviewModels(
   ctx: Pick<ExtensionContext, "cwd" | "modelRegistry" | "model">,
+  /** Optional override for Pi's scoped model patterns; omit to use configured defaults. */
   enabledModelPatterns?: string[],
 ): ReviewModelSelection[] {
   return getSelectableModels(ctx, enabledModelPatterns) as ReviewModelSelection[];
@@ -35,3 +39,34 @@ export function getCurrentReviewModel(
     isCurrent: true,
   };
 }
+
+/**
+ * Resolve the configured model for an agent-driven review.
+ *
+ * `current` preserves the historical behavior. Explicit canonical model ids
+ * must be both available and present in Pi's current scoped model set.
+ */
+export function resolveAgentReviewModel(
+  ctx: Pick<ExtensionContext, "cwd" | "modelRegistry" | "model">,
+  configuredModelId: string,
+  /** Optional override for Pi's scoped model patterns; omit to use configured defaults. */
+  enabledModelPatterns?: string[],
+): ReviewModelSelection | undefined {
+  const modelId = configuredModelId.trim();
+  if (modelId === CURRENT_SESSION_REVIEW_MODEL) {
+    return getCurrentReviewModel(ctx);
+  }
+
+  const selection = getSelectableReviewModels(
+    { cwd: ctx.cwd, modelRegistry: ctx.modelRegistry, model: undefined },
+    enabledModelPatterns,
+  ).find((candidate) => candidate.canonicalId === modelId);
+  if (!selection) return undefined;
+
+  return {
+    ...selection,
+    isCurrent: ctx.model
+      ? `${ctx.model.provider}/${ctx.model.id}` === selection.canonicalId
+      : false,
+  };
+}

package/src/review-path.ts

@@ -0,0 +1,85 @@
+import { lstat, readFile, readlink, realpath } from "node:fs/promises";
+import { dirname, posix, relative, resolve, sep, win32 } from "node:path";
+
+/** Verified repository-relative review path that cannot lexically escape the worktree. */
+export interface SafeReviewPath {
+  absolute: string;
+  path: string;
+}
+
+/** Normalize a portable repository-relative path without touching the filesystem. */
+export function normalizeRepositoryRelativePath(path: string): string {
+  if (!path || path.includes("\0") || posix.isAbsolute(path) || win32.isAbsolute(path)) {
+    throw new Error(`Review path must stay inside the repository: ${path}`);
+  }
+  const normalized = posix.normalize(path.replaceAll("\\", "/"));
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
+    throw new Error(`Review path must stay inside the repository: ${path}`);
+  }
+  return normalized;
+}
+
+/** Resolve a repository-relative tool path without allowing lexical escape. */
+export function resolveReviewPath(cwd: string, path: string): SafeReviewPath {
+  const normalizedInput = normalizeRepositoryRelativePath(path);
+  const absolute = resolve(cwd, normalizedInput);
+  const normalized = relative(resolve(cwd), absolute);
+  if (!normalized || normalized === ".." || normalized.startsWith(`..${sep}`)) {
+    throw new Error(`Review path must stay inside the repository: ${path}`);
+  }
+  return { absolute, path: normalized.split(sep).join("/") };
+}
+
+function isMissingPath(error: unknown): boolean {
+  return (
+    !!error &&
+    typeof error === "object" &&
+    "code" in error &&
+    ((error as { code?: unknown }).code === "ENOENT" ||
+      (error as { code?: unknown }).code === "ENOTDIR")
+  );
+}
+
+function assertInsideRepository(repository: string, candidate: string, originalPath: string): void {
+  const rel = relative(repository, candidate);
+  if (rel === ".." || rel.startsWith(`..${sep}`)) {
+    throw new Error(`Review path must stay inside the repository: ${originalPath}`);
+  }
+}
+
+/** Read a working-tree file without following an intermediate symlink outside the repository. */
+export async function readWorkingTreeFile(cwd: string, path: string): Promise<string | undefined> {
+  const safe = resolveReviewPath(cwd, path);
+  try {
+    const [repository, parent, stat] = await Promise.all([
+      realpath(cwd),
+      realpath(dirname(safe.absolute)),
+      lstat(safe.absolute),
+    ]);
+    assertInsideRepository(repository, parent, path);
+    if (stat.isSymbolicLink()) return await readlink(safe.absolute);
+    if (!stat.isFile()) return undefined;
+    const resolvedFile = await realpath(safe.absolute);
+    assertInsideRepository(repository, resolvedFile, path);
+    return await readFile(safe.absolute, "utf8");
+  } catch (error) {
+    if (isMissingPath(error)) return undefined;
+    throw error;
+  }
+}
+
+/** Remove deleted paths from a Git-produced repository-relative path list. */
+export async function filterExistingReviewPaths(cwd: string, paths: string[]): Promise<string[]> {
+  const existing = await Promise.all(
+    paths.map(async (path) => {
+      try {
+        await lstat(resolveReviewPath(cwd, path).absolute);
+        return path;
+      } catch (error) {
+        if (isMissingPath(error)) return undefined;
+        throw error;
+      }
+    }),
+  );
+  return existing.filter((path): path is string => path !== undefined);
+}

package/src/review-result.ts

@@ -1,98 +1,49 @@
-import type {
-  NormalizedReviewOutput,
-  RawReviewResult,
-  ReviewItem,
-  ReviewItemCategory,
-  ReviewItemEffort,
-  ReviewItemImpact,
-  ReviewItemRecommendedAction,
-  ReviewOutputEvent,
-  ReviewResult,
-  ReviewSummary,
-} from "./types.ts";
+import { normalizeRepositoryRelativePath } from "./review-path.ts";
+import type { NormalizedReviewSubmission, ReviewSubmission } from "./types.ts";
 
-const actionRank: Record<ReviewItemRecommendedAction, number> = {
-  "must-fix": 0,
-  "should-fix": 1,
-  consider: 2,
-};
-
-const impactRank: Record<ReviewItemImpact, number> = {
-  high: 0,
-  medium: 1,
-  low: 2,
-};
-
-const effortRank: Record<ReviewItemEffort, number> = {
-  low: 0,
-  medium: 1,
-  high: 2,
-};
-
-/** Normalize raw reviewer output into the host-owned review contract. */
-export function normalizeReviewOutput(output: ReviewOutputEvent): NormalizedReviewOutput {
-  const items = [...(Array.isArray(output.items) ? output.items : [])].sort(compareReviewItems);
-  const summary = summarizeReviewItems(items);
-
-  return {
-    ...output,
-    items,
-    overall_correctness: summary.actions.mustFix > 0 ? "PATCH HAS ISSUES" : "PATCH IS CORRECT",
-    summary,
-  };
+function requireText(value: string, label: string): string {
+  const normalized = value.trim();
+  if (!normalized) throw new Error(`${label} must not be blank.`);
+  return normalized;
 }
 
-/** Normalize a raw reviewer result for rendering and follow-up handling. */
-export function normalizeReviewResult(result: RawReviewResult): ReviewResult {
-  if (result.kind !== "success") {
-    return result;
-  }
-
+/** Derive the machine verdict while preserving reviewer-authored finding order. */
+export function normalizeReviewSubmission(
+  submission: ReviewSubmission,
+): NormalizedReviewSubmission {
   return {
-    ...result,
-    output: normalizeReviewOutput(result.output),
-  };
-}
-
-function compareReviewItems(left: ReviewItem, right: ReviewItem): number {
-  const actionDiff = actionRank[left.recommended_action] - actionRank[right.recommended_action];
-  if (actionDiff !== 0) return actionDiff;
-
-  const impactDiff = impactRank[left.impact] - impactRank[right.impact];
-  if (impactDiff !== 0) return impactDiff;
-
-  const effortDiff = effortRank[left.effort] - effortRank[right.effort];
-  if (effortDiff !== 0) return effortDiff;
-
-  return right.confidence_score - left.confidence_score;
-}
-
-function summarizeReviewItems(items: ReviewItem[]): ReviewSummary {
-  const categories: Partial<Record<ReviewItemCategory, number>> = {};
-  const summary: ReviewSummary = {
-    actions: {
-      mustFix: 0,
-      shouldFix: 0,
-      consider: 0,
-    },
-    categories,
+    summary: requireText(submission.summary, "Review summary"),
+    findings: submission.findings.map((finding, index) => {
+      if (
+        !Number.isFinite(finding.confidence) ||
+        finding.confidence < 0 ||
+        finding.confidence > 1
+      ) {
+        throw new Error(`Finding ${index + 1} confidence must be between 0 and 1.`);
+      }
+      if (
+        finding.location &&
+        (!Number.isSafeInteger(finding.location.startLine) ||
+          !Number.isSafeInteger(finding.location.endLine) ||
+          finding.location.startLine < 1 ||
+          finding.location.endLine < finding.location.startLine)
+      ) {
+        throw new Error(`Finding ${index + 1} location must contain a valid ordered line range.`);
+      }
+      return {
+        ...finding,
+        title: requireText(finding.title, `Finding ${index + 1} title`),
+        description: requireText(finding.description, `Finding ${index + 1} description`),
+        location: finding.location
+          ? {
+              ...finding.location,
+              path: normalizeRepositoryRelativePath(
+                requireText(finding.location.path, `Finding ${index + 1} location path`),
+              ),
+            }
+          : undefined,
+      };
+    }),
+    verdict: submission.findings.some((finding) => finding.blocksAcceptance) ? "issues" : "pass",
   };
-
-  for (const item of items) {
-    switch (item.recommended_action) {
-      case "must-fix":
-        summary.actions.mustFix++;
-        break;
-      case "should-fix":
-        summary.actions.shouldFix++;
-        break;
-      case "consider":
-        summary.actions.consider++;
-        break;
-    }
-
-    categories[item.category] = (categories[item.category] ?? 0) + 1;
-  }
-
-  return summary;
 }