pi-diff-review 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-diff-review",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Local diff review TUI extension for pi",
   "license": "MIT",
   "repository": {
@@ -21,6 +21,7 @@
   ],
   "files": [
     "extensions",
+    "src",
     "README.md",
     "LICENSE"
   ],

package/src/diff-parser.ts

@@ -0,0 +1,410 @@
+import { parsePatchFiles } from "@pierre/diffs";
+import type {
+  ChangeContent,
+  ContextContent,
+  FileDiffMetadata,
+  Hunk,
+} from "@pierre/diffs";
+import type { ReviewLine } from "./types.ts";
+
+export function parseDiff(diffText: string): ReviewLine[] {
+  try {
+    const reviewLines = parseDiffWithPierre(diffText);
+    if (reviewLines.length > 0) return reviewLines;
+  } catch {
+    // Fall back to the local parser for any patch formats @pierre/diffs does
+    // not recognize. The review UI should remain available even if the richer
+    // parser fails on unusual diff output.
+  }
+
+  return parseDiffManual(diffText);
+}
+
+function parseDiffWithPierre(diffText: string): ReviewLine[] {
+  const patches = parsePatchFiles(diffText);
+  const parsed: ReviewLine[] = [];
+  let lineIndex = 0;
+
+  const pushLine = (line: Omit<ReviewLine, "id">) => {
+    parsed.push({ id: `line-${lineIndex++}`, ...line });
+  };
+
+  for (const patch of patches) {
+    if (patch.patchMetadata?.trim()) {
+      for (const line of patch.patchMetadata.trimEnd().split("\n")) {
+        pushLine({ kind: "meta", text: line, commentable: false });
+      }
+    }
+
+    for (const file of patch.files) {
+      appendPierreFileDiff(file, pushLine);
+    }
+  }
+
+  return parsed;
+}
+
+function appendPierreFileDiff(
+  file: FileDiffMetadata,
+  pushLine: (line: Omit<ReviewLine, "id">) => void,
+): void {
+  const previousFile =
+    file.prevName ?? (file.type === "new" ? undefined : file.name);
+  const nextFile = file.type === "deleted" ? undefined : file.name;
+  const displayPreviousFile = previousFile ?? file.name;
+  const displayNextFile = nextFile ?? file.name;
+  const currentFile = nextFile ?? previousFile ?? file.name;
+
+  pushLine({
+    kind: "meta",
+    text: `diff --git a/${displayPreviousFile} b/${displayNextFile}`,
+    filePath: currentFile,
+    commentable: false,
+  });
+
+  if (file.type === "new" && file.mode) {
+    pushLine({
+      kind: "meta",
+      text: `new file mode ${file.mode}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+  } else if (file.type === "deleted" && file.mode) {
+    pushLine({
+      kind: "meta",
+      text: `deleted file mode ${file.mode}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+  } else if (file.prevMode && file.mode && file.prevMode !== file.mode) {
+    pushLine({
+      kind: "meta",
+      text: `old mode ${file.prevMode}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+    pushLine({
+      kind: "meta",
+      text: `new mode ${file.mode}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+  }
+
+  if (file.prevObjectId && file.newObjectId) {
+    pushLine({
+      kind: "meta",
+      text: `index ${file.prevObjectId}..${file.newObjectId}${file.mode ? ` ${file.mode}` : ""}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+  }
+
+  if (file.type === "rename-pure" || file.type === "rename-changed") {
+    if (file.prevName) {
+      pushLine({
+        kind: "meta",
+        text: `rename from ${file.prevName}`,
+        filePath: currentFile,
+        commentable: false,
+      });
+    }
+    pushLine({
+      kind: "meta",
+      text: `rename to ${file.name}`,
+      filePath: currentFile,
+      commentable: false,
+    });
+  }
+
+  if (file.hunks.length === 0) return;
+
+  pushLine({
+    kind: "meta",
+    text: previousFile ? `--- a/${previousFile}` : "--- /dev/null",
+    filePath: currentFile,
+    commentable: false,
+  });
+  pushLine({
+    kind: "meta",
+    text: nextFile ? `+++ b/${nextFile}` : "+++ /dev/null",
+    filePath: currentFile,
+    commentable: false,
+  });
+
+  for (const hunk of file.hunks) {
+    appendPierreHunk(file, hunk, currentFile, pushLine);
+  }
+}
+
+function appendPierreHunk(
+  file: FileDiffMetadata,
+  hunk: Hunk,
+  currentFile: string,
+  pushLine: (line: Omit<ReviewLine, "id">) => void,
+): void {
+  const hunkLabel = hunk.hunkSpecs?.trimEnd() ?? "@@";
+  let oldLine = hunk.deletionStart;
+  let newLine = hunk.additionStart;
+  let deletionIndex = hunk.deletionLineIndex;
+  let additionIndex = hunk.additionLineIndex;
+
+  pushLine({
+    kind: "hunk",
+    text: hunkLabel,
+    filePath: currentFile,
+    commentable: false,
+    hunkLabel,
+  });
+
+  for (const content of hunk.hunkContent) {
+    if (content.type === "context") {
+      ({ oldLine, newLine, deletionIndex, additionIndex } = appendPierreContext(
+        file,
+        content,
+        currentFile,
+        hunkLabel,
+        oldLine,
+        newLine,
+        deletionIndex,
+        additionIndex,
+        pushLine,
+      ));
+    } else {
+      ({ oldLine, newLine, deletionIndex, additionIndex } = appendPierreChange(
+        file,
+        content,
+        currentFile,
+        hunkLabel,
+        oldLine,
+        newLine,
+        deletionIndex,
+        additionIndex,
+        pushLine,
+      ));
+    }
+  }
+}
+
+type PierreLineState = {
+  oldLine: number;
+  newLine: number;
+  deletionIndex: number;
+  additionIndex: number;
+};
+
+function appendPierreContext(
+  file: FileDiffMetadata,
+  content: ContextContent,
+  currentFile: string,
+  hunkLabel: string,
+  oldLine: number,
+  newLine: number,
+  deletionIndex: number,
+  additionIndex: number,
+  pushLine: (line: Omit<ReviewLine, "id">) => void,
+): PierreLineState {
+  for (let i = 0; i < content.lines; i++) {
+    const lineText =
+      file.deletionLines[deletionIndex] ??
+      file.additionLines[additionIndex] ??
+      "";
+    pushLine({
+      kind: "context",
+      text: ` ${stripLineEnding(lineText)}`,
+      filePath: currentFile,
+      oldLineNumber: oldLine,
+      newLineNumber: newLine,
+      commentable: true,
+      hunkLabel,
+    });
+    oldLine++;
+    newLine++;
+    deletionIndex++;
+    additionIndex++;
+  }
+
+  return { oldLine, newLine, deletionIndex, additionIndex };
+}
+
+function appendPierreChange(
+  file: FileDiffMetadata,
+  content: ChangeContent,
+  currentFile: string,
+  hunkLabel: string,
+  oldLine: number,
+  newLine: number,
+  deletionIndex: number,
+  additionIndex: number,
+  pushLine: (line: Omit<ReviewLine, "id">) => void,
+): PierreLineState {
+  for (let i = 0; i < content.deletions; i++) {
+    const lineText = file.deletionLines[deletionIndex] ?? "";
+    pushLine({
+      kind: "remove",
+      text: `-${stripLineEnding(lineText)}`,
+      filePath: currentFile,
+      oldLineNumber: oldLine,
+      commentable: true,
+      hunkLabel,
+    });
+    oldLine++;
+    deletionIndex++;
+  }
+
+  for (let i = 0; i < content.additions; i++) {
+    const lineText = file.additionLines[additionIndex] ?? "";
+    pushLine({
+      kind: "add",
+      text: `+${stripLineEnding(lineText)}`,
+      filePath: currentFile,
+      newLineNumber: newLine,
+      commentable: true,
+      hunkLabel,
+    });
+    newLine++;
+    additionIndex++;
+  }
+
+  return { oldLine, newLine, deletionIndex, additionIndex };
+}
+
+function stripLineEnding(text: string): string {
+  return text.replace(/\r?\n$/, "");
+}
+
+function parseDiffManual(diffText: string): ReviewLine[] {
+  const lines = diffText.split("\n");
+  const parsed: ReviewLine[] = [];
+
+  let currentFile: string | undefined;
+  let previousFile: string | undefined;
+  let nextFile: string | undefined;
+  let currentHunk: string | undefined;
+  let oldLine = 0;
+  let newLine = 0;
+  let lineIndex = 0;
+
+  for (const raw of lines) {
+    if (raw.startsWith("diff --git ")) {
+      const match = raw.match(/^diff --git a\/(.+?) b\/(.+)$/);
+      previousFile = match?.[1];
+      nextFile = match?.[2];
+      currentFile = nextFile ?? previousFile;
+      currentHunk = undefined;
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "meta",
+        text: raw,
+        filePath: currentFile,
+        commentable: false,
+      });
+      continue;
+    }
+
+    if (raw.startsWith("--- ")) {
+      previousFile =
+        raw === "--- /dev/null"
+          ? undefined
+          : raw.replace(/^--- a\//, "").replace(/^--- /, "");
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "meta",
+        text: raw,
+        filePath: currentFile,
+        commentable: false,
+      });
+      continue;
+    }
+
+    if (raw.startsWith("+++ ")) {
+      nextFile =
+        raw === "+++ /dev/null"
+          ? undefined
+          : raw.replace(/^\+\+\+ b\//, "").replace(/^\+\+\+ /, "");
+      currentFile = nextFile ?? previousFile;
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "meta",
+        text: raw,
+        filePath: currentFile,
+        commentable: false,
+      });
+      continue;
+    }
+
+    if (raw.startsWith("@@")) {
+      const match = raw.match(
+        /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/,
+      );
+      if (match) {
+        oldLine = Number(match[1]);
+        newLine = Number(match[3]);
+      }
+      currentHunk = raw;
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "hunk",
+        text: raw,
+        filePath: currentFile,
+        commentable: false,
+        hunkLabel: currentHunk,
+      });
+      continue;
+    }
+
+    if (raw.startsWith("+") && !raw.startsWith("+++")) {
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "add",
+        text: raw,
+        filePath: currentFile,
+        newLineNumber: newLine,
+        commentable: Boolean(currentFile),
+        hunkLabel: currentHunk,
+      });
+      newLine++;
+      continue;
+    }
+
+    if (raw.startsWith("-") && !raw.startsWith("---")) {
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "remove",
+        text: raw,
+        filePath: currentFile,
+        oldLineNumber: oldLine,
+        commentable: Boolean(currentFile),
+        hunkLabel: currentHunk,
+      });
+      oldLine++;
+      continue;
+    }
+
+    if (raw.startsWith(" ")) {
+      parsed.push({
+        id: `line-${lineIndex++}`,
+        kind: "context",
+        text: raw,
+        filePath: currentFile,
+        oldLineNumber: oldLine,
+        newLineNumber: newLine,
+        commentable: Boolean(currentFile),
+        hunkLabel: currentHunk,
+      });
+      oldLine++;
+      newLine++;
+      continue;
+    }
+
+    parsed.push({
+      id: `line-${lineIndex++}`,
+      kind: "meta",
+      text: raw,
+      filePath: currentFile,
+      commentable: false,
+    });
+  }
+
+  return parsed;
+}

package/src/diff-source.ts

@@ -0,0 +1,32 @@
+import { execFileSync } from "node:child_process";
+import type { DiffSource } from "./types.ts";
+
+export function parseDiffSource(args: string): DiffSource {
+  const trimmed = args.trim();
+  if (!trimmed) {
+    return {
+      label: "unstaged git diff",
+      promptLabel: "the current unstaged git diff",
+      args: [],
+    };
+  }
+
+  const gitArgs = trimmed.split(/\s+/).filter(Boolean);
+  return {
+    label: `git diff ${trimmed}`,
+    promptLabel: `\`git diff ${trimmed}\``,
+    args: gitArgs,
+  };
+}
+
+export function getDiff(cwd: string, source: DiffSource): string {
+  return execFileSync(
+    "git",
+    ["diff", "--no-color", "--unified=3", ...source.args],
+    {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+}

package/src/index.ts

@@ -0,0 +1,56 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@mariozechner/pi-coding-agent";
+import { getDiff, parseDiffSource } from "./diff-source.ts";
+import { parseDiff } from "./diff-parser.ts";
+import { buildReviewPrompt } from "./prompt.ts";
+import { ReviewComponent } from "./review-component.ts";
+import type { ReviewComment, ReviewResult } from "./types.ts";
+
+export function registerDiffReviewCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("diff", {
+    description: "Review a git diff in a custom TUI (/diff [git diff args])",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      const source = parseDiffSource(args);
+      let diffText: string;
+      try {
+        diffText = getDiff(ctx.cwd, source);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Unable to read ${source.label}: ${message}`, "error");
+        return;
+      }
+
+      if (!diffText.trim()) {
+        ctx.ui.notify(`No changes to review for ${source.label}.`, "info");
+        return;
+      }
+
+      const reviewLines = parseDiff(diffText);
+      const result = await ctx.ui.custom<ReviewResult>(
+        (tui, theme, _keybindings, done) => {
+          const comments = new Map<string, ReviewComment>();
+          return new ReviewComponent(
+            tui,
+            theme,
+            source.label,
+            reviewLines,
+            comments,
+            done,
+          );
+        },
+      );
+
+      if (!result || result.action !== "submit") return;
+      if (result.comments.length === 0) {
+        ctx.ui.notify("No review comments to send.", "info");
+        return;
+      }
+
+      pi.sendUserMessage(
+        buildReviewPrompt(result.comments, source.promptLabel),
+      );
+    },
+  });
+}

package/src/prompt.ts

@@ -0,0 +1,49 @@
+import type { ReviewComment } from "./types.ts";
+
+export function formatLocation(line: {
+  filePath?: string;
+  oldLineNumber?: number;
+  newLineNumber?: number;
+}): string {
+  const file = line.filePath ?? "(unknown file)";
+  if (line.oldLineNumber != null && line.newLineNumber != null) {
+    if (line.oldLineNumber === line.newLineNumber) {
+      return `${file}:${line.newLineNumber}`;
+    }
+    return `${file}:old:${line.oldLineNumber}/new:${line.newLineNumber}`;
+  }
+  if (line.newLineNumber != null) return `${file}:new:${line.newLineNumber}`;
+  if (line.oldLineNumber != null) return `${file}:old:${line.oldLineNumber}`;
+  return file;
+}
+
+function formatCommentLocation(comment: ReviewComment): string {
+  const start = formatLocation({
+    filePath: comment.filePath,
+    oldLineNumber: comment.startOldLineNumber,
+    newLineNumber: comment.startNewLineNumber,
+  });
+  const end = formatLocation({
+    filePath: comment.filePath,
+    oldLineNumber: comment.endOldLineNumber,
+    newLineNumber: comment.endNewLineNumber,
+  });
+  return start === end ? start : `${start} -> ${end}`;
+}
+
+export function buildReviewPrompt(
+  comments: ReviewComment[],
+  promptLabel: string,
+): string {
+  const body = comments
+    .map((comment) => {
+      const location = formatCommentLocation(comment);
+      const excerpt = comment.lineText.trim()
+        ? `\n  Excerpt:\n\n\`\`\`diff\n${comment.lineText}\n\`\`\``
+        : "";
+      return `- \`${location}\` — ${comment.text}${excerpt}`;
+    })
+    .join("\n");
+
+  return `Address this local code review feedback for ${promptLabel}.\n\n## Review comments\n${body}\n\nPlease apply the feedback and summarize what changed.`;
+}