@filipc77/cowrite 0.6.3 → 0.6.5

package/README.md

@@ -14,11 +14,12 @@ Browser (Preview UI)          Node.js Process              Claude Code
 │ File preview     │     │  HTTP + WebSocket    │     │                    │
 │ Text selection   │◄───►│  server (port 3377)  │     │  MCP tools:        │
 │ Comment creation │     │                      │     │                    │
-│ Comment sidebar  │     │  ┌────────────────┐  │     │  get_pending       │ 
+│ Comment sidebar  │     │  ┌────────────────┐  │     │  get_pending       │
 └──────────────────┘     │  │ CommentStore   │  │     │  resolve           │
                          │  │ (shared memory)│  │     │  reply             │
-                         │  └───────┬────────┘  │     │  get_annotated     │
-                         │          │           │     │   wait_for_comment │
+                         │  └───────┬────────┘  │     │  propose_change    │
+                         │          │           │     │  get_annotated     │
+                         │          │           │     │  wait_for_comment  │
                          │  ┌───────▼────────┐  │     │                    │
                          │  │ MCP Server     │◄─╋────►│                    │
                          │  │ (stdio)        │  │     │                    │
@@ -135,6 +136,16 @@ Sends a reply from the agent, visible in the browser comment sidebar.
 | `commentId` | string | The comment ID to reply to |
 | `reply` | string | The reply text |
 
+### `propose_change`
+
+Proposes a text replacement for a comment's selected text. The user sees a diff in the browser with Apply/Reject buttons. Preferred over direct file edits when responding to comments on selected text.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `commentId` | string | The comment ID to propose a change for |
+| `newText` | string | The replacement text |
+| `explanation` | string | Explanation of the change |
+
 ### `get_file_with_annotations`
 
 Returns the file content with inline comment markers at the positions where comments are anchored:
@@ -192,7 +203,7 @@ Cowrite ships with two built-in Claude Code skills (auto-installed to `.claude/s
    - The `UserPromptSubmit` hook injecting it on the next user message
    - `wait_for_comment` returning immediately (if `/watch` is active)
    - The agent calling `get_pending_comments` directly
-6. The agent makes the change, calls `reply_to_comment` (visible in the browser), then `resolve_comment`
+6. The agent responds — either calling `propose_change` (user sees a diff with Apply/Reject) or `reply_to_comment` + `resolve_comment`
 7. The browser receives the update via WebSocket and shows the reply and resolved state
 
 ## How Edits Flow

package/dist/bin/cowrite.js

@@ -150,6 +150,46 @@ var CommentStore = class extends EventEmitter {
 `));
     return reply;
   }
+  addProposalReply(commentId, newText, explanation) {
+    const comment = this.comments.get(commentId);
+    if (!comment) return null;
+    const proposal = {
+      oldText: comment.selectedText,
+      newText,
+      explanation,
+      status: "pending"
+    };
+    const reply = {
+      id: randomUUID(),
+      from: "agent",
+      text: explanation,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      proposal
+    };
+    comment.replies.push(reply);
+    if (comment.status === "pending") {
+      comment.status = "answered";
+    }
+    this.emit("change", comment);
+    this.persist().catch((err) => process.stderr.write(`Persist error: ${err}
+`));
+    return reply;
+  }
+  updateProposalStatus(commentId, replyId, status) {
+    const comment = this.comments.get(commentId);
+    if (!comment) return false;
+    const reply = comment.replies.find((r) => r.id === replyId);
+    if (!reply?.proposal) return false;
+    reply.proposal.status = status;
+    if (status === "applied") {
+      comment.selectedText = reply.proposal.newText;
+      comment.length = reply.proposal.newText.length;
+    }
+    this.emit("change", comment);
+    this.persist().catch((err) => process.stderr.write(`Persist error: ${err}
+`));
+    return true;
+  }
   get(commentId) {
     return this.comments.get(commentId) ?? null;
   }
@@ -359,6 +399,40 @@ function createMcpServer(store, projectDir, getPreviewPort) {
       };
     }
   );
