diffprism 1.4.1 → 1.5.0

package/README.md

@@ -79,7 +79,7 @@ Reviews are **one per repo**: opening a review for a repo that already has one u
 |------|---------|
 | `annotate` | Post findings inline on the diff; `warning` flags the session for attention |
 | `get_review_comments` | Read every thread on the session; `awaiting_reply` narrows to unanswered ones |
-| `reply` | Reply to a thread — answer the reviewer's question on a line |
+| `reply` | Reply to a thread, then keep listening for what the reviewer does next |
 | `wait_for_comments` | Block until the reviewer writes something the agent hasn't answered |
 | `get_review_state` | Session status, attention and new-changes flags, and annotations |
 | `get_user_focus` | What file/line the user is currently viewing in the browser |
@@ -89,7 +89,7 @@ Reviews are **one per repo**: opening a review for a repo that already has one u
 
 In a local review, **Ask agent now** in a line's comment form asks the agent while you're still reviewing: the agent's wait for your decision ends with your question, it answers in the thread, and goes back to waiting.
 
-PR reviews are opened with `diffprism review <PR URL>` or the dashboard — not by `open_review` — and your AI then works inside them with the tools above. Click a line to ask the agent about it; an agent listening with `wait_for_comments` answers in the thread. Nothing starts an agent for you: if none has picked a question up, the thread says so and names the session to ask Claude Code about.
+PR reviews are opened with `diffprism review <PR URL>` or the dashboard — not by `open_review` — and your AI then works inside them with the tools above. Click a line to ask the agent about it; an agent listening with `wait_for_comments` answers in the thread, and stays listening for your next question until you tell it to stop. Nothing starts an agent for you: if none has picked a question up, the thread says so and names the session to ask Claude Code about. That one prompt is enough — the agent is handed the checkout, branch, PR and the code you asked about along with the question.
 
 When you're done, **Approve**, **Request changes** or **Comment** from the bar at the bottom: DiffPrism posts it to GitHub as a pull request review. Your threads are a conversation with the agent, so none of them goes to GitHub unless you tick it; a ticked thread posts your opening message as an inline review comment. The token comes from `GITHUB_TOKEN`, `gh auth token`, or `~/.diffprism/config.json`.
 

package/dist/bin.js

@@ -5,7 +5,7 @@ import {
 } from "./chunk-RFDSC6MC.js";
 import {
   demo
-} from "./chunk-GF455BBV.js";
+} from "./chunk-4JLGL3O6.js";
 import {
   COMMIT_GATE_DIFF_REF,
   DEFAULT_DIFF_REF,
@@ -26,7 +26,7 @@ import {
   recordError,
   startGlobalServer,
   submitReviewToServer
-} from "./chunk-YGUHES4P.js";
+} from "./chunk-M5NJBIOV.js";
 import {
   getDiff
 } from "./chunk-GGK6TIQZ.js";
