@plannotator/pi-extension 0.19.10 → 0.19.11

package/generated/agent-review-message.ts

@@ -0,0 +1,148 @@
+// @generated — DO NOT EDIT. Source: packages/server/agent-review-message.ts
+import {
+  JJ_TRUNK_REVSET,
+  jjLineBaseRevset,
+  parseWorktreeDiffType,
+  type DiffType,
+} from "./review-core.js";
+import type { PRMetadata } from "./pr-provider.js";
+
+export interface AgentReviewUserMessageOptions {
+  defaultBranch?: string;
+  hasLocalAccess?: boolean;
+  prDiffScope?: string;
+}
+
+export interface LocalDiffInstruction {
+  target: string;
+  inspect: string;
+}
+
+/** Build the dynamic user message shared by local Claude and Codex review jobs. */
+export function buildAgentReviewUserMessage(
+  patch: string,
+  diffType: DiffType,
+  options?: AgentReviewUserMessageOptions,
+  prMetadata?: PRMetadata,
+): string {
+  if (prMetadata) {
+    if (options?.prDiffScope === "full-stack") {
+      return [
+        `Full-stack review of ${prMetadata.url}`,
+        "",
+        "This is a stacked PR. The diff below shows ALL accumulated changes from the repository default branch through this PR's head (not just this PR's own layer).",
+        "Review the complete diff for issues that span the stack.",
+        "",
+        "```diff",
+        patch,
+        "```",
+      ].join("\n");
+    }
+    if (options?.hasLocalAccess) {
+      return [
+        prMetadata.url,
+        "",
+        "You are in a local worktree checked out at the PR head. The code is available locally.",
+        `To see the PR changes, diff against the remote base branch: git diff origin/${prMetadata.baseBranch}...HEAD`,
+        "Do NOT diff against the local `main` branch; it may be stale. Always use origin/.",
+      ].join("\n");
+    }
+    return prMetadata.url;
+  }
+
+  const instruction = getLocalDiffInstruction(diffType, options?.defaultBranch);
+  if (instruction) {
+    return `Review ${instruction.target}. ${instruction.inspect} Provide prioritized, actionable findings.`;
+  }
+
+  return [
+    "Review the following code changes and provide prioritized findings.",
+    "",
+    "```diff",
+    patch,
+    "```",
+  ].join("\n");
+}
+
+export function getLocalDiffInstruction(
+  diffType: DiffType,
+  defaultBranch?: string,
+): LocalDiffInstruction | null {
+  const effectiveDiffType = normalizeLocalDiffType(diffType);
+
+  switch (effectiveDiffType) {
+    case "uncommitted":
+      return {
+        target: "the current code changes (staged, unstaged, and untracked files)",
+        inspect: "Inspect the working tree changes locally.",
+      };
+    case "staged":
+      return {
+        target: "the currently staged code changes",
+        inspect: "Run `git diff --staged` to inspect the changes.",
+      };
+    case "unstaged":
+      return {
+        target: "the unstaged code changes (tracked modifications and untracked files)",
+        inspect: "Inspect the unstaged working tree changes locally.",
+      };
+    case "last-commit":
+      return {
+        target: "the code changes introduced in the last commit",
+        inspect: "Run `git diff HEAD~1..HEAD` to inspect the changes.",
+      };
+    case "branch": {
+      const base = defaultBranch || "main";
+      return {
+        target: `the code changes against the base branch '${base}'`,
+        inspect: `Run \`git diff ${base}..HEAD\` to inspect the changes.`,
+      };
+    }
+    case "merge-base": {
+      const base = defaultBranch || "main";
+      return {
+        target: `the PR-style diff against base '${base}'`,
+        inspect: `First find the common ancestor with \`git merge-base ${base} HEAD\`, then run \`git diff <merge-base>..HEAD\` using that commit to inspect only the changes introduced on this branch (matches GitHub's PR view).`,
+      };
+    }
+    case "all":
+      return {
+        target: "every file in the repository",
+        inspect: "All files are shown as additions, diffed against an empty tree.",
+      };
+    case "jj-current":
+      return {
+        target: "the current JJ change",
+        inspect: "Run `jj diff --git -r @` to inspect the changes.",
+      };
+    case "jj-last":
+      return {
+        target: "the previous JJ change",
+        inspect: "Run `jj diff --git -r @-` to inspect the changes.",
+      };
+    case "jj-line": {
+      const base = defaultBranch || JJ_TRUNK_REVSET;
+      const baseRevset = jjLineBaseRevset(base);
+      return {
+        target: `the JJ line of work against \`${base}\``,
+        inspect: `Run \`jj diff --git --from ${shellQuote(baseRevset)} --to @\` to inspect the changes.`,
+      };
+    }
+    case "jj-all":
+      return {
+        target: "all files in the JJ workspace",
+        inspect: "Run `jj diff --git --from 'root()' --to @` to inspect the changes.",
+      };
+    default:
+      return null;
+  }
+}
+
+function normalizeLocalDiffType(diffType: DiffType): string {
+  const worktree = parseWorktreeDiffType(diffType);
+  return worktree?.subType ?? diffType;
+}
+
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}

