git-reviewer 2.1.0 → 2.2.0

package/README.md

@@ -3,7 +3,7 @@
 [![CI](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml/badge.svg)](https://github.com/dheerajjha/reviewer/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-brightgreen.svg)](package.json)
-[![Tests](https://img.shields.io/badge/tests-196-brightgreen.svg)](test/)
+[![Tests](https://img.shields.io/badge/tests-206-brightgreen.svg)](test/)
 [![Dependencies](https://img.shields.io/badge/dependencies-3-brightgreen.svg)](package.json)
 
 ![Plain grey code lines on the left resolving into colored diff stripes, with threaded comment markers attached in the right margin](docs/banner.jpg)
@@ -239,7 +239,7 @@ rather than a public issue.
 
 ```bash
 npm install           # 3 dependencies, no build step, ~6MB
-npm test              # 196 tests
+npm test              # 206 tests
 npm run test:watch
 npm run test:coverage
 ```

package/lib/agent.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const path = require('path');
 const { groupByFile } = require('./comments');
 const { fence, repoSlug } = require('./review');
 
@@ -66,10 +67,43 @@ function buildReviewDocument({ repoPath, comments, generatedAt, head = null, bra
       comments: comments.length,
       files: grouped.length
     },
-    comments: grouped.flatMap(([, fileComments]) => fileComments.map(toAgentComment))
+    comments: assignIds(grouped.flatMap(([, fileComments]) => fileComments))
   };
 }
 
+/**
+ * Give every comment an id that is unique within the document.
+ *
+ * `<file>:<line>` was assumed to be unique because "the UI anchors one
+ * comment per line". It does not: in a diff, the removed line and the line
+ * that replaced it can carry the *same* number, one on each side, and
+ * commenting on both is two ordinary clicks. The export then contained two
+ * different comments under one id, and a consumer keyed by id — which is
+ * what an id is for — silently kept one of them. See #26.
+ *
+ * The first comment on a line keeps the bare `<file>:<line>`, so ids do not
+ * churn for the overwhelmingly common case and stay stable for anything
+ * already consuming them. Only a genuine collision gets a suffix.
+ *
+ * Stable across exports because the order is: `groupByFile` sorts by line
+ * with a stable sort, so two comments sharing a line keep the order they
+ * were saved in, and saving appends.
+ *
+ * @param {import('./comments').Comment[]} comments in document order
+ * @returns {AgentComment[]}
+ */
+function assignIds(comments) {
+  const seen = new Map();
+
+  return comments.map(comment => {
+    const base = `${comment.file}:${comment.line}`;
+    const n = (seen.get(base) ?? 0) + 1;
+    seen.set(base, n);
+    return toAgentComment(comment, n === 1 ? base : `${base}#${n}`);
+  });
+}
+
+
 /**
  * Select comments from an already-built document and keep its summary honest.
  *
@@ -81,7 +115,8 @@ function buildReviewDocument({ repoPath, comments, generatedAt, head = null, bra
 function filterReviewDocument(document, { file = null } = {}) {
   if (file === null) return document;
 
-  const comments = document.comments.filter(comment => comment.file === file);
+  const wanted = normalizeReviewPath(file, document.repository.path);
+  const comments = document.comments.filter(comment => comment.file === wanted);
   return {
     ...document,
     summary: {
@@ -92,15 +127,36 @@ function filterReviewDocument(document, { file = null } = {}) {
   };
 }
 
+/**
+ * Turn a `--file` argument into the repo-relative, forward-slash form comments
+ * are stored in.
+ *
+ * Shells hand paths over as `./src/auth.js` on tab-completion, scripts often
+ * pass absolute paths, and Windows users type backslashes. Matching literally
+ * made every one of those miss and fail with the same error as a file that
+ * genuinely has no comments.
+ *
+ * @param {string} file
+ * @param {string} repoPath
+ * @returns {string}
+ */
+function normalizeReviewPath(file, repoPath) {
+  let candidate = file;
+  if (path.isAbsolute(candidate)) candidate = path.relative(repoPath, candidate);
+
+  const normalized = path.posix.normalize(candidate.replace(/\\/g, '/'));
+  return normalized.replace(/^(\.\/)+/, '').replace(/\/$/, '');
+}
+
 /**
  * @param {import('./comments').Comment} comment
  * @returns {AgentComment}
  */
-function toAgentComment(comment) {
+function toAgentComment(comment, id) {
   const entry = {
-    // File and line identify a comment uniquely — the UI anchors one comment
-    // per line — and staying derived keeps ids stable across exports.
-    id: `${comment.file}:${comment.line}`,
+    // Derived from file and line so it stays stable across exports, with a
+    // suffix where that is not enough on its own. See `assignIds`.
+    id,
     file: comment.file,
     line: comment.line,
     anchor: comment.lineContent ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-reviewer",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Review your coding agent's changes like a pull request \u2014 locally, with inline comments and threaded follow-ups, then hand the marked-up review back to the agent",
   "author": "Dheeraj Jha",
   "license": "MIT",

package/public/app.js

@@ -296,7 +296,7 @@ async function loadFile(filePath, index) {
       updateCommentsSidebar();
     }
 
-    displayCode(data.filePath, data.diffLines);
+    displayCode(data.filePath, data.diffLines, data.binary);
     updateFullContextButton();
     return Promise.resolve();
 
@@ -307,7 +307,7 @@ async function loadFile(filePath, index) {
 }
 
 // Display code with diff highlighting
-function displayCode(filePath, diffLines) {
+function displayCode(filePath, diffLines, binary) {
   const codeSection = document.getElementById('codeSection');
   const currentFileEl = document.getElementById('currentFile');
   const codeViewer = document.getElementById('codeViewer');
@@ -315,6 +315,19 @@ function displayCode(filePath, diffLines) {
   currentFileEl.textContent = filePath;
   currentDiffLines = diffLines; // Store for reference when adding comments
 
+  // A binary file has no lines to show and none to comment on. Saying so is
+  // the whole feature: it used to be decoded as UTF-8 and rendered as
+  // mojibake, and a comment left on one of those lines exported an anchor
+  // that could never match the file again.
+  if (binary) {
+    codeSection.style.display = 'block';
+    codeViewer.innerHTML =
+      '<div class="binary-notice">Binary file &mdash; not shown.' +
+      '<span>git reports this file as binary, so there are no lines to ' +
+      'review. Comments need a line to anchor to.</span></div>';
+    return;
+  }
+
   const fileComments = comments.filter(c => c.file === filePath);
 
   let html = '';

package/public/style.css

@@ -988,3 +988,19 @@ button:disabled {
   color: #24292e;
   border: 1px solid #e1e4e8;
 }
+
+/* A binary file has no lines to render; say so rather than showing a
+   lossy UTF-8 decode of its bytes. See #23. */
+.binary-notice {
+  padding: 28px 24px;
+  color: #57606a;
+  font-size: 14px;
+  line-height: 1.6;
+}
+
+.binary-notice span {
+  display: block;
+  margin-top: 6px;
+  font-size: 13px;
+  opacity: 0.8;
+}

package/server.js

@@ -149,6 +149,29 @@ function createApp(options = {}) {
    * @param {string} filePath
    * @returns {Promise<string>}
    */
+  /**
+   * Whether git considers this file binary.
+   *
+   * Asking git rather than sniffing the bytes ourselves, because git's
+   * answer is the one that produced the diff we are about to render, and a
+   * second opinion that disagreed would be worse than no opinion. It says
+   * so in the diff itself: `Binary files a/x and b/x differ` for the
+   * default format, `GIT binary patch` when binary patches are enabled.
+   *
+   * This matters beyond the mojibake. `lib/changes.js` already classifies
+   * these as `B` and the sidebar renders that letter, but the file endpoint
+   * never consulted it -- so a 2 KB PNG came back as ten `add` lines that
+   * were ~45% U+FFFD, and a comment left on one of them exported an
+   * `anchor` that can never match the file. docs/agent-format.md tells a
+   * consumer to locate comments by that anchor.
+   *
+   * @param {string} diffText
+   * @returns {boolean}
+   */
+  function isBinaryDiff(diffText) {
+    return /^Binary files .* differ$/m.test(diffText) || /^GIT binary patch$/m.test(diffText);
+  }
+
   async function diffForFile(git, session, filePath) {
     if (session.mode === 'lastCommit') {
       return git.diff(['HEAD~1', 'HEAD', '--', filePath]);
@@ -221,11 +244,26 @@ function createApp(options = {}) {
       const session = requireSession(res, repoId);
       if (!session) return;
 
+      // Confine the path first, explicitly. It used to be confined as a
+      // side effect of `readFileForMode` calling `resolveRepoFile`, so
+      // moving the read below the binary check silently turned a 400 into a
+      // 500 and let the traversal reach git. A containment check that only
+      // works because of statement order is not a containment check.
+      resolveRepoFile(session.repoPath, filePath);
+
       const git = gitFactory(session.repoPath);
-      const content = await readFileForMode(session, filePath);
       const diffText = await diffForFile(git, session, filePath);
 
-      res.json({ filePath, diffLines: parseDiff(diffText, content) });
+      // Answered before the file is read: decoding a PNG as UTF-8 to then
+      // throw the result away is how the mojibake got served in the first
+      // place.
+      if (isBinaryDiff(diffText)) {
+        return res.json({ filePath, binary: true, diffLines: [] });
+      }
+
+      const content = await readFileForMode(session, filePath);
+
+      res.json({ filePath, binary: false, diffLines: parseDiff(diffText, content) });
     } catch (error) {
       if (error instanceof PathEscapeError) {
         return res.status(400).json({ error: error.message });