pi-workflow-engine 0.1.0 → 0.2.0

package/workflows/code-review.ts

@@ -1,5 +1,6 @@
+import { execSync } from "node:child_process";
 import { Type } from "typebox";
-import type { WorkflowApi, WorkflowMeta } from "../src/types.ts";
+import type { WorkflowApi, WorkflowMeta, WorkflowRunStats } from "../src/types.ts";
 
 export const meta: WorkflowMeta = {
   name: "code-review",
@@ -40,6 +41,8 @@ const ReportSchema = Type.Object({
       severity: Type.Union([Type.Literal("bug"), Type.Literal("cleanup")]),
       verdict: Type.Union([Type.Literal("CONFIRMED"), Type.Literal("PLAUSIBLE")]),
       summary: Type.String(),
+      evidence: Type.Optional(Type.String()),
+      failure_scenario: Type.Optional(Type.String()),
     }),
   ),
 });
@@ -72,10 +75,58 @@ const ANGLES: Angle[] = [
 
 const TOOLS = ["read", "bash"];
 const PER_ANGLE = 6;
+const DIFF_EMBED_CAP = 60_000;
+
+/** Strip leading "./", "a/", "b/" so diff paths and finder-reported paths compare equal. */
+export function normalizePath(path: string): string {
+  return path.replace(/^\.\//, "").replace(/^[ab]\//, "");
+}
+
+/** Parse a unified diff into the set of added/changed new-file line numbers per file. */
+export function changedLines(diff: string): Map<string, Set<number>> {
+  const byFile = new Map<string, Set<number>>();
+  let file: string | null = null;
+  let newLine = 0;
+  for (const raw of diff.split("\n")) {
+    if (raw.startsWith("+++ ")) {
+      const path = raw.slice(4).trim();
+      file = path === "/dev/null" ? null : normalizePath(path);
+      if (file && !byFile.has(file)) byFile.set(file, new Set());
+    } else if (raw.startsWith("@@")) {
+      const match = /\+(\d+)/.exec(raw);
+      newLine = match ? Number(match[1]) : 0;
+    } else if (file === null || raw.startsWith("---") || raw.startsWith("\\")) {
+      // file header, deletion, or "No newline" marker — record nothing
+    } else if (raw.startsWith("+")) {
+      byFile.get(file)!.add(newLine++);
+    } else if (!raw.startsWith("-")) {
+      newLine++; // context line advances the new-file counter; deletions do not
+    }
+  }
+  return byFile;
+}
+
+/** Is a finding inside the diff? File-level findings count if the file changed; ±1 line of fuzz. */
+export function inDiff(changed: Map<string, Set<number>>, file: string, line?: number): boolean {
+  const set = changed.get(normalizePath(file));
+  if (!set) return false;
+  if (line == null) return true;
+  return set.has(line) || set.has(line - 1) || set.has(line + 1);
+}
 
 export default async function run(api: WorkflowApi): Promise<unknown> {
-  const { agent, parallel, pipeline, phase, log, args } = api;
+  const { agent, parallel, pipeline, phase, log, progress, args, cwd } = api;
   const target = args.trim();
+  let fileCount = 0;
+  let rawCandidateCount = 0;
+  let droppedCandidateCount = 0;
+  const makeStats = (verified: number, kept: number): WorkflowRunStats => ({
+    files: fileCount,
+    candidates: rawCandidateCount,
+    verified,
+    kept,
+    dropped: droppedCandidateCount,
+  });
 
   // ─── Phase 0: Scope ───
   phase("Scope");
@@ -98,14 +149,46 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
     { phase: "Scope", label: "scope", tools: TOOLS, thinkingLevel: "medium", schema: ScopeSchema },
   );
 
-  if (!scope || scope.files.length === 0) {
-    return { summary: "No changes found to review.", findings: [], stats: { candidates: 0, verified: 0 } };
+  if (!scope) {
+    return { summary: "No changes found to review.", findings: [], stats: makeStats(0, 0) };
+  }
+
+  fileCount = scope.files.length;
+  progress({ type: "summary", key: "files", value: scope.files.join(", ") || "(none)" });
+  progress({ type: "summary", key: "diffCommand", value: scope.diffCommand });
+  progress({ type: "counter", key: "files", label: "files", value: fileCount });
+
+  if (scope.files.length === 0) {
+    return { summary: "No changes found to review.", findings: [], stats: makeStats(0, 0) };
   }
   log(`${scope.files.length} changed files`);
 
+  // Capture the diff once, deterministically, so findings can be bounded to changed lines in code.
+  let changed: Map<string, Set<number>> | null = null;
+  let diffText = "";
+  if (/^(git diff|gh pr diff)\b/.test(scope.diffCommand)) {
+    try {
+      diffText = execSync(scope.diffCommand, { cwd, encoding: "utf8", maxBuffer: 16 << 20 });
+      changed = changedLines(diffText);
+    } catch (error) {
+      log(`diff capture failed (${error instanceof Error ? error.message : String(error)}) — reviewing without the line gate`);
+    }
+  } else {
+    log("diffCommand not in the git/gh allowlist — reviewing without the line gate");
+  }
+
+  const diffBlock = diffText
+    ? `\n## Diff (review is bounded to these changed lines)\n\`\`\`diff\n${
+        diffText.length > DIFF_EMBED_CAP
+          ? `${diffText.slice(0, DIFF_EMBED_CAP)}\n... (truncated — run \`${scope.diffCommand}\` for the full diff)`
+          : diffText
+      }\n\`\`\`\n`
+    : "";
+
   const scopeBlock =
     `## Diff command\n${scope.diffCommand}\n\n## Changed files\n${scope.files.map((file) => `- ${file}`).join("\n")}\n\n` +
     `## Summary\n${scope.summary}\n\n## Conventions\n${scope.conventions ?? "(none noted)"}\n` +
+    diffBlock +
     (target ? `\n## User instructions (verbatim)\n${target}\n` : "");
 
   // Dedup state accumulates as finders complete (the pipeline has no barrier).
@@ -122,12 +205,37 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
       const angle = item as Angle;
       const found = await agent(
         `## Code-review finder — ${angle.label}\n\n${scopeBlock}\n` +
-          `Run the diff command and review ONLY through this lens:\n${angle.text}\n` +
-          `Surface up to ${PER_ANGLE} candidates, each with file, line, a one-line summary, and a concrete failure_scenario. ` +
+          `Review the change through ONLY this lens:\n${angle.text}\n` +
+          "Only flag issues on lines that are part of the diff above (run the diff command if it is not shown). " +
+          "You may read surrounding files for context, but never report issues in unchanged code. " +
+          `Surface up to ${PER_ANGLE} candidates, each with file, a line that appears in the diff, a one-line summary, and a concrete failure_scenario. ` +
           "Pass through anything with a nameable failure scenario — a separate verifier judges them next. Structured output only.",
         { phase: "Find", label: `find:${angle.label}`, tools: TOOLS, thinkingLevel: "low", schema: CandidatesSchema },
       );
-      return { angle, candidates: (found?.candidates ?? []).slice(0, PER_ANGLE) };
+      const raw = (found?.candidates ?? []).slice(0, PER_ANGLE);
+      rawCandidateCount += raw.length;
+      progress({ type: "counter_delta", key: "candidates", label: "candidates", delta: raw.length });
+      const gate = changed;
+      const bounded = gate ? raw.filter((candidate) => inDiff(gate, candidate.file, candidate.line)) : raw;
+      const dropped = raw.length - bounded.length;
+      if (dropped > 0) {
+        droppedCandidateCount += dropped;
+        progress({ type: "counter_delta", key: "dropped", label: "dropped", delta: dropped });
+      }
+      if (gate && dropped > 0) {
+        log(`find:${angle.label}: dropped ${dropped} out-of-diff candidate(s)`);
+      }
+      for (const candidate of bounded) {
+        progress({
+          type: "lane_item",
+          lane: "Candidates",
+          title: candidate.summary,
+          subtitle: formatLocation(candidate),
+          status: "pending",
+          details: candidate.failure_scenario,
+        });
+      }
+      return { angle, candidates: bounded };
     },
     // Stage 2: dedup against the shared set, then verify survivors concurrently.
     async (prev) => {
@@ -148,7 +256,17 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
               "with evidence quoting the line(s). Default toward REFUTED if you cannot substantiate it. Structured output only.",
             { phase: "Verify", label: `verify:${candidate.file.split("/").pop() ?? candidate.file}`, tools: TOOLS, thinkingLevel: "low", schema: VerdictSchema },
           );
-          return judged ? { ...candidate, verdict: judged.verdict, evidence: judged.evidence, kind: angle.kind } : null;
+          if (!judged) return null;
+          progress({ type: "counter_delta", key: `verdict.${judged.verdict.toLowerCase()}`, label: judged.verdict, delta: 1 });
+          progress({
+            type: "lane_item",
+            lane: verdictLane(judged.verdict),
+            title: candidate.summary,
+            subtitle: formatLocation(candidate),
+            status: verdictStatus(judged.verdict),
+            details: judged.evidence,
+          });
+          return { ...candidate, verdict: judged.verdict, evidence: judged.evidence, kind: angle.kind };
         }),
       );
       return verdicts.filter((value): value is Verified => value !== null);
