@dreki-gg/pi-code-reviewer 0.5.0 → 0.6.0

package/extensions/code-reviewer/commands/review-tool.ts

@@ -148,17 +148,32 @@ export function registerReviewTool(pi: ExtensionAPI) {
             signal,
           );
           ctx.ui.setStatus('code-review', undefined);
-          return {
-            content: [{ type: 'text', text: renderPipelineReport(pipeline, diff) }],
+          // Every pass failed (e.g. the review model/pi-ai was unavailable for
+          // each call). The swallowed failures would render as a misleading
+          // "0 findings" report — instead, degrade to the single-pass prompt so
+          // the reviewing agent still produces a real review.
+          const allPassesFailed =
+            config.review.passes > 0 && pipeline.telemetry.failedPasses >= config.review.passes;
+          if (!allPassesFailed) {
+            return {
+              content: [{ type: 'text', text: renderPipelineReport(pipeline, diff) }],
+              details: {
+                mode: 'pipeline',
+                lensCount: lensNames.length,
+                availableLenses: [...available.keys()],
+                changedFiles,
+                findings: pipeline.findings,
+                telemetry: pipeline.telemetry,
+              },
+            };
+          }
+          onUpdate?.({
+            content: [{ type: 'text', text: 'all review passes failed — single-pass fallback' }],
             details: {
-              mode: 'pipeline',
-              lensCount: lensNames.length,
-              availableLenses: [...available.keys()],
-              changedFiles,
-              findings: pipeline.findings,
-              telemetry: pipeline.telemetry,
+              failedPasses: pipeline.telemetry.failedPasses,
+              passError: pipeline.telemetry.passErrorSample,
             },
-          };
+          });
         } catch (cause) {
           // Pipeline failed hard (e.g. model/pi-ai unavailable at runtime) —
           // degrade to the single-pass prompt instead of failing the review.

package/extensions/code-reviewer/diff.ts

@@ -23,6 +23,14 @@ export type DiffOptions = { base?: string; staged?: boolean };
  *  the whole review. */
 const GIT_TIMEOUT_MS = 30_000;
 
+/** Cap on untracked files diffed against /dev/null so a repo full of generated
+ *  junk can't blow up the prompt. The whole diff is truncated downstream too. */
+const MAX_UNTRACKED_FILES = 200;
+
+/** The empty tree object — diffing a path against it yields a full new-file
+ *  diff portably (no reliance on /dev/null path handling across platforms). */
+const NULL_DEVICE = '/dev/null';
+
 function git(args: string[], cwd: string): Effect.Effect<string, ExecError, Executor> {
   return Effect.gen(function* () {
     const executor = yield* Executor;
@@ -31,6 +39,51 @@ function git(args: string[], cwd: string): Effect.Effect<string, ExecError, Exec
   });
 }
 
+/**
+ * Diff every untracked (new, not-yet-`git add`ed) file against /dev/null so
+ * brand-new files show up in a working-directory review — `git diff HEAD`
+ * omits them entirely, which is exactly the class of change agents introduce.
+ *
+ * Read-only: it NEVER touches the index (no `git add -N`). `git diff --no-index`
+ * exits non-zero when files differ, but pi.exec resolves with the diff on stdout
+ * regardless; any per-file failure degrades to an empty string rather than
+ * sinking the whole review.
+ */
+function collectUntrackedEffect(
+  cwd: string,
+): Effect.Effect<{ diff: string; files: string[] }, never, Executor> {
+  return Effect.gen(function* () {
+    const listed = yield* git(['ls-files', '--others', '--exclude-standard'], cwd).pipe(
+      Effect.orElseSucceed(() => ''),
+    );
+    const files = listed
+      .split('\n')
+      .map((f) => f.trim())
+      .filter(Boolean);
+    if (files.length === 0) return { diff: '', files: [] };
+
+    const parts = yield* Effect.forEach(
+      files.slice(0, MAX_UNTRACKED_FILES),
+      (file) =>
+        git(['diff', '--no-index', '--', NULL_DEVICE, file], cwd).pipe(
+          Effect.orElseSucceed(() => ''),
+        ),
+      { concurrency: 4 },
+    );
+    return { diff: parts.filter((part) => part.trim()).join('\n'), files };
+  });
+}
+
+/** Append a one-line-per-file summary of untracked files to a `--stat` block so
+ *  the change overview reflects new files that git's own stat never lists. */
+function appendUntrackedStat(stat: string, files: string[]): string {
+  if (files.length === 0) return stat;
+  const shown = files.slice(0, MAX_UNTRACKED_FILES);
+  const lines = shown.map((file) => ` ${file} | (new, untracked)`);
+  const note = `${files.length} untracked file(s) included`;
+  return [stat.trimEnd(), ...lines, note].filter(Boolean).join('\n');
+}
+
 /** Collect the diff from the working directory or a specific base ref. */
 export function collectDiffEffect(
   cwd: string,
@@ -49,20 +102,31 @@ export function collectDiffEffect(
       return { diff, stat, label: `changes since ${options.base}` };
     }
 
-    // Default: working directory changes (unstaged + staged) relative to HEAD.
-    // `git diff HEAD` fails on a repo with no commits (HEAD is unborn), so
+    // Default: EVERYTHING the agent is working on but hasn't committed —
+    // tracked changes (unstaged + staged) relative to HEAD, PLUS untracked
+    // (brand-new) files. `git diff HEAD` covers only the former; untracked
+    // files are collected separately and merged so new files are reviewed too.
+    // `git diff HEAD` also fails on a repo with no commits (HEAD is unborn), so
     // tolerate that and fall back to the bare working-directory diff.
     const headDiff = yield* git(['diff', 'HEAD'], cwd).pipe(Effect.either);
+    const untracked = yield* collectUntrackedEffect(cwd);
 
-    // No HEAD (fresh repo) or an empty HEAD diff → fall back to the working dir.
+    let tracked: string;
+    let stat: string;
+    let label: string;
     if (headDiff._tag === 'Left' || !headDiff.right.trim()) {
-      const wdDiff = yield* git(['diff'], cwd);
-      const wdStat = yield* git(['diff', '--stat'], cwd);
-      return { diff: wdDiff, stat: wdStat, label: 'working directory changes' };
+      // No HEAD (fresh repo) or no tracked changes → use the bare working dir.
+      tracked = yield* git(['diff'], cwd);
+      stat = yield* git(['diff', '--stat'], cwd);
+      label = 'working directory changes';
+    } else {
+      tracked = headDiff.right;
+      stat = yield* git(['diff', 'HEAD', '--stat'], cwd);
+      label = 'all uncommitted changes';
     }
 
-    const stat = yield* git(['diff', 'HEAD', '--stat'], cwd);
-    return { diff: headDiff.right, stat, label: 'all uncommitted changes' };
+    const diff = [tracked, untracked.diff].filter((part) => part.trim()).join('\n');
+    return { diff, stat: appendUntrackedStat(stat, untracked.files), label };
   });
 }
 
