agent-canvas 0.1.39 → 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;
+}