git-reviewer 2.3.0 → 2.3.1

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-261-brightgreen.svg)](test/)
+[![Tests](https://img.shields.io/badge/tests-264-brightgreen.svg)](test/)
 [![Dependencies](https://img.shields.io/badge/dependencies-3-brightgreen.svg)](package.json)
 
 When an agent writes the code, reading it becomes the bottleneck — and the tool
@@ -271,7 +271,7 @@ rather than a public issue.
 
 ```bash
 npm install           # 3 dependencies, no build step, ~6MB
-npm test              # 261 tests
+npm test              # 264 tests
 npm run test:watch
 npm run test:coverage
 ```

package/lib/comments.js

@@ -30,10 +30,31 @@
  * Optional fields are omitted rather than stored as `null` so that an absent
  * selection and an empty one are not two different states on disk.
  *
+ * A comment missing its file, line or text is rejected here rather than stored:
+ * `JSON.stringify` would silently drop the missing fields, and the record would
+ * only surface later, in `reviewer export`, as a comment on a file called
+ * `undefined` for an agent to act on.
+ *
  * @param {object} comment
+ * @param {number} index position in the batch, for the error message
  * @returns {Comment}
+ * @throws {TypeError} when a required field is missing or malformed
  */
-function normalizeComment(comment) {
+function normalizeComment(comment, index) {
+  const where = `comments[${index}]`;
+  if (comment === null || typeof comment !== 'object' || Array.isArray(comment)) {
+    throw new TypeError(`${where} must be an object`);
+  }
+  if (typeof comment.file !== 'string' || comment.file.trim() === '') {
+    throw new TypeError(`${where}.file must be a non-empty string`);
+  }
+  if (!Number.isInteger(comment.line) || comment.line < 1) {
+    throw new TypeError(`${where}.line must be a positive integer`);
+  }
+  if (typeof comment.text !== 'string' || comment.text.trim() === '') {
+    throw new TypeError(`${where}.text must be a non-empty string`);
+  }
+
   const normalized = {
     file: comment.file,
     line: comment.line,
@@ -61,13 +82,13 @@ function normalizeComment(comment) {
  *
  * @param {object[]} comments
  * @returns {Comment[]}
- * @throws {TypeError} when `comments` is not an array
+ * @throws {TypeError} when `comments` is not an array or a comment is malformed
  */
 function normalizeComments(comments) {
   if (!Array.isArray(comments)) {
     throw new TypeError('comments must be an array');
   }
-  return comments.map(normalizeComment);
+  return comments.map((comment, index) => normalizeComment(comment, index));
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-reviewer",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Review your coding agent's changes like a pull request — 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

@@ -180,8 +180,10 @@ async function loadRepo() {
     // Load saved comments
     const savedComments = await loadCommentsFromBackend();
     if (savedComments.length > 0) {
-      // Store saved comments in a global variable for matching later
-      window.savedComments = savedComments;
+      // These went into `window.savedComments` as well, as a second copy for
+      // the matcher to read. Nothing reads it now, and leaving a stale copy of
+      // the review lying around is how the resurrection happened in the first
+      // place -- so there is one list, and it is this one.
 
       // Add all saved comments to the comments array immediately
       comments = savedComments.map(c => ({
@@ -308,9 +310,20 @@ async function loadFile(filePath, index) {
       throw new Error(data.error || 'Failed to load file');
     }
 
-    // Match saved comments to current diff if available
-    if (window.savedComments && window.savedComments.length > 0) {
-      const matchedComments = matchCommentsToDiff(window.savedComments, filePath, data.diffLines);
+    // Give this file's comments their position in the diff just rendered.
+    //
+    // The source here used to be `window.savedComments`, a snapshot taken when
+    // the repository was opened and never updated again. Everything else works
+    // from `comments`, the live list -- so a comment you deleted was still in
+    // the snapshot, was not found in the live list, and the branch below added
+    // it straight back. It vanished from disk and reappeared on screen, and
+    // the next save wrote the resurrected copy back over the deletion. Editing
+    // one did the same thing by a different route: the text no longer matched,
+    // so the pre-edit copy was added alongside the edited one (#52).
+    //
+    // `comments` is what exists. A comment that is not in it does not exist.
+    if (comments.length > 0) {
+      const matchedComments = matchCommentsToDiff(comments, filePath, data.diffLines);
 
       // Update existing comments in the array with matched diff indices
       matchedComments.forEach(mc => {
@@ -330,6 +343,10 @@ async function loadFile(filePath, index) {
             existing.followUps = mc.followUps;
           }
         } else {
+          // Unreachable now that the matcher is fed the live list: everything
+          // it returns came from there. Kept as a guard rather than removed,
+          // because silently dropping a comment is the worse failure of the
+          // two, and this is the line that would do it.
           // Add new comment if it doesn't exist
           comments.push({
             file: mc.file,