@dreki-gg/pi-code-reviewer 0.1.1 → 0.3.0

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

@@ -7,9 +7,9 @@ export function registerReviewLensesCommand(pi: ExtensionAPI) {
   pi.registerCommand('review-lenses', {
     description: 'List available review lenses for this project',
     handler: async (_args, ctx) => {
-      const config = loadConfig(ctx.cwd);
+      const config = await loadConfig(ctx.cwd);
       const lensDir = getLensDir(ctx.cwd, config);
-      const available = discoverLenses(lensDir);
+      const available = await discoverLenses(lensDir);
 
       if (available.size === 0) {
         ctx.ui.notify(

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

@@ -38,11 +38,11 @@ export function registerReviewTool(pi: ExtensionAPI) {
       ),
     }),
 
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
       const cwd = ctx.cwd;
-      const config = loadConfig(cwd);
+      const config = await loadConfig(cwd);
       const lensDir = getLensDir(cwd, config);
-      const available = discoverLenses(lensDir);
+      const available = await discoverLenses(lensDir);
 
       if (available.size === 0) {
         return {
@@ -58,12 +58,14 @@ export function registerReviewTool(pi: ExtensionAPI) {
 
       const lensNames = resolveLensNames(params.lenses, config, available);
 
+      ctx.ui.setStatus('code-review', '🔍 Collecting diff...');
       const diff = await collectDiff(pi, cwd, {
         base: params.base,
         staged: params.staged,
       });
 
       if (!diff.diff.trim()) {
+        ctx.ui.setStatus('code-review', undefined);
         return {
           content: [{ type: 'text', text: 'No changes to review.' }],
           details: {},
@@ -71,15 +73,25 @@ export function registerReviewTool(pi: ExtensionAPI) {
       }
 
       const results: LensResult[] = [];
-      for (const name of lensNames) {
+      for (let i = 0; i < lensNames.length; i++) {
         if (signal?.aborted) break;
 
+        const name = lensNames[i];
+        const progressMsg = `Lens ${i + 1}/${lensNames.length}: ${name}`;
+        ctx.ui.setStatus('code-review', `🔍 ${progressMsg}`);
+        onUpdate?.({
+          content: [{ type: 'text', text: progressMsg }],
+          details: { currentLens: name, lensIndex: i + 1, totalLenses: lensNames.length },
+        });
+
         const lens = available.get(name)!;
-        const content = getLensContent(lensDir, name) ?? '';
+        const content = (await getLensContent(lensDir, name)) ?? '';
         const result = await reviewWithLens(pi, ctx, cwd, lens, content, diff, signal);
         results.push(result);
       }
 
+      ctx.ui.setStatus('code-review', undefined);
+
       const report: ReviewReport = {
         diff: diff.diff,
         diffStat: diff.stat,

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

@@ -3,7 +3,7 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { loadConfig, getLensDir } from '../config';
 import { collectDiff } from '../diff';
 import { discoverLenses, getLensContent } from '../lenses';
-import { reviewWithLens } from '../reviewer';
+import { reviewWithLens, buildDiffSection } from '../reviewer';
 import { parseReviewArgs } from '../parse-args';
 
 export function registerReviewCommand(pi: ExtensionAPI) {
@@ -12,9 +12,9 @@ export function registerReviewCommand(pi: ExtensionAPI) {
       'Run a multi-lens code review on working directory changes. Usage: /review [--lens name,...] [--base ref] [--staged]',
     handler: async (args, ctx) => {
       const cwd = ctx.cwd;
-      const config = loadConfig(cwd);
+      const config = await loadConfig(cwd);
       const lensDir = getLensDir(cwd, config);
-      const available = discoverLenses(lensDir);
+      const available = await discoverLenses(lensDir);
 
       if (available.size === 0) {
         ctx.ui.notify(
@@ -34,36 +34,61 @@ export function registerReviewCommand(pi: ExtensionAPI) {
         return;
       }
 
+      ctx.ui.setStatus('code-review', '🔍 Collecting diff...');
       const diff = await collectDiff(pi, cwd, {
         base: parsed.base,
         staged: parsed.staged,
       });
 
       if (!diff.diff.trim()) {
+        ctx.ui.setStatus('code-review', undefined);
         ctx.ui.notify('No changes to review', 'info');
         return;
       }
 
       ctx.ui.notify(`Reviewing ${diff.label} through ${lensNames.length} lens(es)...`, 'info');
+      ctx.ui.setStatus('code-review', `🔍 Reviewing (0/${lensNames.length})...`);
+
+      const lensSections: string[] = [];
+      for (let i = 0; i < lensNames.length; i++) {
+        const name = lensNames[i];
+        ctx.ui.setStatus('code-review', `🔍 Lens ${i + 1}/${lensNames.length}: ${name}`);
 
-      const lensPrompts: string[] = [];
-      for (const name of lensNames) {
         const lens = available.get(name)!;
-        const content = getLensContent(lensDir, name) ?? '';
+        const content = (await getLensContent(lensDir, name)) ?? '';
         const result = await reviewWithLens(pi, ctx, cwd, lens, content, diff);
 
-        if (result._prompt) {
-          lensPrompts.push(result._prompt);
+        if (result._lensSection) {
+          lensSections.push(result._lensSection);
         }
       }
 
+      ctx.ui.setStatus('code-review', undefined);
+
       const combinedPrompt = [
         `Review the following changes through ${lensNames.length} lens(es): ${lensNames.join(', ')}.`,
         '',
         'For each lens, evaluate the diff against its criteria and produce findings.',
         'Output your review as a structured report with sections per lens.',
         '',
-        ...lensPrompts,
+        buildDiffSection(diff),
+        '',
+        '## Lenses',
+        '',
+        ...lensSections,
+        '',
+        '## Instructions',
+        '',
+        'For each lens above, review the diff and output a JSON array of findings:',
+        '',
+        '```json',
+        '[',
+        '  { "file": "path/to/file.ts", "line": 42, "severity": "warning", "message": "Description" }',
+        ']',
+        '```',
+        '',
+        'After each lens JSON array, write a 2-3 sentence summary.',
+        'If there are no findings for a lens, return an empty array `[]` and note the code looks good.',
       ].join('\n');
 
       pi.sendUserMessage(combinedPrompt, { deliverAs: 'followUp' });

package/extensions/code-reviewer/config.ts

@@ -1,30 +1,47 @@
-import { readFileSync, existsSync } from 'node:fs';
+/**
+ * Review configuration loader.
+ *
+ * Reading `.code-review.json` is an Effect program against the FileSystem
+ * service; a missing or malformed file falls back to defaults (never fails).
+ * The Promise wrapper provides the live service for imperative call sites.
+ */
+
+import { Effect } from 'effect';
 import { resolve } from 'node:path';
+
+import { FileSystem, nodeFileSystemService } from './effects/filesystem';
 import type { ReviewConfig } from './types';
 
 const CONFIG_FILE = '.code-review.json';
 const DEFAULT_LENS_DIR = '.code-review/lenses';
 
-export function loadConfig(cwd: string): ReviewConfig {
-  const configPath = resolve(cwd, CONFIG_FILE);
+function defaultConfig(): ReviewConfig {
+  return { lensDir: DEFAULT_LENS_DIR, defaultLenses: [] };
+}
+
+export function loadConfigEffect(cwd: string): Effect.Effect<ReviewConfig, never, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const raw = yield* fs.readTextFile(getConfigPath(cwd)).pipe(Effect.either);
+    if (raw._tag === 'Left') return defaultConfig();
 
-  if (existsSync(configPath)) {
     try {
-      const raw = readFileSync(configPath, 'utf-8');
-      const parsed = JSON.parse(raw) as Partial<ReviewConfig>;
+      const parsed = JSON.parse(raw.right) as Partial<ReviewConfig>;
       return {
         lensDir: parsed.lensDir ?? DEFAULT_LENS_DIR,
         defaultLenses: parsed.defaultLenses ?? [],
       };
     } catch {
-      // Malformed config — fall back to defaults
+      // Malformed config — fall back to defaults.
+      return defaultConfig();
     }
-  }
+  });
+}
 
-  return {
-    lensDir: DEFAULT_LENS_DIR,
-    defaultLenses: [],
-  };
+export function loadConfig(cwd: string): Promise<ReviewConfig> {
+  return Effect.runPromise(
+    loadConfigEffect(cwd).pipe(Effect.provideService(FileSystem, nodeFileSystemService)),
+  );
 }
 
 export function getLensDir(cwd: string, config: ReviewConfig): string {

package/extensions/code-reviewer/diff.ts

@@ -1,4 +1,15 @@
+/**
+ * Diff collection.
+ *
+ * Git invocations run through the Executor service as typed Effects. The
+ * Promise wrappers build a live Executor from `pi` for imperative call sites.
+ */
+
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Effect } from 'effect';
+
+import { Executor, makeExecutorService } from './effects/exec';
+import type { ExecError } from './errors';
 
 export type DiffSource = {
   diff: string;
@@ -6,73 +17,88 @@ export type DiffSource = {
   label: string;
 };
 
+export type DiffOptions = { base?: string; staged?: boolean };
+
+function git(args: string[], cwd: string): Effect.Effect<string, ExecError, Executor> {
+  return Effect.gen(function* () {
+    const executor = yield* Executor;
+    const result = yield* executor.exec('git', args, { cwd });
+    return result.stdout;
+  });
+}
+
 /** Collect the diff from the working directory or a specific base ref. */
-export async function collectDiff(
-  pi: ExtensionAPI,
+export function collectDiffEffect(
   cwd: string,
-  options: { base?: string; staged?: boolean },
-): Promise<DiffSource> {
-  if (options.staged) {
-    const diff = await pi.exec('git', ['diff', '--staged'], { cwd });
-    const stat = await pi.exec('git', ['diff', '--staged', '--stat'], { cwd });
-    return {
-      diff: diff.stdout,
-      stat: stat.stdout,
-      label: 'staged changes',
-    };
-  }
+  options: DiffOptions,
+): Effect.Effect<DiffSource, ExecError, Executor> {
+  return Effect.gen(function* () {
+    if (options.staged) {
+      const diff = yield* git(['diff', '--staged'], cwd);
+      const stat = yield* git(['diff', '--staged', '--stat'], cwd);
+      return { diff, stat, label: 'staged changes' };
+    }
 
-  if (options.base) {
-    const diff = await pi.exec('git', ['diff', options.base], { cwd });
-    const stat = await pi.exec('git', ['diff', options.base, '--stat'], { cwd });
-    return {
-      diff: diff.stdout,
-      stat: stat.stdout,
-      label: `changes since ${options.base}`,
-    };
-  }
+    if (options.base) {
+      const diff = yield* git(['diff', options.base], cwd);
+      const stat = yield* git(['diff', options.base, '--stat'], cwd);
+      return { diff, stat, label: `changes since ${options.base}` };
+    }
 
-  // Default: working directory changes (unstaged + staged)
-  const diff = await pi.exec('git', ['diff', 'HEAD'], { cwd });
-  const stat = await pi.exec('git', ['diff', 'HEAD', '--stat'], { cwd });
+    // Default: working directory changes (unstaged + staged) relative to HEAD.
+    const diff = yield* git(['diff', 'HEAD'], cwd);
 
-  // If no HEAD diff, fall back to just working directory
-  if (!diff.stdout.trim()) {
-    const wdDiff = await pi.exec('git', ['diff'], { cwd });
-    const wdStat = await pi.exec('git', ['diff', '--stat'], { cwd });
-    return {
-      diff: wdDiff.stdout,
-      stat: wdStat.stdout,
-      label: 'working directory changes',
-    };
-  }
+    // If no HEAD diff, fall back to just the working directory.
+    if (!diff.trim()) {
+      const wdDiff = yield* git(['diff'], cwd);
+      const wdStat = yield* git(['diff', '--stat'], cwd);
+      return { diff: wdDiff, stat: wdStat, label: 'working directory changes' };
+    }
 
-  return {
-    diff: diff.stdout,
-    stat: stat.stdout,
-    label: 'all uncommitted changes',
-  };
+    const stat = yield* git(['diff', 'HEAD', '--stat'], cwd);
+    return { diff, stat, label: 'all uncommitted changes' };
+  });
 }
 
 /** Get a list of changed file paths from the diff. */
-export async function getChangedFiles(
-  pi: ExtensionAPI,
+export function getChangedFilesEffect(
   cwd: string,
-  options: { base?: string; staged?: boolean },
-): Promise<string[]> {
-  const args = ['diff', '--name-only'];
+  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) {
-    args.push('--staged');
-  } else if (options.base) {
-    args.push(options.base);
-  } else {
-    args.push('HEAD');
-  }
+    const stdout = yield* git(args, cwd);
+    return stdout
+      .split('\n')
+      .map((f) => f.trim())
+      .filter(Boolean);
+  });
+}
 
-  const result = await pi.exec('git', args, { cwd });
-  return result.stdout
-    .split('\n')
-    .map((f) => f.trim())
-    .filter(Boolean);
+// ── Promise wrappers (live Executor from pi) ──────────────────────────────────
+
+export function collectDiff(
+  pi: Pick<ExtensionAPI, 'exec'>,
+  cwd: string,
+  options: DiffOptions,
+): Promise<DiffSource> {
+  return Effect.runPromise(
+    collectDiffEffect(cwd, options).pipe(Effect.provideService(Executor, makeExecutorService(pi))),
+  );
+}
+
+export function getChangedFiles(
+  pi: Pick<ExtensionAPI, 'exec'>,
+  cwd: string,
+  options: DiffOptions,
+): Promise<string[]> {
+  return Effect.runPromise(
+    getChangedFilesEffect(cwd, options).pipe(
+      Effect.provideService(Executor, makeExecutorService(pi)),
+    ),
+  );
 }

package/extensions/code-reviewer/effects/exec.ts

@@ -0,0 +1,47 @@
+/**
+ * Executor service — wraps `pi.exec` so shelling out (git, lens tools) becomes
+ * an injectable, typed Effect. Tests provide a fake executor instead of running
+ * real subprocesses.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Context, Effect } from 'effect';
+
+import { ExecError } from '../errors';
+
+export interface ExecOptions {
+  cwd?: string;
+  timeout?: number;
+  signal?: AbortSignal;
+}
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+}
+
+export interface ExecutorService {
+  readonly exec: (
+    command: string,
+    args: string[],
+    options?: ExecOptions,
+  ) => Effect.Effect<ExecResult, ExecError>;
+}
+
+export class Executor extends Context.Tag('CodeReviewer/Executor')<Executor, ExecutorService>() {}
+
+type ExecCapableApi = Pick<ExtensionAPI, 'exec'>;
+
+/** Build a live Executor backed by `pi.exec`. */
+export function makeExecutorService(pi: ExecCapableApi): ExecutorService {
+  return {
+    exec: (command, args, options) =>
+      Effect.tryPromise({
+        try: async () => {
+          const result = await pi.exec(command, args, options);
+          return { stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+        },
+        catch: (cause) => new ExecError({ command, args, cause }),
+      }),
+  };
+}

package/extensions/code-reviewer/effects/filesystem.ts

@@ -0,0 +1,38 @@
+/**
+ * FileSystem service — the only place the code-reviewer reads disk.
+ *
+ * Wrapping Node's `fs/promises` behind an Effect service keeps config and lens
+ * loading pure and injectable: tests swap in an in-memory implementation, and
+ * read failures surface as typed `FileReadError` values.
+ */
+
+import { Context, Effect } from 'effect';
+import { readFile, readdir } from 'node:fs/promises';
+
+import { FileReadError } from '../errors';
+
+export interface FileSystemService {
+  /** Read a UTF-8 file, failing with FileReadError when unreadable/missing. */
+  readonly readTextFile: (path: string) => Effect.Effect<string, FileReadError>;
+  /** List directory entries, failing with FileReadError when the dir is missing. */
+  readonly readDirectory: (path: string) => Effect.Effect<string[], FileReadError>;
+}
+
+export class FileSystem extends Context.Tag('CodeReviewer/FileSystem')<
+  FileSystem,
+  FileSystemService
+>() {}
+
+export const nodeFileSystemService: FileSystemService = {
+  readTextFile: (path) =>
+    Effect.tryPromise({
+      try: () => readFile(path, 'utf-8'),
+      catch: (cause) => new FileReadError({ path, cause }),
+    }),
+
+  readDirectory: (path) =>
+    Effect.tryPromise({
+      try: () => readdir(path),
+      catch: (cause) => new FileReadError({ path, cause }),
+    }),
+};

package/extensions/code-reviewer/effects/runtime.ts

@@ -0,0 +1,21 @@
+/**
+ * Live Effect layers for the code-reviewer extension.
+ *
+ * `fileSystemLayer` covers disk-only programs (config + lens loading).
+ * `makeRuntimeLayer(pi)` adds the `pi.exec`-backed Executor for git/diff and
+ * lens-tool programs.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Layer } from 'effect';
+
+import { Executor, makeExecutorService } from './exec';
+import { FileSystem, nodeFileSystemService } from './filesystem';
+
+export const fileSystemLayer = Layer.succeed(FileSystem, nodeFileSystemService);
+
+export function makeRuntimeLayer(pi: Pick<ExtensionAPI, 'exec'>) {
+  return Layer.mergeAll(fileSystemLayer, Layer.succeed(Executor, makeExecutorService(pi)));
+}
+
+export type CodeReviewerServices = FileSystem | Executor;

package/extensions/code-reviewer/errors.ts

@@ -0,0 +1,57 @@
+/**
+ * Tagged error types for the code-reviewer extension.
+ *
+ * Modeled with Effect's `Data.TaggedError` so failures are typed and carry
+ * structured context. Helpers convert them into human-readable messages and
+ * native `Error`s when an Effect crosses back into Promise-land.
+ */
+
+import { Data } from 'effect';
+
+export class FileReadError extends Data.TaggedError('FileReadError')<{
+  readonly path: string;
+  readonly cause: unknown;
+}> {
+  get message(): string {
+    return `Failed to read ${this.path}: ${causeMessage(this.cause)}`;
+  }
+}
+
+export class ExecError extends Data.TaggedError('ExecError')<{
+  readonly command: string;
+  readonly args: readonly string[];
+  readonly cause: unknown;
+}> {
+  get message(): string {
+    const cmd = [this.command, ...this.args].join(' ');
+    return `Command failed: ${cmd}: ${causeMessage(this.cause)}`;
+  }
+}
+
+export type CodeReviewerError = FileReadError | ExecError;
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+export function causeMessage(cause: unknown): string {
+  if (cause instanceof Error) return cause.message;
+  return String(cause);
+}
+
+export function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === 'object' && error !== null && 'message' in error) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string') return message;
+  }
+  return String(error);
+}
+
+/** Convert a tagged/unknown error into a native Error for Promise rejection. */
+export function toNativeError(error: unknown): Error {
+  if (error instanceof Error) return error;
+  const native = new Error(errorMessage(error));
+  if (typeof error === 'object' && error !== null && '_tag' in error) {
+    native.name = String((error as { _tag: unknown })._tag);
+  }
+  return native;
+}

package/extensions/code-reviewer/lenses.ts

@@ -1,5 +1,7 @@
-import { readFileSync, readdirSync, existsSync } from 'node:fs';
-import { resolve, basename } from 'node:path';
+import { Effect } from 'effect';
+import { basename, resolve } from 'node:path';
+
+import { FileSystem, nodeFileSystemService } from './effects/filesystem';
 import type { LensConfig, LensSeverity } from './types';
 
 type SectionKind = 'top' | 'criteria' | 'tools' | 'severity';
@@ -91,27 +93,52 @@ function parseSeverityRule(trimmed: string, rules: Record<LensSeverity, string>)
   }
 }
 
-/** Discover all lens files in a directory. */
-export function discoverLenses(lensDir: string): Map<string, LensConfig> {
-  const lenses = new Map<string, LensConfig>();
+/** Discover all lens files in a directory (missing dir → empty map). */
+export function discoverLensesEffect(
+  lensDir: string,
+): Effect.Effect<Map<string, LensConfig>, never, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const lenses = new Map<string, LensConfig>();
+
+    const entries = yield* fs.readDirectory(lensDir).pipe(Effect.either);
+    if (entries._tag === 'Left') return lenses;
+
+    for (const file of entries.right.filter((f) => f.endsWith('.md'))) {
+      const content = yield* fs.readTextFile(resolve(lensDir, file)).pipe(Effect.either);
+      if (content._tag === 'Left') continue;
+      const key = basename(file, '.md');
+      lenses.set(key, parseLensFile(content.right, file));
+    }
 
-  if (!existsSync(lensDir)) return lenses;
+    return lenses;
+  });
+}
 
-  const files = readdirSync(lensDir).filter((f) => f.endsWith('.md'));
+/** Get raw markdown content for a lens to pass to the reviewer agent. */
+export function getLensContentEffect(
+  lensDir: string,
+  lensName: string,
+): Effect.Effect<string | null, never, FileSystem> {
+  return Effect.gen(function* () {
+    const fs = yield* FileSystem;
+    const content = yield* fs.readTextFile(resolve(lensDir, `${lensName}.md`)).pipe(Effect.either);
+    return content._tag === 'Right' ? content.right : null;
+  });
+}
 
-  for (const file of files) {
-    const content = readFileSync(resolve(lensDir, file), 'utf-8');
-    const config = parseLensFile(content, file);
-    const key = basename(file, '.md');
-    lenses.set(key, config);
-  }
+// ── Promise wrappers (live FileSystem provided) ──────────────────────────────
 
-  return lenses;
+export function discoverLenses(lensDir: string): Promise<Map<string, LensConfig>> {
+  return Effect.runPromise(
+    discoverLensesEffect(lensDir).pipe(Effect.provideService(FileSystem, nodeFileSystemService)),
+  );
 }
 
-/** Get raw markdown content for a lens to pass to the reviewer agent. */
-export function getLensContent(lensDir: string, lensName: string): string | null {
-  const filePath = resolve(lensDir, `${lensName}.md`);
-  if (!existsSync(filePath)) return null;
-  return readFileSync(filePath, 'utf-8');
+export function getLensContent(lensDir: string, lensName: string): Promise<string | null> {
+  return Effect.runPromise(
+    getLensContentEffect(lensDir, lensName).pipe(
+      Effect.provideService(FileSystem, nodeFileSystemService),
+    ),
+  );
 }

package/extensions/code-reviewer/reviewer.ts

@@ -1,55 +1,48 @@
 import { platform } from 'node:os';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Effect } from 'effect';
+
 import type { DiffSource } from './diff';
+import { Executor, makeExecutorService } from './effects/exec';
 import type { LensConfig, LensResult } from './types';
 
 const isWindows = platform() === 'win32';
 
 /** Run project tools specified by a lens and collect their output. */
-async function runLensTools(
-  pi: ExtensionAPI,
+function runLensToolsEffect(
   cwd: string,
   tools: string[],
   signal?: AbortSignal,
-): Promise<Record<string, string>> {
-  const outputs: Record<string, string> = {};
+): Effect.Effect<Record<string, string>, never, Executor> {
+  return Effect.gen(function* () {
+    const executor = yield* Executor;
+    const outputs: Record<string, string> = {};
 
-  for (const tool of tools) {
-    if (signal?.aborted) break;
+    for (const tool of tools) {
+      if (signal?.aborted) break;
 
-    try {
       const [shell, shellArgs] = isWindows ? ['cmd', ['/c', tool]] : ['sh', ['-c', tool]];
-      const result = await pi.exec(shell, shellArgs, {
-        cwd,
-        timeout: 60_000,
-        signal,
-      });
-      outputs[tool] = result.stdout || result.stderr || '(no output)';
-    } catch {
-      outputs[tool] = `(tool failed or timed out: ${tool})`;
+      const result = yield* executor
+        .exec(shell, shellArgs as string[], { cwd, timeout: 60_000, signal })
+        .pipe(Effect.either);
+
+      outputs[tool] =
+        result._tag === 'Right'
+          ? result.right.stdout || result.right.stderr || '(no output)'
+          : `(tool failed or timed out: ${tool})`;
     }
-  }
 
-  return outputs;
+    return outputs;
+  });
 }
 
-/** Build the review prompt for a single lens. */
-function buildReviewPrompt(
-  lens: LensConfig,
-  lensContent: string,
-  diff: DiffSource,
-  toolOutputs: Record<string, string>,
-): string {
+/** Build the shared diff section of the review prompt (included once). */
+export function buildDiffSection(diff: DiffSource): string {
   const parts: string[] = [];
-
-  parts.push(`You are reviewing code changes through the "${lens.name}" lens.`);
-  parts.push('');
-  parts.push('## Lens Definition');
-  parts.push(lensContent);
-  parts.push('');
-  parts.push(`## Diff (${diff.label})`);
   const maxDiffLen = 50_000;
   const diffTruncated = diff.diff.length > maxDiffLen;
+
+  parts.push(`## Diff (${diff.label})`);
   parts.push('```diff');
   parts.push(diff.diff.slice(0, maxDiffLen));
   parts.push('```');
@@ -64,21 +57,60 @@ function buildReviewPrompt(
   parts.push(diff.stat);
   parts.push('```');
 
+  return parts.join('\n');
+}
+
+/** Build the lens-specific section of the review prompt (no diff duplication). */
+function buildLensSection(
+  lens: LensConfig,
+  lensContent: string,
+  toolOutputs: Record<string, string>,
+): string {
+  const parts: string[] = [];
+
+  parts.push(`### Lens: ${lens.name}`);
+  parts.push('');
+  parts.push('#### Lens Definition');
+  parts.push(lensContent);
+
   if (Object.keys(toolOutputs).length > 0) {
     parts.push('');
-    parts.push('## Tool Outputs');
+    parts.push('#### Tool Outputs');
     for (const [cmd, output] of Object.entries(toolOutputs)) {
-      parts.push(`### \`${cmd}\``);
+      parts.push(`##### \`${cmd}\``);
       parts.push('```');
       parts.push(output.slice(0, 20_000));
       parts.push('```');
     }
   }
 
+  parts.push('');
+  parts.push('#### Severity levels');
+  if (lens.severityRules.blocker) parts.push(`- **blocker**: ${lens.severityRules.blocker}`);
+  if (lens.severityRules.warning) parts.push(`- **warning**: ${lens.severityRules.warning}`);
+  if (lens.severityRules.note) parts.push(`- **note**: ${lens.severityRules.note}`);
+
+  return parts.join('\n');
+}
+
+/** Build the full review prompt for a single lens (includes diff — used by the tool path). */
+function buildReviewPrompt(
+  lens: LensConfig,
+  lensContent: string,
+  diff: DiffSource,
+  toolOutputs: Record<string, string>,
+): string {
+  const parts: string[] = [];
+
+  parts.push(`You are reviewing code changes through the "${lens.name}" lens.`);
+  parts.push('');
+  parts.push(buildDiffSection(diff));
+  parts.push('');
+  parts.push(buildLensSection(lens, lensContent, toolOutputs));
   parts.push('');
   parts.push('## Instructions');
   parts.push('');
-  parts.push('Review the diff through this lens. For each finding, output a JSON array:');
+  parts.push('Review the diff above through this lens. For each finding, output a JSON array:');
   parts.push('');
   parts.push('```json');
   parts.push('[');
@@ -88,11 +120,6 @@ function buildReviewPrompt(
   parts.push(']');
   parts.push('```');
   parts.push('');
-  parts.push('Severity levels:');
-  if (lens.severityRules.blocker) parts.push(`- **blocker**: ${lens.severityRules.blocker}`);
-  if (lens.severityRules.warning) parts.push(`- **warning**: ${lens.severityRules.warning}`);
-  if (lens.severityRules.note) parts.push(`- **note**: ${lens.severityRules.note}`);
-  parts.push('');
   parts.push(
     'After the JSON array, write a 2-3 sentence summary of your review through this lens.',
   );
@@ -101,9 +128,31 @@ function buildReviewPrompt(
   return parts.join('\n');
 }
 
-/** Execute a review for a single lens using the subagent tool. */
-export async function reviewWithLens(
-  pi: ExtensionAPI,
+/** Execute a review for a single lens: run its tools, then build the prompt. */
+export function reviewWithLensEffect(
+  cwd: string,
+  lens: LensConfig,
+  lensContent: string,
+  diff: DiffSource,
+  signal?: AbortSignal,
+): Effect.Effect<LensResult, never, Executor> {
+  return Effect.gen(function* () {
+    const toolOutputs = yield* runLensToolsEffect(cwd, lens.tools, signal);
+
+    return {
+      lens: lens.name,
+      findings: [],
+      summary: '',
+      toolOutputs,
+      _prompt: buildReviewPrompt(lens, lensContent, diff, toolOutputs),
+      _lensSection: buildLensSection(lens, lensContent, toolOutputs),
+    };
+  });
+}
+
+/** Promise wrapper building a live Executor from `pi`. */
+export function reviewWithLens(
+  pi: Pick<ExtensionAPI, 'exec'>,
   _ctx: unknown,
   cwd: string,
   lens: LensConfig,
@@ -111,20 +160,9 @@ export async function reviewWithLens(
   diff: DiffSource,
   signal?: AbortSignal,
 ): Promise<LensResult> {
-  // Run lens tools first
-  const toolOutputs = await runLensTools(pi, cwd, lens.tools, signal);
-
-  // Build the prompt
-  const prompt = buildReviewPrompt(lens, lensContent, diff, toolOutputs);
-
-  // Use sendMessage to delegate to the agent for review
-  // For now, we return the prompt and let the command handler
-  // pass it to a subagent via the subagent tool
-  return {
-    lens: lens.name,
-    findings: [],
-    summary: '',
-    toolOutputs,
-    _prompt: prompt,
-  };
+  return Effect.runPromise(
+    reviewWithLensEffect(cwd, lens, lensContent, diff, signal).pipe(
+      Effect.provideService(Executor, makeExecutorService(pi)),
+    ),
+  );
 }

package/extensions/code-reviewer/types.ts

@@ -22,6 +22,8 @@ export type LensResult = {
   toolOutputs?: Record<string, string>;
   /** Review prompt built for this lens, used internally to delegate to the agent. */
   _prompt?: string;
+  /** Lens-specific section (without diff), used by /review command to avoid diff duplication. */
+  _lensSection?: string;
 };
 
 export type ReviewConfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreki-gg/pi-code-reviewer",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Multi-lens code review extension for pi — configurable review criteria per project",
   "keywords": [
     "pi-package"
@@ -21,9 +21,10 @@
   "type": "module",
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "lint": "oxlint extensions",
-    "format": "oxfmt --write extensions",
-    "format:check": "oxfmt --check extensions"
+    "test": "bun test",
+    "lint": "oxlint extensions test",
+    "format": "oxfmt --write extensions test",
+    "format:check": "oxfmt --check extensions test"
   },
   "pi": {
     "extensions": [
@@ -33,8 +34,12 @@
       "./skills"
     ]
   },
+  "dependencies": {
+    "effect": "^3.21.2"
+  },
   "devDependencies": {
     "@types/node": "24",
+    "bun-types": "latest",
     "oxfmt": "^0.43.0",
     "oxlint": "^1.58.0",
     "typescript": "^6.0.0"