@@ -477,7 +477,7 @@ This should happen automatically after significant changes. You don't need the u
    - **\`dismissed\`** \u2014 the reviewer closed it without deciding. Ask before continuing.
    - If \`postReviewAction\` is \`"commit"\` \u2014 commit the changes. If \`"commit_and_pr"\` \u2014 commit and open a PR.
 4. If it returns \`status: "timed_out"\`, the reviewer is still reading. Keep waiting with \`mcp__diffprism__get_review_result\` (\`wait: true\`).
-5. If it returns \`status: "reviewer_asked"\`, the reviewer asked you something before deciding. Answer each thread with \`mcp__diffprism__reply\` (its \`id\` is the \`annotation_id\`) \u2014 and change the code if that's what they asked for. Then wait again with \`mcp__diffprism__get_review_result\` (\`wait: true\`), which can return \`reviewer_asked\` again.
+5. If it returns \`status: "reviewer_asked"\`, the reviewer asked you something before deciding. Answer each thread with \`mcp__diffprism__reply\` (its \`id\` is the \`annotation_id\`) \u2014 and change the code if that's what they asked for. \`reply\` goes back to waiting by itself and returns what happened next as \`next\`: another question (\`reviewer_asked\`) to answer the same way, the decision (\`decided\`), or \`timed_out\` \u2014 then wait with \`mcp__diffprism__get_review_result\` (\`wait: true\`).
 
 **While a review is open, wait for it.** Don't ask the user whether they've finished, and don't move on to other work \u2014 their decision is the answer, and it arrives through the tool. Asking in the terminal splits the conversation in two and the decision gets lost between them.
 
@@ -514,11 +514,11 @@ Pull requests are opened by the user \u2014 \`diffprism review <PR URL>\` or "Re
 
 The reviewer can also ask you questions on lines of the PR. Hold that conversation in the dashboard, not the terminal:
 
-1. \`mcp__diffprism__wait_for_comments\` \u2014 blocks until the reviewer writes something you haven't answered, then returns those threads.
-2. \`mcp__diffprism__reply\` \u2014 answer each thread, passing its \`annotation_id\`.
-3. Wait again. On \`timed_out\`, nothing new was said \u2014 keep waiting until the user tells you to stop.
+1. \`mcp__diffprism__wait_for_comments\` \u2014 blocks until the reviewer writes something you haven't answered, then returns those threads. Each carries \`hunk\`, the code it's on, and the response carries \`review\`: the checkout on disk (\`projectPath\`), the branch, and the PR. That's enough to start answering \u2014 you don't need to look the review up first. If \`localRepoConnected\` is false there's no clone here; answer from the hunk and the PR.
+2. \`mcp__diffprism__reply\` \u2014 answer a thread, passing its \`annotation_id\`. It goes back to listening by itself and returns what happened next as \`next\`: more questions to answer the same way, or \`timed_out\` \u2014 then call \`wait_for_comments\` again.
+3. Keep going until the user tells you to stop. Answering is not the end of the conversation; the reviewer's next question only reaches you if you're still listening.
 
-When no agent has read a question, the dashboard tells the reviewer so, and to ask you to answer their DiffPrism comments on a session id. When they do, run this loop with that \`session_id\`.
+When no agent has read a question, the dashboard tells the reviewer so, and to ask you to answer their DiffPrism comments on a session id. When they do, call \`wait_for_comments\` with that \`session_id\` \u2014 it returns at once with what's waiting \u2014 and run this loop.
 
 A PR review and a working-copy review can be open for the same clone at once. If a tool reports more than one session, pass the \`session_id\` of the one you mean.
 
@@ -542,8 +542,8 @@ A PR review and a working-copy review can be open for the same clone at once. If
 |------|---------|
 | \`annotate\` | Post one or more findings. \`warning\` flags the session for attention. |
 | \`get_review_comments\` | Every thread on the review; \`awaiting_reply\` narrows to threads waiting for an answer. |
-| \`reply\` | Reply to a thread \u2014 answer the reviewer's question or follow up on a finding. |
-| \`wait_for_comments\` | Block until the reviewer writes something you haven't answered. |
+| \`reply\` | Reply to a thread, then keep listening and return what happens next. |
+| \`wait_for_comments\` | Block until the reviewer writes something you haven't answered; returns it with the code and where the review is. |
 | \`get_review_state\` | Session status, attention and new-changes flags, and annotations. |
 | \`get_user_focus\` | What the user is currently looking at. |
 | \`get_pr_context\` | PR overview: metadata, briefing, file list, local clone status. |
@@ -721,7 +721,7 @@ async function setupInteractive(flags) {
 }
 async function runDemo(dev) {
   console.log("");
-  const { demo: demo2 } = await import("./demo-F47GIDSV.js");
+  const { demo: demo2 } = await import("./demo-5UQ7CLKT.js");
   await demo2({ dev });
 }
 async function setupBatch(flags) {

package/dist/{chunk-GF455BBV.js → chunk-4JLGL3O6.js}

@@ -1,7 +1,7 @@
 import {
   ensureServer,
   submitReviewToServer
-} from "./chunk-YGUHES4P.js";
+} from "./chunk-M5NJBIOV.js";
 import {
   parseDiff
 } from "./chunk-GGK6TIQZ.js";

package/dist/{chunk-YGUHES4P.js → chunk-M5NJBIOV.js}

@@ -111,7 +111,7 @@ import fs2 from "fs";
 import path2 from "path";
 import { fileURLToPath } from "url";
 function builtAt() {
-  return true ? 1789619886717 : null;
+  return true ? 1789699543800 : null;
 }
 function getBuildInfo() {
   let dir = path2.dirname(fileURLToPath(import.meta.url));
@@ -141,7 +141,7 @@ function describeVersion(version) {
 var ISSUES_NEW_URL = "https://github.com/CodeJonesW/diffprism/issues/new";
 var MAX_ERROR_CHARS = 1500;
 function currentVersion() {
-  return true ? "1.4.1" : "0.0.0-dev";
+  return true ? "1.5.0" : "0.0.0-dev";
 }
 function describeEnvironment() {
   return {

package/dist/{demo-F47GIDSV.js → demo-5UQ7CLKT.js}

@@ -1,7 +1,7 @@
 import {
   demo
-} from "./chunk-GF455BBV.js";
-import "./chunk-YGUHES4P.js";
+} from "./chunk-4JLGL3O6.js";
+import "./chunk-M5NJBIOV.js";
 import "./chunk-GGK6TIQZ.js";
 import "./chunk-DHCVZGHE.js";
 import "./chunk-JSBRDJBE.js";

package/dist/mcp-server.js

@@ -14,7 +14,7 @@ import {
   recordError,
   submitReviewToServer,
   waitForDecision
-} from "./chunk-YGUHES4P.js";
+} from "./chunk-M5NJBIOV.js";
 import {
   getDiff
 } from "./chunk-GGK6TIQZ.js";
@@ -81,11 +81,56 @@ async function readThreads(serverInfo, sessionId) {
   const { annotations } = await response.json();
   return annotations.map((a) => ({ ...a, awaitingReply: awaitingAgent(a) }));
 }
-function reviewerAskedResult(err, waitWith) {
+async function readReview(serverInfo, sessionId) {
+  let response;
+  try {
+    response = await fetch(
+      `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/payload`
+    );
+  } catch {
+    return null;
+  }
+  if (!response.ok) {
+    return null;
+  }
+  const { payload, projectPath } = await response.json();
+  return {
+    review: {
+      sessionId,
+      projectPath,
+      localRepoConnected: !projectPath.startsWith("github:"),
+      branch: payload.metadata.currentBranch,
+      pr: payload.metadata.githubPr ?? null,
+      title: payload.metadata.title
+    },
+    diffSet: payload.diffSet
+  };
+}
+function hunkFor(diffSet, annotation) {
+  const file = diffSet.files.find((f) => f.path === annotation.file);
+  if (!file) {
+    return null;
+  }
+  return file.hunks.find(
+    (hunk) => annotation.side === "old" ? annotation.line >= hunk.oldStart && annotation.line < hunk.oldStart + hunk.oldLines : annotation.line >= hunk.newStart && annotation.line < hunk.newStart + hunk.newLines
+  ) ?? null;
+}
+function answerableThreads(context, threads) {
+  return {
+    sessionId: context.review.sessionId,
+    review: context.review,
+    threads: threads.map((thread) => ({
+      ...thread,
+      awaitingReply: true,
+      hunk: hunkFor(context.diffSet, thread)
+    }))
+  };
+}
+async function reviewerAskedResult(serverInfo, err, waitWith) {
+  const context = await readReview(serverInfo, err.sessionId);
   return jsonResult({
     status: "reviewer_asked",
-    sessionId: err.sessionId,
-    threads: err.threads.map((t) => ({ ...t, awaitingReply: true })),
+    ...context ? answerableThreads(context, err.threads) : { sessionId: err.sessionId, threads: err.threads.map((t) => ({ ...t, awaitingReply: true })) },
     message: `The reviewer asked you something before deciding. Answer each thread with reply (session_id: ${err.sessionId}, annotation_id from threads) \u2014 change the code too if that's what they asked for. Then ${waitWith}. The review stays open; the decision still comes.`
   });
 }