+  server.tool(
+    "propose_change",
+    "Propose a text change for a comment's selected text. The user sees a diff and can Apply or Reject. Preferred over direct edits when responding to comments on selected text.",
+    {
+      commentId: z.string().describe("The comment ID to propose a change for"),
+      newText: z.string().describe("The replacement text"),
+      explanation: z.string().describe("Explanation of the change")
+    },
+    async ({ commentId, newText, explanation }) => {
+      const comment = store.get(commentId);
+      if (!comment) {
+        return {
+          content: [{ type: "text", text: `Comment ${commentId} not found.` }],
+          isError: true
+        };
+      }
+      if (!comment.selectedText) {
+        return {
+          content: [{ type: "text", text: `Comment ${commentId} is a file-level comment with no selected text. Use reply_to_comment instead.` }],
+          isError: true
+        };
+      }
+      const reply = store.addProposalReply(commentId, newText, explanation);
+      if (!reply) {
+        return {
+          content: [{ type: "text", text: `Failed to add proposal to comment ${commentId}.` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Proposal added to comment ${commentId}. The user can now review and apply or reject it.` }]
+      };
+    }
+  );
   server.tool(
     "get_file_with_annotations",
     "Get file content with inline comment markers showing where comments are anchored.",
@@ -382,24 +456,49 @@ function createMcpServer(store, projectDir, getPreviewPort) {
       }
     }
   );
+  const lastSeenReplyCounts = /* @__PURE__ */ new Map();
+  function formatCommentPayload(comment, event) {
+    const file = relative(projectDir, comment.file);
+    const replies = comment.replies ?? [];
+    lastSeenReplyCounts.set(comment.id, replies.length);
+    const payload = { ...comment, file, event };
+    if (event === "follow_up" && replies.length > 0) {
+      const userReplies = replies.filter((r) => r.from === "user");
+      if (userReplies.length > 0) {
+        payload.latestUserReply = userReplies[userReplies.length - 1].text;
+      }
+    }
+    return payload;
+  }
   server.tool(
     "wait_for_comment",
-    "Block until a new comment is posted in the live preview, then return it. This is the primary way to receive real-time comments \u2014 call it again immediately after handling each comment to keep listening. If it times out, call it again.",
+    "Block until a new or follow-up comment is posted in the live preview, then return it. Returns an 'event' field: 'new_comment' for brand-new comments, 'follow_up' when the user replied to an already-answered comment. For follow-ups, 'latestUserReply' contains the new reply text. Call again immediately after handling each result to keep listening.",
     {
       timeout: z.number().optional().describe("Max seconds to wait (default: 30)")
     },
     ({ timeout }, { signal }) => {
       const maxWait = (timeout ?? 30) * 1e3;
       const pending = store.getAll({ status: "pending" });
-      if (pending.length > 0) {
-        const latest = pending[pending.length - 1];
-        const file = relative(projectDir, latest.file);
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({ ...latest, file }, null, 2)
-          }]
-        };
+      for (const c of pending) {
+        const prevCount = lastSeenReplyCounts.get(c.id);
+        if (prevCount === void 0) {
+          const payload = formatCommentPayload(c, "new_comment");
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(payload, null, 2)
+            }]
+          };
+        }
+        if (c.replies.length > prevCount) {
+          const payload = formatCommentPayload(c, "follow_up");
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify(payload, null, 2)
+            }]
+          };
+        }
       }
       return new Promise((resolve6) => {
         const timer = setTimeout(() => {
@@ -409,13 +508,23 @@ function createMcpServer(store, projectDir, getPreviewPort) {
             content: [{ type: "text", text: count > 0 ? `Timeout, but ${count} pending comment(s) exist. Call get_pending_comments now.` : "No new comments yet. Call wait_for_comment again to keep listening." }]
           });
         }, maxWait);
-        const onComment = (comment) => {
+        const onNewComment = (comment) => {
           cleanup();
-          const file = relative(projectDir, comment.file);
+          const payload = formatCommentPayload(comment, "new_comment");
           resolve6({
             content: [{
               type: "text",
-              text: JSON.stringify({ ...comment, file }, null, 2)
+              text: JSON.stringify(payload, null, 2)
+            }]
+          });
+        };
+        const onReopened = (comment) => {
+          cleanup();
+          const payload = formatCommentPayload(comment, "follow_up");
+          resolve6({
+            content: [{
+              type: "text",
+              text: JSON.stringify(payload, null, 2)
             }]
           });
         };
@@ -427,12 +536,12 @@ function createMcpServer(store, projectDir, getPreviewPort) {
         };
         const cleanup = () => {
           clearTimeout(timer);
-          store.off("new_comment", onComment);
-          store.off("comment_reopened", onComment);
+          store.off("new_comment", onNewComment);
+          store.off("comment_reopened", onReopened);
           signal?.removeEventListener("abort", onAbort);
         };
-        store.on("new_comment", onComment);
-        store.on("comment_reopened", onComment);
+        store.on("new_comment", onNewComment);
+        store.on("comment_reopened", onReopened);
         signal?.addEventListener("abort", onAbort, { once: true });
         if (signal?.aborted) {
           onAbort();
@@ -537,7 +646,9 @@ function createMcpServer(store, projectDir, getPreviewPort) {
               "",
               "Follow this loop:",
               "1. Call `get_pending_comments` to check for any comments already posted.",
-              "2. Process each pending comment: read the file, make the requested change, then call `reply_to_comment` to explain what you did.",
+              "2. Process each pending comment: read the file, then respond:",
+              "   - If the comment is on selected text, prefer `propose_change` to suggest a diff the user can Apply/Reject.",
+              "   - For file-level comments or questions, use `reply_to_comment` to explain what you did.",
               "   Your reply automatically marks the comment as 'answered'. The user will review and resolve it.",
               "3. Call `wait_for_comment` to block until the next comment (or reopened comment) arrives.",
               "4. When a comment arrives, process it the same way (step 2).",
@@ -821,6 +932,38 @@ function createPreviewServer(store, projectDir, port, initialFile) {
         await writeFile2(file, newContent, "utf-8");
         break;
       }
+      case "proposal_apply": {
+        const comment = store.get(msg.commentId);
+        if (!comment) {
+          send(ws, { type: "error", message: "Comment not found" });
+          break;
+        }
+        const reply = comment.replies.find((r) => r.id === msg.replyId);
+        if (!reply?.proposal || reply.proposal.status !== "pending") {
+          send(ws, { type: "error", message: "Proposal not found or not pending" });
+          break;
+        }
+        const pFile = comment.file;
+        const pWatcher = watchers.get(pFile);
+        if (!pWatcher) {
+          send(ws, { type: "error", message: "File not being watched" });
+          break;
+        }
+        const pContent = pWatcher.getContent();
+        const pSlice = pContent.slice(comment.offset, comment.offset + comment.length);
+        if (pSlice !== comment.selectedText) {
+          send(ws, { type: "error", message: "File content has changed \u2014 selected text no longer matches at this position" });
+          break;
+        }
+        const pNewContent = pContent.slice(0, comment.offset) + reply.proposal.newText + pContent.slice(comment.offset + comment.length);
+        await writeFile2(pFile, pNewContent, "utf-8");
+        store.updateProposalStatus(msg.commentId, msg.replyId, "applied");
+        break;
+      }
+      case "proposal_reject": {
+        store.updateProposalStatus(msg.commentId, msg.replyId, "rejected");
+        break;
+      }
     }
   }
   store.on("change", (comment) => {
@@ -887,7 +1030,7 @@ function createPreviewServer(store, projectDir, port, initialFile) {
 // bin/cowrite.ts
 import updateNotifier from "update-notifier";
 import "module";
-var version = true ? "0.6.1" : createRequire(import.meta.url)("../package.json").version;
+var version = true ? "0.6.5" : createRequire(import.meta.url)("../package.json").version;
 var USAGE = `
 cowrite \u2014 Live commenting plugin for coding agent sessions