@dreki-gg/pi-code-reviewer 0.7.0 → 0.8.0

package/README.md

@@ -30,10 +30,28 @@ This creates:
 /review --lens quality,ux        # Multiple lenses
 /review --base main              # Diff against a branch
 /review --staged                 # Only staged changes
+/review --repo ../project-pr35    # Review a worktree / sibling repo
 /review-lenses                   # List available lenses
 ```
 
-The `code_review` tool is also available for programmatic use by the agent.
+### Reviewing worktrees & other repos (`--repo`)
+
+By default `/review` runs git against the Pi session directory. Pass `--repo <dir>`
+(alias `--cwd <dir>`) to target a different directory — a git worktree (sibling or
+nested) or another repo — without leaving the session:
+
+```
+/review --repo /path/to/worktree --base HEAD~1 --lens code-quality,architecture
+```
+
+- The path is resolved relative to the session directory and validated as a git
+  work tree (relative paths like `../project-pr35` work).
+- `.code-review.json`, lenses, and recorded rejections all resolve relative to the
+  override directory.
+- The session directory itself is left unchanged — only git/config/lens resolution
+  is redirected.
+
+The `code_review` tool exposes the same override via its optional `cwd` parameter.
 
 ## How the review runs (Bugbot-style pipeline)
 

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

@@ -7,6 +7,7 @@ import { Type } from 'typebox';
 import { loadConfig, getLensDir } from '../config';
 import { collectDiff, getChangedFiles } from '../diff';
 import { discoverLenses, getLensContent } from '../lenses';
+import { resolveRepoCwd } from '../resolve-cwd';
 import { resolveModelPlan } from '../model-plan';
 import { runPipeline } from '../passes';
 import {
@@ -72,10 +73,29 @@ export function registerReviewTool(pi: ExtensionAPI) {
           description: 'Review only staged changes instead of all working directory changes.',
         }),
       ),
+      cwd: Type.Optional(
+        Type.String({
+          description:
+            'Override directory for git/config/lens resolution (e.g. a worktree or sibling repo). Resolved relative to the session directory and validated as a git work tree. The session directory is left unchanged.',
+        }),
+      ),
     }),
 
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      const cwd = ctx.cwd;
+      let cwd: string;
+      try {
+        cwd = await resolveRepoCwd(pi, ctx.cwd, params.cwd);
+      } catch (cause) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `cwd "${params.cwd}" is not a git work tree (${cause instanceof Error ? cause.message : String(cause)}).`,
+            },
+          ],
+          details: {},
+        };
+      }
       const config = await loadConfig(cwd);
       const lensDir = getLensDir(cwd, config);
       const available = await discoverLenses(lensDir);

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

@@ -14,13 +14,29 @@ import {
   runTools,
 } from '../reviewer';
 import { parseReviewArgs } from '../parse-args';
+import { resolveRepoCwd } from '../resolve-cwd';
 
 export function registerReviewCommand(pi: ExtensionAPI) {
   pi.registerCommand('review', {
     description:
-      'Run a multi-lens code review on working directory changes. Usage: /review [--lens name,...] [--base ref] [--staged]',
+      'Run a multi-lens code review on working directory changes. Usage: /review [--lens name,...] [--base ref] [--staged] [--repo dir]',
     handler: async (args, ctx) => {
-      const cwd = ctx.cwd;
+      const parsed = parseReviewArgs(args ?? '');
+
+      // Override directory for git/config/lens resolution (worktrees, sibling
+      // repos). Resolved relative to the session CWD and validated; the session
+      // CWD itself is left unchanged.
+      let cwd: string;
+      try {
+        cwd = await resolveRepoCwd(pi, ctx.cwd, parsed.repo);
+      } catch (cause) {
+        ctx.ui.notify(
+          `--repo ${parsed.repo} is not a git work tree (${cause instanceof Error ? cause.message : String(cause)})`,
+          'error',
+        );
+        return;
+      }
+
       const config = await loadConfig(cwd);
       const lensDir = getLensDir(cwd, config);
       const available = await discoverLenses(lensDir);
@@ -33,7 +49,6 @@ export function registerReviewCommand(pi: ExtensionAPI) {
         return;
       }
 
-      const parsed = parseReviewArgs(args ?? '');
       const lensNames = resolveLensNames(parsed.lenses, config.defaultLenses, available, (msg) =>
         ctx.ui.notify(msg, 'warning'),
       );

package/extensions/code-reviewer/parse-args.ts

@@ -3,10 +3,13 @@ export function parseReviewArgs(args: string): {
   lenses: string[];
   base?: string;
   staged: boolean;
+  /** Override directory for git operations (--repo, alias --cwd). */
+  repo?: string;
 } {
   const lenses: string[] = [];
   let base: string | undefined;
   let staged = false;
+  let repo: string | undefined;
 
   const parts = args.split(/\s+/).filter(Boolean);
 
@@ -18,8 +21,10 @@ export function parseReviewArgs(args: string): {
       base = parts[++i];
     } else if (part === '--staged') {
       staged = true;
+    } else if ((part === '--repo' || part === '--cwd') && i + 1 < parts.length) {
+      repo = parts[++i];
     }
   }
 
-  return { lenses, base, staged };
+  return { lenses, base, staged, repo };
 }

package/extensions/code-reviewer/resolve-cwd.ts

@@ -0,0 +1,52 @@
+/**
+ * Resolve the directory git operations should target.
+ *
+ * `/review` and the `code_review` tool default to the Pi session CWD, but a
+ * `--repo` / `--cwd` override (or tool `cwd` param) lets a worktree or sibling
+ * repo be reviewed from the same session. The override is resolved relative to
+ * the session CWD (so relative worktree paths like `../project-pr35` work) and
+ * validated with a single `git rev-parse --is-inside-work-tree` — that one call
+ * rejects both a missing directory and a non-git path. The session CWD itself is
+ * never mutated; this only redirects git/config/lens/rejections resolution.
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Effect } from 'effect';
+import { resolve } from 'node:path';
+
+import { Executor, makeExecutorService } from './effects/exec';
+import type { ExecError } from './errors';
+
+const GIT_TIMEOUT_MS = 30_000;
+
+export function resolveRepoCwdEffect(
+  sessionCwd: string,
+  override?: string,
+): Effect.Effect<string, ExecError, Executor> {
+  return Effect.gen(function* () {
+    if (!override) return sessionCwd;
+    const resolved = resolve(sessionCwd, override);
+    const executor = yield* Executor;
+    // Throws ExecError when the path is missing or not a git work tree; the
+    // caller maps that to a user-facing notice rather than silently falling
+    // back to the session CWD.
+    yield* executor.exec('git', ['rev-parse', '--is-inside-work-tree'], {
+      cwd: resolved,
+      timeout: GIT_TIMEOUT_MS,
+    });
+    return resolved;
+  });
+}
+
+/** Promise wrapper: resolve + validate the repo cwd with a live Executor from `pi`. */
+export function resolveRepoCwd(
+  pi: Pick<ExtensionAPI, 'exec'>,
+  sessionCwd: string,
+  override?: string,
+): Promise<string> {
+  return Effect.runPromise(
+    resolveRepoCwdEffect(sessionCwd, override).pipe(
+      Effect.provideService(Executor, makeExecutorService(pi)),
+    ),
+  );
+}

package/package.json

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