@@ -176,7 +221,7 @@ function createMcpServer() {
           });
         } catch (err) {
           if (err instanceof ReviewerAskedError) {
-            return reviewerAskedResult(err, `wait for the decision with get_review_result (session_id: ${err.sessionId}, wait: true)`);
+            return await reviewerAskedResult(serverInfo, err, `wait for the decision with get_review_result (session_id: ${err.sessionId}, wait: true)`);
           }
           if (err instanceof ReviewTimeoutError) {
             return jsonResult({
@@ -217,7 +262,7 @@ ${REPORT_HINT}`);
         return jsonResult(await waitForDecision(serverInfo, sessionId, Math.min(timeout ?? 300, 600) * 1e3));
       } catch (err) {
         if (err instanceof ReviewerAskedError) {
-          return reviewerAskedResult(err, "call get_review_result with wait: true again");
+          return await reviewerAskedResult(serverInfo, err, "call get_review_result with wait: true again");
         }
         if (err instanceof ReviewTimeoutError) {
           return jsonResult({
@@ -382,14 +427,17 @@ ${REPORT_HINT}`);
   );
   server.tool(
     "reply",
-    "Reply to a thread on an open review \u2014 answer the reviewer's question, or follow up on a finding. The reply appears under the thread in the dashboard straight away.",
+    "Reply to a thread on an open review \u2014 answer the reviewer's question, or follow up on a finding. The reply appears under the thread in the dashboard straight away, and then this goes back to listening and returns whatever happens next: the reviewer's next question, their decision, or `timed_out`. Stay in that loop until they tell you to stop.",
     {
       ...targetParams,
       annotation_id: z.string().describe("The thread to reply to (an annotation id from get_review_comments or wait_for_comments)"),
       body: z.string().describe("Your reply"),
-      source_agent: z.string().optional().describe("Who is replying, e.g. 'pr-reviewer'")
+      source_agent: z.string().optional().describe("Who is replying, e.g. 'pr-reviewer'"),
+      then_wait: z.boolean().optional().describe(
+        "Keep listening after replying (default true). With false, returns as soon as the reply is posted \u2014 use it when you have several threads to answer and want to post them all first."
+      )
     },
-    async ({ session_id, repo_path, annotation_id, body, source_agent }) => withSession({ session_id, repo_path }, async ({ serverInfo, sessionId }) => {
+    async ({ session_id, repo_path, annotation_id, body, source_agent, then_wait }) => withSession({ session_id, repo_path }, async ({ serverInfo, sessionId }) => {
       const response = await fetch(
         `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/annotations/${annotation_id}/replies`,
         {
@@ -402,7 +450,33 @@ ${REPORT_HINT}`);
       if (!response.ok) {
         return toolError(`Error: ${data.error ?? `server returned ${response.status}`}`);
       }
-      return jsonResult({ sessionId, annotationId: annotation_id, replyId: data.replyId });
+      const posted = { sessionId, annotationId: annotation_id, replyId: data.replyId };
+      if (then_wait === false) {
+        return jsonResult(posted);
+      }
+      try {
+        const result = await waitForDecision(serverInfo, sessionId, DEFAULT_WAIT_MS);
+        return jsonResult({ ...posted, next: { status: "decided", result } });
+      } catch (err) {
+        if (err instanceof ReviewerAskedError) {
+          const context = await readReview(serverInfo, sessionId);
+          return jsonResult({
+            ...posted,
+            next: context ? { status: "reviewer_asked", ...answerableThreads(context, err.threads) } : { status: "reviewer_asked", sessionId, threads: err.threads }
+          });
+        }
+        if (err instanceof ReviewTimeoutError) {
+          return jsonResult({
+            ...posted,
+            next: {
+              status: "timed_out",
+              sessionId,
+              message: "Your reply is posted and the reviewer hasn't said anything since. Keep listening: wait_for_comments in a PR review, or get_review_result with wait: true if you're waiting for their decision. Don't ask them in the terminal."
+            }
+          });
+        }
+        throw err;
+      }
     })
   );
   server.tool(
@@ -422,7 +496,10 @@ ${REPORT_HINT}`);
         }
         const waiting = threads.filter((t) => t.awaitingReply);
         if (waiting.length > 0) {
-          return jsonResult({ sessionId, threads: waiting });
+          const context = await readReview(serverInfo, sessionId);
+          return jsonResult(
+            context ? answerableThreads(context, waiting) : { sessionId, threads: waiting }
+          );
         }
         if (Date.now() - start >= maxWaitMs) {
           return jsonResult({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffprism",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "type": "module",
   "description": "Local-first code review tool for agent-generated code changes",
   "bin": {