package/generated/claude-review.ts

@@ -89,7 +89,7 @@ project guidance files explicitly expand your scope.
 ## Pipeline
 
 Step 1: Gather context
-  - Retrieve the PR diff (gh pr diff or git diff)
+  - Retrieve the PR diff or local diff (gh pr diff, git diff, or jj diff)
   - Read CLAUDE.md and REVIEW.md at the repo root and in every directory
     containing modified files
   - Build a map of which rules apply to which file paths
@@ -207,6 +207,10 @@ export function buildClaudeCommand(prompt: string, model: string = "claude-opus-
     "Bash(git grep:*)", "Bash(git ls-remote:*)", "Bash(git ls-tree:*)",
     "Bash(git merge-base:*)", "Bash(git remote:*)", "Bash(git rev-parse:*)",
     "Bash(git show-ref:*)",
+    // JJ (read-only)
+    "Bash(jj status:*)", "Bash(jj diff:*)", "Bash(jj log:*)",
+    "Bash(jj show:*)", "Bash(jj file show:*)", "Bash(jj cat:*)",
+    "Bash(jj bookmark list:*)",
     "Bash(wc:*)",
   ].join(",");
 

package/generated/codex-review.ts

@@ -10,8 +10,6 @@ import { join } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { appendFile, mkdir, unlink, writeFile, readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import type { DiffType } from "./review-core.js";
-import type { PRMetadata } from "./pr-provider.js";
 import { toRelativePath } from "./path-utils.js";
 
 // ---------------------------------------------------------------------------
@@ -159,86 +157,6 @@ Ignore non-blocking issues such as style, formatting, typos, documentation, and
 FORMATTING GUIDELINES:
 The finding description should be one paragraph.`;
 
-// ---------------------------------------------------------------------------
-// User message builder
-// ---------------------------------------------------------------------------
-
-/** Build the dynamic user message based on review context. */
-export function buildCodexReviewUserMessage(
-  patch: string,
-  diffType: DiffType,
-  options?: { defaultBranch?: string; hasLocalAccess?: boolean; prDiffScope?: string },
-  prMetadata?: PRMetadata,
-): string {
-  // PR/MR mode — pass the link, with local context if --local
-  if (prMetadata) {
-    if (options?.prDiffScope === "full-stack") {
-      return [
-        `Full-stack review of ${prMetadata.url}`,
-        "",
-        "This is a stacked PR. The diff below shows ALL accumulated changes from the repository default branch through this PR's head (not just this PR's own layer).",
-        "Review the complete diff for issues that span the stack.",
-        "",
-        "```diff",
-        patch,
-        "```",
-      ].join("\n");
-    }
-    if (options?.hasLocalAccess) {
-      return [
-        prMetadata.url,
-        "",
-        "You are in a local worktree checked out at the PR head. The code is available locally.",
-        `To see the PR changes, diff against the remote base branch: git diff origin/${prMetadata.baseBranch}...HEAD`,
-        "Do NOT diff against the local `main` branch — it may be stale. Always use origin/.",
-      ].join("\n");
-    }
-    return prMetadata.url;
-  }
-
-  // Local mode — Codex has full file/git access
-  const effectiveDiffType = diffType.startsWith("worktree:")
-    ? diffType.split(":").pop() || "uncommitted"
-    : diffType;
-
-  switch (effectiveDiffType) {
-    case "uncommitted":
-      return "Review the current code changes (staged, unstaged, and untracked files) and provide prioritized findings.";
-
-    case "staged":
-      return "Review the currently staged code changes (`git diff --staged`) and provide prioritized findings.";
-
-    case "unstaged":
-      return "Review the unstaged code changes (tracked modifications and untracked files) and provide prioritized findings.";
-
-    case "last-commit":
-      return "Review the code changes introduced in the last commit (`git diff HEAD~1..HEAD`) and provide prioritized findings.";
-
-    case "branch": {
-      const base = options?.defaultBranch || "main";
-      return `Review the code changes against the base branch '${base}'. Run \`git diff ${base}..HEAD\` to inspect the changes. Provide prioritized, actionable findings.`;
-    }
-
-    case "merge-base": {
-      const base = options?.defaultBranch || "main";
-      return `Review the PR-style diff against base '${base}'. First find the common ancestor with \`git merge-base ${base} HEAD\`, then run \`git diff <merge-base>..HEAD\` using that commit to inspect only the changes introduced on this branch (matches GitHub's PR view). Provide prioritized, actionable findings.`;
-    }
-
-    case "all":
-      return "Review every file in the repository (all files shown as additions, diffed against an empty tree). Provide prioritized, actionable findings.";
-
-    default:
-      // p4 or unknown — fall back to generic with inlined diff
-      return [
-        "Review the following code changes and provide prioritized findings.",
-        "",
-        "```diff",
-        patch,
-        "```",
-      ].join("\n");
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Command builder
 // ---------------------------------------------------------------------------

package/generated/jj-core.ts

@@ -0,0 +1,329 @@
+// @generated — DO NOT EDIT. Source: packages/shared/jj-core.ts
+import { basename } from "node:path";
+import {
+  type DiffResult,
+  type DiffType,
+  type GitCommandResult,
+  type GitContext,
+  type GitDiffOptions,
+  JJ_TRUNK_REVSET,
+  jjLineBaseRevset,
+  validateFilePath,
+} from "./review-core";
+
+export {
+  JJ_TRUNK_REVSET,
+  jjCompareTargetRevset,
+  jjLineBaseRevset,
+  parseRemoteBookmark,
+} from "./review-core";
+
+export interface ReviewJjRuntime {
+  runJj: (
+    args: string[],
+    options?: { cwd?: string; timeoutMs?: number },
+  ) => Promise<GitCommandResult>;
+}
+
+export async function detectJjWorkspace(
+  runtime: ReviewJjRuntime,
+  cwd?: string,
+): Promise<string | null> {
+  const result = await runtime.runJj(["workspace", "root"], { cwd });
+  return result.exitCode === 0 ? result.stdout.trim() || null : null;
+}
+
+export async function getJjContext(
+  runtime: ReviewJjRuntime,
+  cwd?: string,
+): Promise<GitContext> {
+  const root = await detectJjWorkspace(runtime, cwd);
+  const targets = await listJjCompareTargets(runtime, root ?? cwd);
+  const defaultTarget = selectDefaultJjCompareTarget(targets);
+  const contextCwd = root ?? cwd;
+
+  return {
+    currentBranch: "",
+    defaultBranch: defaultTarget,
+    diffOptions: [
+      { id: "jj-current", label: "Current change" },
+      { id: "jj-last", label: "Last change" },
+      { id: "jj-line", label: "Line of work" },
+      { id: "jj-all", label: "All files" },
+    ],
+    worktrees: [],
+    availableBranches: targets,
+    compareTarget: {
+      diffTypes: ["jj-line"],
+      fallback: defaultTarget,
+      picker: {
+        rowLabel: "from revision",
+        triggerLabel: "revision",
+        triggerTitlePrefix: "Compare against",
+        searchPlaceholder: "Search bookmarks...",
+        emptyText: "No bookmarks match.",
+        localGroupLabel: "Bookmarks",
+        remoteGroupLabel: "Remote bookmarks",
+      },
+    },
+    repository: contextCwd ? { displayFallback: basename(contextCwd) } : undefined,
+    cwd: contextCwd,
+    vcsType: "jj",
+  };
+}
+
+export async function runJjDiff(
+  runtime: ReviewJjRuntime,
+  diffType: DiffType,
+  defaultBranch: string,
+  cwd?: string,
+  options?: GitDiffOptions,
+): Promise<DiffResult> {
+  const compareTarget = defaultBranch.length > 0 ? defaultBranch : JJ_TRUNK_REVSET;
+  const args = getJjDiffArgs(diffType, compareTarget, options);
+  if (!args) return { patch: "", label: "Unknown diff type" };
+
+  const result = await runtime.runJj(args.args, { cwd });
+  if (result.exitCode !== 0) {
+    return { patch: "", label: args.label, error: firstErrorLine(result.stderr) };
+  }
+
+  const patch = options?.hideWhitespace ? dropHunklessGitDiffChunks(result.stdout) : result.stdout;
+  return { patch, label: args.label };
+}
+
+function dropHunklessGitDiffChunks(patch: string): string {
+  if (!patch.includes("diff --git ")) return patch;
+
+  const chunks = patch.split(/^diff --git /m);
+  const prefix = chunks.shift() ?? "";
+  const filtered = chunks
+    .filter(hasReviewableGitDiffChunk)
+    .map((chunk) => `diff --git ${chunk}`)
+    .join("");
+
+  return `${prefix}${filtered}`;
+}
+
+function hasReviewableGitDiffChunk(chunk: string): boolean {
+  if (/^@@@? /m.test(chunk)) return true;
+  return /^(new file mode|deleted file mode|old mode|new mode|rename from|rename to|copy from|copy to|GIT binary patch|Binary files |similarity index|dissimilarity index)/m.test(chunk);
+}
+
+export async function getJjFileContentsForDiff(
+  runtime: ReviewJjRuntime,
+  diffType: DiffType,
+  defaultBranch: string,
+  filePath: string,
+  oldPath?: string,
+  cwd?: string,
+): Promise<{ oldContent: string | null; newContent: string | null }> {
+  validateFilePath(filePath);
+  if (oldPath) validateFilePath(oldPath);
+
+  const oldFilePath = oldPath === undefined || oldPath.length === 0 ? filePath : oldPath;
+  const root = await detectJjWorkspace(runtime, cwd);
+  const fileCwd = root ?? cwd;
+
+  switch (diffType) {
+    case "jj-current":
+      return {
+        oldContent: await jjFileContent(runtime, "@-", oldFilePath, fileCwd),
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd),
+      };
+    case "jj-last": {
+      const parentRev = await resolveJjParent(runtime, "@-", fileCwd);
+      return {
+        oldContent: parentRev ? await jjFileContent(runtime, parentRev, oldFilePath, fileCwd) : null,
+        newContent: await jjFileContent(runtime, "@-", filePath, fileCwd),
+      };
+    }
+    case "jj-line": {
+      const compareTarget = defaultBranch.length > 0 ? defaultBranch : JJ_TRUNK_REVSET;
+      return {
+        oldContent: await jjFileContent(runtime, jjLineBaseRevset(compareTarget), oldFilePath, fileCwd),
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd),
+      };
+    }
+    case "jj-all":
+      return {
+        oldContent: null,
+        newContent: await jjFileContent(runtime, "@", filePath, fileCwd),
+      };
+    default:
+      return { oldContent: null, newContent: null };
+  }
+}
+
+export function getJjDiffArgs(
+  diffType: DiffType,
+  compareTarget: string,
+  options?: GitDiffOptions,
+): { args: string[]; label: string } | null {
+  const whitespaceArgs = options?.hideWhitespace ? ["-w"] : [];
+
+  switch (diffType) {
+    case "jj-current":
+      return { args: ["diff", "--git", ...whitespaceArgs, "-r", "@"], label: "Current change" };
+    case "jj-last":
+      return { args: ["diff", "--git", ...whitespaceArgs, "-r", "@-"], label: "Last change" };
+    case "jj-line":
+      return {
+        args: ["diff", "--git", ...whitespaceArgs, "--from", jjLineBaseRevset(compareTarget), "--to", "@"],
+        label: `Line of work vs ${compareTarget}`,
+      };
+    case "jj-all":
+      return { args: ["diff", "--git", ...whitespaceArgs, "--from", "root()", "--to", "@"], label: "All files" };
+    default:
+      return null;
+  }
+}
+
+export function selectDefaultJjCompareTarget(targets: { local: string[]; remote: string[] }): string {
+  const preferredNames = ["main", "develop", "master", "trunk"];
+  for (const name of preferredNames) {
+    const preferredRemote = [
+      `${name}@origin`,
+      `${name}@upstream`,
+      `${name}@git`,
+      ...targets.remote.filter((target) => target.startsWith(`${name}@`)).sort(),
+    ].find((target) => targets.remote.includes(target));
+    if (preferredRemote) return preferredRemote;
+
+    if (targets.local.includes(name)) return name;
+  }
+
+  // `trunk()` honors JJ's repository default bookmark/remote and user aliases
+  // when the repository has no obvious default bookmark to compare against.
+  return JJ_TRUNK_REVSET;
+}
+
+async function listJjCompareTargets(
+  runtime: ReviewJjRuntime,
+  cwd?: string,
+): Promise<{ local: string[]; remote: string[] }> {
+  const [localResult, remoteResult] = await Promise.all([
+    runtime.runJj([
+      "bookmark",
+      "list",
+      "--sort",
+      "committer-date-",
+      "--sort",
+      "name",
+      "-T",
+      "if(remote, '', if(present, json(name) ++ '\\n', ''))",
+    ], { cwd }),
+    runtime.runJj([
+      "bookmark",
+      "list",
+      "--all-remotes",
+      "--sort",
+      "committer-date-",
+      "--sort",
+      "name",
+      "-T",
+      "if(remote, if(present, json(name) ++ '\\t' ++ json(remote) ++ '\\n', ''), '')",
+    ], { cwd }),
+  ]);
+
+  const local = localResult.exitCode === 0 ? parseJjBookmarkList(localResult.stdout) : [];
+  const remote = remoteResult.exitCode === 0 ? parseJjRemoteBookmarkList(remoteResult.stdout) : [];
+
+  return {
+    local,
+    remote,
+  };
+}
+
+export function parseJjBookmarkList(stdout: string): string[] {
+  const seen = new Set<string>();
+  const bookmarks: string[] = [];
+
+  for (const rawLine of splitJjTemplateRecords(stdout)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const bookmark = parseSerializedJjString(line);
+    if (!bookmark || seen.has(bookmark)) continue;
+
+    seen.add(bookmark);
+    bookmarks.push(bookmark);
+  }
+
+  return bookmarks;
+}
+
+export function parseJjRemoteBookmarkList(stdout: string): string[] {
+  const seen = new Set<string>();
+  const bookmarks: string[] = [];
+
+  for (const rawLine of splitJjTemplateRecords(stdout)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const fields = splitJjTemplateFields(line);
+    if (!fields) continue;
+
+    const [nameField, remoteField] = fields;
+    const name = parseSerializedJjString(nameField);
+    const remote = parseSerializedJjString(remoteField);
+    if (!name || !remote) continue;
+
+    const bookmark = `${name}@${remote}`;
+    if (seen.has(bookmark)) continue;
+
+    seen.add(bookmark);
+    bookmarks.push(bookmark);
+  }
+
+  return bookmarks;
+}
+
+function splitJjTemplateRecords(stdout: string): string[] {
+  return stdout.split(/\n|\\n/g);
+}
+
+function splitJjTemplateFields(line: string): [string, string] | null {
+  const literalTab = line.indexOf("\t");
+  if (literalTab !== -1) return [line.slice(0, literalTab), line.slice(literalTab + 1)];
+
+  const escapedTab = line.indexOf("\\t");
+  if (escapedTab !== -1) return [line.slice(0, escapedTab), line.slice(escapedTab + 2)];
+
+  return null;
+}
+
+function parseSerializedJjString(value: string): string | null {
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+async function jjFileContent(
+  runtime: ReviewJjRuntime,
+  rev: string,
+  filePath: string,
+  cwd?: string,
+): Promise<string | null> {
+  const result = await runtime.runJj(["file", "show", "-r", rev, "--", filePath], { cwd });
+  return result.exitCode === 0 ? result.stdout : null;
+}
+
+async function resolveJjParent(
+  runtime: ReviewJjRuntime,
+  rev: string,
+  cwd?: string,
+): Promise<string | null> {
+  const result = await runtime.runJj(["log", "-r", rev, "--no-graph", "-T", "parents.map(|p| p.change_id()).join(' ')", "--limit", "1"], { cwd });
+  const parent = result.stdout.trim().split(/\s+/).find(Boolean);
+  return result.exitCode === 0 && parent ? parent : null;
+}
+
+function firstErrorLine(stderr: string): string | undefined {
+  const line = stderr.split("\n").find((value) => value.trim().length > 0)?.trim();
+  if (!line) return undefined;
+  return line.length > 200 ? line.slice(0, 200) + "..." : line;
+}

package/generated/review-args.ts

@@ -0,0 +1,86 @@
+// @generated — DO NOT EDIT. Source: packages/shared/review-args.ts
+import type { VcsSelection } from "./vcs-core";
+import { stripWrappingQuotes } from "./resolve-file";
+
+export interface ParsedReviewArgs {
+  prUrl?: string;
+  vcsType?: VcsSelection;
+  useLocal: boolean;
+}
+
+export function parseReviewArgs(input: string | string[]): ParsedReviewArgs {
+  const tokens = Array.isArray(input)
+    ? input.map((token) => stripWrappingQuotes(token.trim())).filter(Boolean)
+    : tokenizeReviewArgs(input ?? "");
+
+  let vcsType: VcsSelection | undefined;
+  let useLocal = true;
+  const positional: string[] = [];
+
+  for (const token of tokens) {
+    switch (token) {
+      case "--git":
+        vcsType = "git";
+        break;
+      case "--local":
+        useLocal = true;
+        break;
+      case "--no-local":
+        useLocal = false;
+        break;
+      default:
+        positional.push(token);
+        break;
+    }
+  }
+
+  const target = positional[0];
+  return {
+    prUrl: target && isReviewUrl(target) ? target : undefined,
+    vcsType,
+    useLocal,
+  };
+}
+
+function isReviewUrl(value: string): boolean {
+  return value.startsWith("http://") || value.startsWith("https://");
+}
+
+function tokenizeReviewArgs(input: string): string[] {
+  const raw = input.trim();
+  if (!raw) return [];
+
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | "\"" | undefined;
+
+  for (let i = 0; i < raw.length; i++) {
+    const char = raw[i];
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === "'" || char === "\"") {
+      quote = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) tokens.push(current);
+  return tokens.map((token) => stripWrappingQuotes(token.trim())).filter(Boolean);
+}