@@ -72,19 +136,31 @@ export function getChangedFilesEffect(
   options: DiffOptions,
 ): Effect.Effect<string[], ExecError, Executor> {
   return Effect.gen(function* () {
-    const args = ['diff', '--name-only'];
-    if (options.staged) args.push('--staged');
-    else if (options.base) args.push(options.base);
-    else args.push('HEAD');
+    if (options.staged || options.base) {
+      const args = ['diff', '--name-only', options.staged ? '--staged' : options.base!];
+      const stdout = yield* git(args, cwd);
+      return splitPaths(stdout);
+    }
 
-    const stdout = yield* git(args, cwd);
-    return stdout
-      .split('\n')
-      .map((f) => f.trim())
-      .filter(Boolean);
+    // Default: tracked changes vs HEAD (tolerate an unborn HEAD) plus untracked
+    // files, deduped, so the changed-file list mirrors the merged default diff.
+    const tracked = yield* git(['diff', '--name-only', 'HEAD'], cwd).pipe(
+      Effect.orElseSucceed(() => ''),
+    );
+    const untracked = yield* git(['ls-files', '--others', '--exclude-standard'], cwd).pipe(
+      Effect.orElseSucceed(() => ''),
+    );
+    return [...new Set([...splitPaths(tracked), ...splitPaths(untracked)])];
   });
 }
 
+function splitPaths(stdout: string): string[] {
+  return stdout
+    .split('\n')
+    .map((f) => f.trim())
+    .filter(Boolean);
+}
+
 // ── Promise wrappers (live Executor from pi) ──────────────────────────────────
 
 export function collectDiff(

package/extensions/code-reviewer/passes.ts

@@ -16,6 +16,7 @@
 
 import { Effect } from 'effect';
 
+import { causeMessage } from './errors';
 import { type ModelResolution, Reviewer, makeReviewerService } from './effects/model';
 import type {
   CandidateFinding,
@@ -355,7 +356,11 @@ export function runPassesEffect(
   config: ReviewPipelineConfig,
   plan: ModelPlan,
   signal?: AbortSignal,
-): Effect.Effect<{ perPass: RawFinding[][]; failedPasses: number }, never, Reviewer> {
+): Effect.Effect<
+  { perPass: RawFinding[][]; failedPasses: number; passErrorSample?: string },
+  never,
+  Reviewer
+> {
   return Effect.gen(function* () {
     const reviewer = yield* Reviewer;
     const indices = Array.from({ length: config.passes }, (_unused, index) => index);
@@ -380,19 +385,29 @@ export function runPassesEffect(
             })
             .pipe(Effect.either);
           return result._tag === 'Right'
-            ? { findings: parseFindings(result.right), failed: false }
-            : { findings: [] as RawFinding[], failed: true };
+            ? { findings: parseFindings(result.right), failed: false, error: undefined }
+            : { findings: [] as RawFinding[], failed: true, error: describePassError(result.left) };
         }),
       { concurrency: Math.max(1, config.concurrency) },
     );
 
+    const failures = outcomes.filter((outcome) => outcome.failed);
     return {
       perPass: outcomes.map((outcome) => outcome.findings),
-      failedPasses: outcomes.filter((outcome) => outcome.failed).length,
+      failedPasses: failures.length,
+      passErrorSample: failures[0]?.error,
     };
   });
 }
 
