@mrclrchtr/supi-review 0.1.0

package/src/runner.ts

@@ -0,0 +1,424 @@
+// biome-ignore lint/nursery/noExcessiveLinesPerFile: pre-existing, needs refactoring
+import { clampThinkingLevel, type Model } from "@earendil-works/pi-ai";
+import {
+  type AgentSession,
+  type AgentSessionEvent,
+  createAgentSession,
+  DefaultResourceLoader,
+  defineTool,
+  type ModelRegistry,
+  SessionManager,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { ReviewerInvocation, ReviewProgress } from "./runner-types.ts";
+import type { ReviewOutputEvent, ReviewResult, ReviewTarget } from "./types.ts";
+
+export type { ReviewerInvocation } from "./runner-types.ts";
+
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1_000;
+const GRACE_TURNS = 3;
+const STEER_MESSAGE = "Time limit reached. Wrap up and submit your review now.";
+/** Maps tool names to human-readable activity descriptions. */
+function toolNameToActivity(name: string, phase: "start" | "end"): string {
+  if (phase === "end") return "";
+  const map: Record<string, string> = {
+    read: "reading",
+    grep: "searching",
+    find: "finding files",
+    ls: "listing files",
+    submit_review: "submitting review",
+  };
+  return map[name] ?? name;
+}
+function createSubmitReviewTool(resultHolder: {
+  value: ReviewOutputEvent | undefined;
+}): ReturnType<typeof defineTool> {
+  return defineTool({
+    name: "submit_review",
+    label: "Submit Review",
+    description: [
+      "Submit the final structured review result.",
+      "Call this tool when you have completed your review and are ready to submit the findings.",
+    ].join(" "),
+    parameters: Type.Object({
+      findings: Type.Array(
+        Type.Object({
+          title: Type.String(),
+          body: Type.String(),
+          confidence_score: Type.Number(),
+          priority: Type.Number(),
+          code_location: Type.Object({
+            absolute_file_path: Type.String(),
+            line_range: Type.Object({
+              start: Type.Number(),
+              end: Type.Number(),
+            }),
+          }),
+        }),
+      ),
+      overall_correctness: Type.String(),
+      overall_explanation: Type.String(),
+      overall_confidence_score: Type.Number(),
+    }),
+    execute: async (_toolCallId, args) => {
+      resultHolder.value = args as ReviewOutputEvent;
+      return {
+        content: [{ type: "text" as const, text: "Review submitted successfully." }],
+        details: args,
+        terminate: true,
+      };
+    },
+  });
+}
+export function buildReviewerSystemPrompt(): string {
+  return [
+    "You are a rigorous code reviewer. Review the provided code changes carefully and report any issues you find.",
+    "You have read-only tools only. Do NOT attempt to edit files or run commands that modify the working tree.",
+    "If the patch is fully correct, set overall_correctness to 'patch is correct' with high confidence.",
+    "",
+    "--- Review categories ---",
+    "Check each category that applies:",
+    "- Security: injection risks, auth bypasses, secrets exposure, data validation",
+    "- Performance: O(n²) algorithms, unnecessary allocations, N+1 queries, blocking operations",
+    "- Correctness: logic bugs, race conditions, type mismatches, off-by-one errors, missing null checks",
+    "- Maintainability: unclear naming, missing tests, dead code, duplication, overly complex logic",
+    "- API design: breaking changes, inconsistent patterns, missing validation, poor ergonomics",
+    "",
+    "--- Finding quality ---",
+    "Title: concise and specific (e.g. 'Missing null check in parseToken()', not 'Bug found')",
+    "Body: explain the problem, why it matters, and suggest a concrete fix",
+    "code_location: 1-based inclusive line range; verify against the diff before submitting",
+    "confidence_score: 0.0-1.0 based on how certain you are (obvious bug = 1.0, suspicion = 0.3)",
+    "priority: 0=info (notable observation), 1=minor (style/small issue), 2=major (bug/risk), 3=critical (security/data loss)",
+    "overall_correctness: 'patch is correct' | 'mostly correct' | 'patch is incorrect'",
+    "",
+    "--- Tool strategy ---",
+    "Use read to inspect full files when the diff lacks surrounding context.",
+    "Use grep to verify patterns across the codebase (e.g. consistent error handling, existing tests).",
+    "Use find to locate related files quickly.",
+    "If you need to understand the broader structure, use ls on relevant directories first.",
+    "",
+    "Do NOT output JSON directly — call submit_review with the structured result.",
+  ].join("\n");
+}
+async function createReviewerSession(
+  // biome-ignore lint/suspicious/noExplicitAny: Model<any> is pi's canonical type
+  model: Model<any>,
+  cwd: string,
+  submitReviewTool: ReturnType<typeof defineTool>,
+  modelRegistry?: ModelRegistry,
+): Promise<AgentSession> {
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir: process.env.PI_CODING_AGENT_DIR || "",
+    noExtensions: false,
+    noSkills: true,
+    noPromptTemplates: true,
+    noThemes: true,
+    noContextFiles: false,
+    appendSystemPrompt: [buildReviewerSystemPrompt()],
+  });
+  await resourceLoader.reload();
+  const { session } = await createAgentSession({
+    cwd,
+    model,
+    modelRegistry,
+    thinkingLevel: clampThinkingLevel(model, "xhigh"),
+    tools: ["read", "grep", "find", "ls", "submit_review"],
+    customTools: [submitReviewTool],
+    resourceLoader,
+    sessionManager: SessionManager.inMemory(cwd),
+  });
+  return session;
+}
+function extractLastAssistantText(session: AgentSession): string | undefined {
+  const messages = session.messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg?.role !== "assistant") continue;
+    const text = extractAssistantTextContent(msg);
+    if (text) return text;
+    const errorMsg = extractAssistantErrorMessage(msg);
+    if (errorMsg) return errorMsg;
+  }
+  return undefined;
+}
+/** Extract non-empty text content from an assistant message (or undefined). */
+function extractAssistantTextContent(msg: {
+  role: string;
+  content: string | Array<{ type: string; text?: string }>;
+}): string | undefined {
+  if (typeof msg.content === "string") return msg.content || undefined;
+  if (!Array.isArray(msg.content)) return undefined;
+  const texts = msg.content
+    .filter((c): c is { type: "text"; text: string } => c.type === "text")
+    .map((c) => c.text);
+  if (texts.length > 0 && texts.some((t) => t.length > 0)) return texts.join("\n");
+  return undefined;
+}
+/** Extract errorMessage or stopReason description from a failed assistant message. */
+function extractAssistantErrorMessage(msg: unknown): string | undefined {
+  const errMsg = (msg as Record<string, unknown>).errorMessage;
+  if (typeof errMsg === "string" && errMsg.length > 0) return errMsg;
+  const stopReason = (msg as Record<string, unknown>).stopReason;
+  if (stopReason === "error") return "Reviewer model returned an error";
+  if (stopReason === "aborted") return "Reviewer was aborted";
+  return undefined;
+}
+/** Format token count for display. */
+export function formatTokens(count: number): string {
+  if (count >= 1_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  if (count >= 1_000) return `${(count / 1_000).toFixed(1)}k`;
+  return String(count);
+}
+interface RunnerContext {
+  progress: ReviewProgress;
+  session: AgentSession;
+  target: ReviewTarget;
+  timeoutMs: number;
+  onToolActivity: ReviewerInvocation["onToolActivity"];
+  onProgress: ReviewerInvocation["onProgress"];
+  resolve: (result: ReviewResult) => void;
+  cleanup: (result: ReviewResult) => ReviewResult;
+  resultHolder: { value: ReviewOutputEvent | undefined };
+  signal?: AbortSignal;
+  /** Whether the review has already settled (resolved + disposed). */
+  state: { settled: boolean };
+  timeout: { steered: boolean; graceTurnsRemaining: number | undefined; aborting?: boolean };
+}
+function emitProgress(ctx: RunnerContext): void {
+  try {
+    const stats = ctx.session.getSessionStats();
+    ctx.progress.tokens = stats?.tokens
+      ? {
+          input: stats.tokens.input ?? 0,
+          output: stats.tokens.output ?? 0,
+          total: stats.tokens.total ?? 0,
+        }
+      : undefined;
+  } catch {
+    /* Session may not have stats yet */
+  }
+  ctx.onProgress?.({ ...ctx.progress, activities: [...ctx.progress.activities] });
+}
+function handleTurnEnd(ctx: RunnerContext): number | undefined {
+  ctx.progress.turns++;
+  ctx.progress.activities = [];
+  if (!ctx.state.settled && ctx.timeout.steered && ctx.timeout.graceTurnsRemaining !== undefined) {
+    ctx.timeout.graceTurnsRemaining--;
+    if (ctx.timeout.graceTurnsRemaining <= 0) {
+      ctx.timeout.aborting = true;
+      void ctx.session
+        .abort()
+        .catch(() => {})
+        .finally(() => {
+          const partialText = extractLastAssistantText(ctx.session);
+          ctx.resolve(
+            ctx.cleanup({
+              kind: "timeout",
+              target: ctx.target,
+              timeoutMs: ctx.timeoutMs,
+              partialOutput: partialText,
+            }),
+          );
+        });
+    }
+  }
+  emitProgress(ctx);
+  return ctx.timeout.graceTurnsRemaining;
+}
+function handleToolStart(
+  event: Extract<AgentSessionEvent, { type: "tool_execution_start" }>,
+  ctx: RunnerContext,
+): void {
+  ctx.progress.toolUses++;
+  const activity = toolNameToActivity(event.toolName, "start");
+  if (activity) ctx.progress.activities.push(activity);
+  ctx.onToolActivity?.({ toolName: event.toolName, phase: "start" });
+  ctx.onProgress?.({ ...ctx.progress, activities: [...ctx.progress.activities] });
+}
+function handleToolEnd(
+  event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>,
+  ctx: RunnerContext,
+): void {
+  const startActivity = toolNameToActivity(event.toolName, "start");
+  if (startActivity) {
+    const idx = ctx.progress.activities.indexOf(startActivity);
+    if (idx !== -1) ctx.progress.activities.splice(idx, 1);
+  }
+  ctx.onToolActivity?.({ toolName: event.toolName, phase: "end" });
+  ctx.onProgress?.({ ...ctx.progress, activities: [...ctx.progress.activities] });
+}
+function handleAgentEnd(ctx: RunnerContext): void {
+  if (ctx.state.settled || ctx.signal?.aborted || ctx.timeout.aborting) return;
+  if (ctx.resultHolder.value) {
+    ctx.resolve(
+      ctx.cleanup({ kind: "success", output: ctx.resultHolder.value, target: ctx.target }),
+    );
+  } else {
+    const lastText = extractLastAssistantText(ctx.session);
+    ctx.resolve(
+      ctx.cleanup({
+        kind: "failed",
+        reason: lastText
+          ? `Reviewer did not call submit_review. Assistant said: ${truncateText(lastText, 400)}`
+          : "Reviewer did not produce any output.",
+        target: ctx.target,
+      }),
+    );
+  }
+}
+function truncateText(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return `${text.slice(0, maxLen)}... (${text.length - maxLen} more chars)`;
+}
+function handleSessionEvent(event: AgentSessionEvent, ctx: RunnerContext): void {
+  switch (event.type) {
+    case "turn_end":
+      ctx.timeout.graceTurnsRemaining = handleTurnEnd(ctx);
+      break;
+    case "tool_execution_start":
+      handleToolStart(event, ctx);
+      break;
+    case "tool_execution_end":
+      handleToolEnd(event, ctx);
+      break;
+    case "agent_end":
+      handleAgentEnd(ctx);
+      break;
+    // Ignore other events (queue_update, compaction, auto_retry, etc.)
+    default:
+      break;
+  }
+}
+export async function runReviewer(inv: ReviewerInvocation): Promise<ReviewResult> {
+  const {
+    prompt,
+    model,
+    modelRegistry,
+    cwd,
+    signal,
+    target,
+    onToolActivity,
+    onProgress,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  } = inv;
+  if (signal?.aborted) {
+    return { kind: "canceled", target };
+  }
+  // Holder for the submit_review tool result
+  const resultHolder: { value: ReviewOutputEvent | undefined } = { value: undefined };
+  const submitReviewTool = createSubmitReviewTool(resultHolder);
+  let session: AgentSession;
+  try {
+    session = await createReviewerSession(model, cwd, submitReviewTool, modelRegistry);
+  } catch (err) {
+    const reason = `Failed to create reviewer session: ${err instanceof Error ? err.message : String(err)}`;
+    return { kind: "failed" as const, reason, target };
+  }
+  const progress: ReviewProgress = { turns: 0, toolUses: 0, activities: [], tokens: undefined };
+  const state = { settled: false };
+  let cancelTeardown: (() => void) | undefined;
+  const cleanup = (result: ReviewResult): ReviewResult => {
+    if (state.settled) return result;
+    state.settled = true;
+    cancelTeardown?.();
+    session.dispose();
+    return result;
+  };
+  return new Promise<ReviewResult>((resolve) => {
+    const timeoutRef = {
+      steered: false,
+      graceTurnsRemaining: undefined as number | undefined,
+      hardAbortTimer: undefined as ReturnType<typeof setTimeout> | undefined,
+    };
+    const clearHardAbort = () => {
+      if (timeoutRef.hardAbortTimer) {
+        clearTimeout(timeoutRef.hardAbortTimer);
+        timeoutRef.hardAbortTimer = undefined;
+      }
+    };
+    const ctx: RunnerContext = {
+      progress,
+      session,
+      target,
+      timeoutMs,
+      onToolActivity,
+      onProgress,
+      resolve,
+      cleanup,
+      resultHolder,
+      signal,
+      state,
+      timeout: timeoutRef,
+    };
+    session.subscribe((event: AgentSessionEvent) => handleSessionEvent(event, ctx));
+    // --- abort ---
+    const onAbort = () => {
+      if (state.settled) return;
+      clearHardAbort();
+      void session
+        .abort()
+        .catch(() => {})
+        .finally(() => {
+          resolve(cleanup({ kind: "canceled", target }));
+        });
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    // --- timeout ---
+    const HARD_ABORT_GRACE_MS = 120_000;
+    const hardAbort = () => {
+      if (state.settled) return;
+      emitProgress(ctx);
+      void session
+        .abort()
+        .catch(() => {})
+        .finally(() => {
+          const partialText = extractLastAssistantText(session);
+          resolve(cleanup({ kind: "timeout", target, timeoutMs, partialOutput: partialText }));
+        });
+    };
+    const onTimeout = () => {
+      if (state.settled) return;
+      timeoutRef.steered = true;
+      timeoutRef.graceTurnsRemaining = GRACE_TURNS;
+      timeoutRef.hardAbortTimer = setTimeout(hardAbort, HARD_ABORT_GRACE_MS);
+      timeoutRef.hardAbortTimer.unref?.();
+      session
+        .steer(STEER_MESSAGE)
+        .then(() => {
+          // Steer succeeded; grace turns tracked via events
+        })
+        .catch(() => {
+          clearHardAbort();
+          hardAbort();
+        });
+    };
+    const timeoutId = setTimeout(onTimeout, timeoutMs);
+    timeoutId.unref?.();
+    cancelTeardown = () => {
+      signal?.removeEventListener("abort", onAbort);
+      clearTimeout(timeoutId);
+      clearHardAbort();
+    };
+    let cancelledDuringSetup = false;
+    if (signal?.aborted) {
+      signal.removeEventListener("abort", onAbort);
+      cancelledDuringSetup = true;
+      onAbort();
+    }
+    if (!cancelledDuringSetup) {
+      session.prompt(prompt).catch((err: unknown) => {
+        if (!state.settled) {
+          resolve(
+            cleanup({
+              kind: "failed",
+              reason: `Reviewer session error: ${err instanceof Error ? err.message : String(err)}`,
+              target,
+            }),
+          );
+        }
+      });
+    }
+  });
+}

package/src/settings.ts

@@ -0,0 +1,246 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { Input, Key, matchesKey, type SettingItem } from "@earendil-works/pi-tui";
+import {
+  type ConfigSettingsHelpers,
+  loadSupiConfig,
+  registerConfigSettings,
+} from "@mrclrchtr/supi-core";
+import type { ReviewSettings } from "./types.ts";
+
+export const REVIEW_DEFAULTS: ReviewSettings = {
+  reviewModel: "",
+  maxDiffBytes: 100_000,
+  autoFix: false,
+};
+
+const INHERIT_MODEL_VALUE = "(inherit)";
+
+let reviewModelChoices: string[] = [];
+
+export function loadReviewSettings(cwd: string, homeDir?: string): ReviewSettings {
+  return loadSupiConfig("review", cwd, REVIEW_DEFAULTS, { homeDir });
+}
+
+/**
+ * Update the model ids offered by `/supi-settings` for review depth overrides.
+ *
+ * The list is session-local and mirrors the currently available authenticated models.
+ */
+export function setReviewModelChoices(modelChoices: string[]): void {
+  reviewModelChoices = Array.from(
+    new Set(modelChoices.map((choice) => choice.trim()).filter((choice) => choice.length > 0)),
+  );
+}
+
+export function registerReviewSettings(): void {
+  registerConfigSettings({
+    id: "review",
+    label: "Review",
+    section: "review",
+    defaults: REVIEW_DEFAULTS,
+    buildItems: (settings) => buildReviewSettingItems(settings),
+    // biome-ignore lint/complexity/useMaxParams: ConfigSettingsOptions interface callback
+    persistChange: (_scope, _cwd, settingId, value, helpers) => {
+      switch (settingId) {
+        case "reviewModel":
+          persistModelOverride(value, helpers);
+          break;
+        case "maxDiffBytes":
+          persistMaxDiffBytes(value, helpers);
+          break;
+        case "autoFix":
+          persistAutoFix(value, helpers);
+          break;
+      }
+    },
+  });
+}
+
+function persistModelOverride(value: string, helpers: ConfigSettingsHelpers): void {
+  if (value.trim() && value !== INHERIT_MODEL_VALUE) {
+    helpers.set("reviewModel", value.trim());
+  } else {
+    helpers.unset("reviewModel");
+  }
+}
+
+function persistMaxDiffBytes(value: string, helpers: ConfigSettingsHelpers): void {
+  const num = Number.parseInt(value, 10);
+  if (Number.isFinite(num) && num > 0) {
+    helpers.set("maxDiffBytes", num);
+  } else {
+    helpers.unset("maxDiffBytes");
+  }
+}
+
+function persistAutoFix(value: string, helpers: ConfigSettingsHelpers): void {
+  if (value === "on") {
+    helpers.set("autoFix", true);
+  } else {
+    helpers.unset("autoFix");
+  }
+}
+
+// ─── Scoped model helpers (workaround for pi-mono#3535) ──────────────────────
+
+/**
+ * Read PI’s `enabledModels` from settings.json (the user’s configured scoped model patterns).
+ * Returns undefined when no scope is configured (all models available).
+ */
+export function readPiEnabledModels(): string[] | undefined {
+  try {
+    const settingsPath = join(getAgentDir(), "settings.json");
+    if (!existsSync(settingsPath)) return undefined;
+    const raw = readFileSync(settingsPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed?.enabledModels)) {
+      const patterns = parsed.enabledModels.filter(
+        (p: unknown): p is string => typeof p === "string" && p.length > 0,
+      );
+      return patterns.length > 0 ? patterns : undefined;
+    }
+  } catch {
+    // settings.json may not exist or be invalid JSON
+  }
+  return undefined;
+}
+
+/**
+ * Filter available models to only those matching enabled model patterns.
+ * Uses simple glob-style matching (* and ? wildcards) on both bare model IDs
+ * and canonical provider/modelId references.
+ */
+export function filterByEnabledModels<T extends { provider: string; id: string }>(
+  patterns: string[],
+  available: T[],
+): T[] {
+  const seen = new Set<string>();
+  const result: T[] = [];
+
+  for (const model of available) {
+    for (const pattern of patterns) {
+      if (matchModelPattern(model, pattern)) {
+        const key = `${model.provider}/${model.id}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          result.push(model);
+        }
+        break;
+      }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Match a model against a single pattern.
+ * - If pattern contains "/", match against canonical “provider/modelId”
+ * - Otherwise, match against both bare modelId and canonical ref
+ * - Supports * (any chars) and ? (single char) wildcards
+ */
+function matchModelPattern(model: { provider: string; id: string }, pattern: string): boolean {
+  const canonical = `${model.provider}/${model.id}`;
+
+  // Pattern with a slash is always canonical
+  if (pattern.includes("/")) {
+    return simpleGlobMatch(canonical, pattern);
+  }
+
+  // Bare pattern: try both canonical and bare model id
+  return simpleGlobMatch(canonical, pattern) || simpleGlobMatch(model.id, pattern);
+}
+
+/**
+ * Simple glob matching with * (any chars) and ? (single char) wildcards.
+ * Falls back to exact case-insensitive comparison when no wildcards are present.
+ */
+function simpleGlobMatch(text: string, pattern: string): boolean {
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    return text.toLowerCase() === pattern.toLowerCase();
+  }
+
+  // Convert simple glob to regex
+  const regexStr = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+
+  return new RegExp(`^${regexStr}$`, "i").test(text);
+}
+
+function buildReviewSettingItems(settings: ReviewSettings): SettingItem[] {
+  return [
+    {
+      id: "reviewModel",
+      label: "Review Model",
+      description:
+        "Preselect the model used by /supi-review. Inherit uses the active session model.",
+      currentValue: settings.reviewModel || INHERIT_MODEL_VALUE,
+      values: buildModelCycleValues(settings.reviewModel),
+    },
+    {
+      id: "maxDiffBytes",
+      label: "Max Diff Size",
+      description: "Maximum diff bytes before truncation (default 100000)",
+      currentValue: String(settings.maxDiffBytes),
+      submenu: (currentValue, done) =>
+        createInputSubmenu(currentValue, "Max diff bytes before truncation:", done),
+    },
+    {
+      id: "autoFix",
+      label: "Auto-Fix After Review",
+      description: "Automatically trigger a fix turn after review completes with findings",
+      currentValue: settings.autoFix ? "on" : "off",
+      values: ["on", "off"],
+    },
+  ];
+}
+
+function buildModelCycleValues(currentValue: string): string[] {
+  const values = [INHERIT_MODEL_VALUE];
+  if (currentValue && !reviewModelChoices.includes(currentValue)) {
+    values.push(currentValue);
+  }
+  values.push(...reviewModelChoices);
+  return values;
+}
+
+function createInputSubmenu(
+  currentValue: string,
+  label: string,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const input = new Input();
+  input.setValue(currentValue);
+
+  return {
+    render: (width: number) => {
+      const lines = [`  ${label}`];
+      lines.push(...input.render(width));
+      lines.push("  enter confirm • esc cancel");
+      return lines;
+    },
+    invalidate: () => {
+      input.invalidate();
+    },
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        done();
+        return true;
+      }
+      if (matchesKey(data, Key.enter)) {
+        done(input.getValue());
+        return true;
+      }
+      input.handleInput(data);
+      return true;
+    },
+  };
+}