agent-canvas 0.1.38 → 0.1.40

package/daemon/client/App.tsx

@@ -21,6 +21,7 @@ import { ShareDialog, ShareButton, type ShareEntry } from "./ShareDialog";
 import { ReviewerIdentityDialog } from "./ReviewerIdentityDialog";
 import type { Annotation } from "#canvas/runtime";
 import { MODE, fetchMeta, FS_AVAILABLE, WS_AVAILABLE, submitSharedFeedback, getReviewerIdentity, setReviewerIdentity } from "./clientApi";
+import { carryUnsubmittedDraft } from "./annotationDraft";
 
 export type ActiveView = { type: "overview" } | { type: "canvas"; filename: string } | { type: "file"; path: string };
 
@@ -312,9 +313,11 @@ function App() {
     fetchMeta()
       .then((data: any) => {
         if (data.currentRevision) {
+          const nextRevisions: RevisionInfo[] = data.revisions || [];
+          carryUnsubmittedDraft(localStorage, sessionId, data.currentRevision, nextRevisions);
           setCurrentRevision(data.currentRevision);
           setSelectedRevision(data.currentRevision);
-          setRevisions(data.revisions || []);
+          setRevisions(nextRevisions);
         }
         if (data.canvasFiles) {
           const files = (data.canvasFiles as string[]).sort();
@@ -378,11 +381,12 @@ function App() {
         try {
           const data = JSON.parse(event.data);
           if (data.type === "plan-updated") {
+            const allRevisions: RevisionInfo[] = Array.isArray(data.revisions) ? data.revisions : [];
+            carryUnsubmittedDraft(localStorage, sessionId, data.currentRevision, allRevisions);
             setCurrentRevision(data.currentRevision);
             setSelectedRevision(data.currentRevision);
             setCompareRevision(null);
-            if (data.revisions) {
-              const allRevisions = data.revisions as RevisionInfo[];
+            if (allRevisions.length > 0) {
               setRevisions(allRevisions);
               const latest = allRevisions.find((r: RevisionInfo) => r.revision === data.currentRevision);
               if (latest?.canvasFiles) {

package/daemon/client/annotationDraft.test.ts

@@ -0,0 +1,134 @@
+import { describe, expect, test } from "bun:test";
+import { carryUnsubmittedDraft } from "./annotationDraft";
+
+class MemoryStorage {
+  private readonly values = new Map<string, string>();
+
+  getItem(key: string): string | null {
+    return this.values.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string): void {
+    this.values.set(key, value);
+  }
+}
+
+const sessionId = "session";
+const key = (revision: number) => `canvas:${sessionId}:rev:${revision}`;
+
+describe("carryUnsubmittedDraft", () => {
+  test("carries the latest unsent draft into a new revision", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({
+      annotations: [{ id: "annotation-1" }],
+      generalNote: "Review in progress",
+      responses: [["choice", { value: "keep" }]],
+      feedbackEntries: [["old", { markdown: "stale generated content" }]],
+    }));
+    storage.setItem(key(3), JSON.stringify({
+      annotations: [],
+      generalNote: "",
+      responses: [["new-choice", { value: null }]],
+      feedbackEntries: [["new", { markdown: "generated content" }]],
+    }));
+
+    const sourceRevision = carryUnsubmittedDraft(storage, sessionId, 3, [
+      { revision: 1, hasFeedback: true },
+      { revision: 2, hasFeedback: false },
+      { revision: 3, hasFeedback: false },
+    ]);
+
+    expect(sourceRevision).toBe(2);
+    expect(JSON.parse(storage.getItem(key(3)) ?? "")).toEqual({
+      annotations: [{ id: "annotation-1" }],
+      generalNote: "Review in progress",
+      responses: [["choice", { value: "keep" }]],
+      feedbackEntries: [],
+    });
+  });
+
+  test("does not cross a submitted revision", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(1), JSON.stringify({
+      annotations: [{ id: "stale-annotation" }],
+      generalNote: "",
+      responses: [],
+    }));
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 3, [
+      { revision: 1, hasFeedback: false },
+      { revision: 2, hasFeedback: true },
+      { revision: 3, hasFeedback: false },
+    ])).toBeNull();
+    expect(storage.getItem(key(3))).toBeNull();
+  });
+
+  test("does not overwrite meaningful target data", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({
+      annotations: [{ id: "old-annotation" }],
+      generalNote: "",
+      responses: [],
+    }));
+    const current = JSON.stringify({
+      annotations: [{ id: "current-annotation" }],
+      generalNote: "",
+      responses: [],
+    });
+    storage.setItem(key(3), current);
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 3, [
+      { revision: 2, hasFeedback: false },
+      { revision: 3, hasFeedback: false },
+    ])).toBeNull();
+    expect(storage.getItem(key(3))).toBe(current);
+  });
+
+  test("skips empty intermediate revision state", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({
+      annotations: [],
+      generalNote: "Still drafting",
+      responses: [],
+    }));
+    storage.setItem(key(3), JSON.stringify({
+      annotations: [],
+      generalNote: "",
+      responses: [["choice", { value: [] }]],
+      feedbackEntries: [["generated", { markdown: "not user input" }]],
+    }));
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 4, [
+      { revision: 1, hasFeedback: true },
+      { revision: 2, hasFeedback: false },
+      { revision: 3, hasFeedback: false },
+      { revision: 4, hasFeedback: false },
+    ])).toBe(2);
+  });
+
+  test("does not resurrect a carried draft after it is cleared", () => {
+    const storage = new MemoryStorage();
+    storage.setItem(key(2), JSON.stringify({
+      annotations: [{ id: "annotation-1" }],
+      generalNote: "",
+      responses: [],
+    }));
+    const revisions = [
+      { revision: 1, hasFeedback: true },
+      { revision: 2, hasFeedback: false },
+      { revision: 3, hasFeedback: false },
+    ];
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 3, revisions)).toBe(2);
+    const cleared = JSON.stringify({ annotations: [], generalNote: "", responses: [] });
+    storage.setItem(key(3), cleared);
+
+    expect(carryUnsubmittedDraft(storage, sessionId, 3, revisions)).toBeNull();
+    expect(storage.getItem(key(3))).toBe(cleared);
+    expect(carryUnsubmittedDraft(storage, sessionId, 4, [
+      ...revisions,
+      { revision: 4, hasFeedback: false },
+    ])).toBeNull();
+    expect(storage.getItem(key(4))).toBeNull();
+  });
+});