@@ -157,10 +275,15 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
 
   const verified = (perAngle as Verified[][]).flat();
   const surviving = verified.filter((finding) => finding.verdict !== "REFUTED");
+  const stats = makeStats(verified.length, surviving.length);
+  progress({ type: "counter", key: "verified", label: "verified", value: verified.length });
+  progress({ type: "counter", key: "kept", label: "kept", value: surviving.length });
+  progress({ type: "summary", key: "verified", value: verified.length });
+  progress({ type: "summary", key: "kept", value: surviving.length });
   log(`${verified.length} verified → ${surviving.length} kept`);
 
   if (surviving.length === 0) {
-    return { summary: "No findings survived verification.", findings: [], stats: { candidates: seen.size, verified: verified.length } };
+    return { summary: "No findings survived verification.", findings: [], stats };
   }
 
   // ─── Synthesize: rank, merge, report ───
@@ -177,9 +300,49 @@ export default async function run(api: WorkflowApi): Promise<unknown> {
 
   const report = await agent(
     `## Synthesis: final code-review report\n\n${ranked.length} findings survived independent verification.\n\n${block}\n\n` +
-      "Merge findings with the same root cause, rank most-severe first (correctness bugs above cleanups), and produce the final report. Structured output only.",
+      "Merge findings with the same root cause, rank most-severe first (correctness bugs above cleanups), and produce the final report. Include evidence and failure_scenario for each finding when available. Structured output only.",
     { phase: "Synthesize", label: "synthesize", thinkingLevel: "medium", schema: ReportSchema },
   );
 
-  return report ?? { summary: "Synthesis produced no output.", findings: [] };
+  if (!report) return { summary: "Synthesis produced no output.", findings: [], stats };
+
+  const findings = report.findings.map((finding) => {
+    const source = ranked.find((candidate) => sameFinding(candidate, finding));
+    return {
+      ...finding,
+      evidence: finding.evidence ?? source?.evidence,
+      failure_scenario: finding.failure_scenario ?? source?.failure_scenario,
+    };
+  });
+  return { ...report, findings, stats };
+}
+
+function formatLocation(candidate: Pick<Candidate, "file" | "line">): string {
+  return `${candidate.file}${candidate.line != null ? `:${candidate.line}` : ""}`;
+}
+
+function verdictLane(verdict: Verified["verdict"]): string {
+  switch (verdict) {
+    case "CONFIRMED":
+      return "Confirmed";
+    case "PLAUSIBLE":
+      return "Plausible";
+    case "REFUTED":
+      return "Refuted";
+  }
+}
+
+function verdictStatus(verdict: Verified["verdict"]): "success" | "warning" | "error" {
+  switch (verdict) {
+    case "CONFIRMED":
+      return "success";
+    case "PLAUSIBLE":
+      return "warning";
+    case "REFUTED":
+      return "error";
+  }
+}
+
+function sameFinding(candidate: Verified, finding: { file: string; line?: number; summary: string }): boolean {
+  return normalizePath(candidate.file) === normalizePath(finding.file) && candidate.line === finding.line;
 }