+/** Best-effort human message for a failed pass: the ModelError's own message
+ *  when present, else its underlying cause. */
+function describePassError(error: unknown): string {
+  const message = (error as { message?: unknown }).message;
+  if (typeof message === 'string' && message.trim()) return message;
+  return causeMessage((error as { cause?: unknown }).cause);
+}
+
 function buildValidatorUser(basePrompt: string, candidates: CandidateFinding[]): string {
   const list = candidates
     .map((candidate, index) => {
@@ -514,7 +529,12 @@ export function runPipelineEffect(
 ): Effect.Effect<PipelineResult, never, Reviewer> {
   return Effect.gen(function* () {
     hooks.onStage?.(`running ${config.passes} passes`);
-    const { perPass, failedPasses } = yield* runPassesEffect(basePrompt, config, plan, signal);
+    const { perPass, failedPasses, passErrorSample } = yield* runPassesEffect(
+      basePrompt,
+      config,
+      plan,
+      signal,
+    );
 
     const buckets = bucketFindings(perPass);
     const { kept, droppedLowSignal } = selectCandidates(buckets, config);
@@ -547,6 +567,7 @@ export function runPipelineEffect(
       droppedFalsePositives,
       droppedLowSignal,
       failedPasses,
+      passErrorSample,
       passModels: plan.passes.map((assignment) => assignment.label),
       validatorModel: plan.validator.label,
     };

package/extensions/code-reviewer/reviewer.ts

@@ -159,10 +159,38 @@ export function renderPipelineReport(result: PipelineResult, diff: DiffSource):
     '',
   ];
 
+  // A pass fails when its model call errors; failures are swallowed into 0
+  // findings, so an all-failed run must NOT masquerade as a clean review.
+  const someFailed = telemetry.failedPasses > 0;
+  const allFailed = telemetry.passes > 0 && telemetry.failedPasses >= telemetry.passes;
+  const errSuffix = telemetry.passErrorSample ? ` — e.g. ${telemetry.passErrorSample}` : '';
+
   if (findings.length === 0) {
+    if (allFailed) {
+      return [
+        ...header,
+        `> ⚠️ **Inconclusive — all ${telemetry.passes} review pass(es) failed${errSuffix}.**`,
+        '> No analysis actually ran; this is NOT a clean result. Re-run the review',
+        '> (check that the review model / pi-ai is available) before trusting it.',
+      ].join('\n');
+    }
+    if (someFailed) {
+      return [
+        ...header,
+        `> ⚠️ **Partial review — ${telemetry.failedPasses}/${telemetry.passes} pass(es) failed${errSuffix}.**`,
+        `> The ${telemetry.passes - telemetry.failedPasses} surviving pass(es) found nothing, but coverage was reduced.`,
+      ].join('\n');
+    }
     return [...header, 'No bugs found that survived validation. ✅'].join('\n');
   }
 
+  const partialWarning = someFailed
+    ? [
+        `> ⚠️ **Partial review — ${telemetry.failedPasses}/${telemetry.passes} pass(es) failed${errSuffix}; findings below may be incomplete.**`,
+        '',
+      ]
+    : [];
+
   // Only attribute models per finding when more than one distinct model ran
   // (a bake-off); with a single model it's noise.
   const multiModel = new Set(telemetry.passModels).size > 1;
@@ -180,7 +208,7 @@ export function renderPipelineReport(result: PipelineResult, diff: DiffSource):
     return `- ${SEVERITY_EMOJI[finding.severity]} **${finding.severity}** ${where} — ${finding.message} _(${meta})_${justification}`;
   });
 
-  return [...header, '## Findings', '', ...lines].join('\n');
+  return [...header, ...partialWarning, '## Findings', '', ...lines].join('\n');
 }
 
 /** Build the lens-specific section of the review prompt (no diff duplication). */

package/extensions/code-reviewer/types.ts

@@ -95,6 +95,9 @@ export type PipelineTelemetry = {
   droppedFalsePositives: number;
   droppedLowSignal: number;
   failedPasses: number;
+  /** A representative error message from the first failed pass, surfaced so a
+   *  fully-failed run reports WHY instead of a misleading "0 findings". */
+  passErrorSample?: string;
   /** Model key used for each pass (parallel to pass index). */
   passModels: string[];
   /** Model key used for the validator stage. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-code-reviewer",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Multi-lens code review extension for pi — configurable review criteria per project",
   "keywords": [
     "pi-package"