package/daemon/client/annotationDraft.ts

@@ -0,0 +1,95 @@
+interface RevisionState {
+  revision: number;
+  hasFeedback: boolean;
+}
+
+interface AnnotationStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+function storageKey(sessionId: string, revision: number): string {
+  return `canvas:${sessionId}:rev:${revision}`;
+}
+
+function handledKey(sessionId: string, revision: number): string {
+  return `${storageKey(sessionId, revision)}:draft-handled`;
+}
+
+function parseState(raw: string | null): object | null {
+  if (!raw) return null;
+  try {
+    const value: unknown = JSON.parse(raw);
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+      ? value
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function hasResponseValue(entry: unknown): boolean {
+  if (!Array.isArray(entry) || entry.length < 2) return false;
+  const response: unknown = entry[1];
+  if (typeof response !== "object" || response === null || Array.isArray(response)) return false;
+
+  const note = Reflect.get(response, "note");
+  if (typeof note === "string" && note.trim().length > 0) return true;
+
+  const value = Reflect.get(response, "value");
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  return value !== null && value !== undefined;
+}
+
+function hasDraftContent(state: object | null): boolean {
+  if (!state) return false;
+  const annotations = Reflect.get(state, "annotations");
+  if (Array.isArray(annotations) && annotations.length > 0) return true;
+
+  const generalNote = Reflect.get(state, "generalNote");
+  if (typeof generalNote === "string" && generalNote.trim().length > 0) return true;
+
+  const responses = Reflect.get(state, "responses");
+  return Array.isArray(responses) && responses.some(hasResponseValue);
+}
+
+/** Carry an unsent draft forward without crossing submitted revisions. */
+export function carryUnsubmittedDraft(
+  storage: AnnotationStorage,
+  sessionId: string,
+  targetRevision: number,
+  revisions: RevisionState[],
+): number | null {
+  try {
+    const targetKey = storageKey(sessionId, targetRevision);
+    if (hasDraftContent(parseState(storage.getItem(targetKey)))) {
+      storage.setItem(handledKey(sessionId, targetRevision), "1");
+      return null;
+    }
+    if (storage.getItem(handledKey(sessionId, targetRevision)) !== null) return null;
+
+    const previous = revisions
+      .filter((revision) => revision.revision < targetRevision)
+      .sort((left, right) => right.revision - left.revision);
+
+    for (const revision of previous) {
+      if (revision.hasFeedback) return null;
+
+      const source = parseState(storage.getItem(storageKey(sessionId, revision.revision)));
+      if (!hasDraftContent(source)) {
+        if (storage.getItem(handledKey(sessionId, revision.revision)) !== null) return null;
+        continue;
+      }
+
+      storage.setItem(targetKey, JSON.stringify({
+        ...source,
+        feedbackEntries: [],
+      }));
+      storage.setItem(handledKey(sessionId, targetRevision), "1");
+      return revision.revision;
+    }
+  } catch {}
+
+  return null;
+}

package/daemon/client/highlightRange.ts

@@ -58,6 +58,7 @@ function getTextNodesInRange(range: Range): Text[] {
     // Skip line numbers and existing marks
     const parent = node.parentElement;
     if (parent?.classList.contains("select-none")) continue;
+    if (parent?.closest("[data-annotation-id]")) continue;
 
     if (range.intersectsNode(node)) {
       nodes.push(node);
@@ -108,27 +109,18 @@ export function restoreMarks(
   container: HTMLElement,
   annotations: { id: string; snippet: string; filePath?: string; context?: { before: string; after: string; hierarchy: string[] } }[]
 ) {
-  // Skip annotations that already have marks in the DOM
-  const toRestore = annotations.filter(
-    (a) => !document.querySelector(`[data-annotation-id="${a.id}"]`)
-  );
-  if (!toRestore.length) return;
+  for (const ann of annotations) {
+    // A canvas can be rendered more than once (overview, compare, hidden
+    // source panes), so restore decisions must be scoped to this container.
+    if (container.querySelector(`[data-annotation-id="${ann.id}"]`)) continue;
 
-  // Build full text content + mapping from text offset to (textNode, offsetInNode)
-  const textNodes: { node: Text; start: number }[] = [];
-  let fullText = "";
-  const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT);
-  let tn: Text | null;
-  while ((tn = walker.nextNode() as Text | null)) {
-    if (tn.parentElement?.classList.contains("select-none")) continue;
-    textNodes.push({ node: tn, start: fullText.length });
-    fullText += tn.textContent || "";
-  }
-
-  for (const ann of toRestore) {
     const snippet = ann.snippet;
     if (!snippet) continue;
 
+    // Rebuild after every inserted mark. Wrapping text splits and moves text
+    // nodes, so a cached offset map can point at stale DOM after the first hit.
+    const { fullText, textNodes } = buildTextIndex(container);
+
     // Find all occurrences of the snippet in the full text
     const occurrences: number[] = [];
     let searchFrom = 0;
@@ -181,6 +173,24 @@ export function restoreMarks(
   }
 }
 
+function buildTextIndex(container: HTMLElement): {
+  fullText: string;
+  textNodes: { node: Text; start: number }[];
+} {
+  const textNodes: { node: Text; start: number }[] = [];
+  let fullText = "";
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT);
+  let tn: Text | null;
+  while ((tn = walker.nextNode() as Text | null)) {
+    const parent = tn.parentElement;
+    if (parent?.classList.contains("select-none")) continue;
+    if (parent?.closest("[data-annotation-id]")) continue;
+    textNodes.push({ node: tn, start: fullText.length });
+    fullText += tn.textContent || "";
+  }
+  return { fullText, textNodes };
+}
+
 function offsetToNode(
   textNodes: { node: Text; start: number }[],
   offset: number