pmx-canvas 0.10.0 → 0.12.0

package/src/server/card-relocation.ts

@@ -0,0 +1,53 @@
+import type { Database } from 'bun:sqlite';
+
+/** JSON target list parameter; event ranges prevent a reused old ID inheriting the moved card's history. */
+export const CARD_HISTORY_CTE = `WITH RECURSIVE
+  targets AS (SELECT json_extract(value, '$.boardId') AS current_board,
+                     json_extract(value, '$.cardId') AS node_id FROM json_each(?)),
+  history(current_board, node_id, board_id, review_after, review_through, read_after, read_through, move_before) AS (
+    SELECT current_board, node_id, current_board,
+      COALESCE((SELECT MAX(review_through) FROM card_relocations r WHERE (r.from_board = t.current_board OR r.to_board = t.current_board) AND r.node_id = t.node_id), 0),
+      9223372036854775807,
+      COALESCE((SELECT MAX(read_through) FROM card_relocations r WHERE (r.from_board = t.current_board OR r.to_board = t.current_board) AND r.node_id = t.node_id), 0),
+      9223372036854775807, 9223372036854775807 FROM targets t
+    UNION ALL
+    SELECT h.current_board, h.node_id, r.from_board, r.review_after, r.review_through,
+      r.read_after, r.read_through, r.sequence
+    FROM history h JOIN card_relocations r ON r.to_board = h.board_id AND r.node_id = h.node_id
+    AND r.sequence = (SELECT MAX(sequence) FROM card_relocations prior
+      WHERE (prior.to_board = h.board_id OR prior.from_board = h.board_id)
+      AND prior.node_id = h.node_id AND prior.sequence < h.move_before)
+  )`;
+
+/** Record locations, not new reads or validations. Called inside the move transaction. */
+export function recordCardRelocation(
+  db: Database,
+  requestId: string,
+  from: string,
+  to: string,
+  nodeIds: string[],
+): void {
+  const reviewThrough = db
+    .query<{ value: number }, []>('SELECT COALESCE(MAX(sequence), 0) AS value FROM review_records')
+    .get()!.value;
+  const readThrough = db
+    .query<{ value: number }, []>('SELECT COALESCE(MAX(seq), 0) AS value FROM context_reads')
+    .get()!.value;
+  for (const id of nodeIds)
+    db.run(
+      `
+    INSERT INTO card_relocations(request_id, node_id, from_board, to_board, review_after, review_through, read_after, read_through)
+    VALUES (?, ?, ?, ?,
+      COALESCE((SELECT MAX(review_through) FROM card_relocations WHERE (from_board = ? OR to_board = ?) AND node_id = ?), 0), ?,
+      COALESCE((SELECT MAX(read_through) FROM card_relocations WHERE (from_board = ? OR to_board = ?) AND node_id = ?), 0), ?)`,
+      [requestId, id, from, to, from, from, id, reviewThrough, from, from, id, readThrough],
+    );
+}
+
+export function boardMoveBoundary(db: Database, boardId: string): string | null {
+  return (
+    db
+      .query<{ request_id: string }, [string]>('SELECT request_id FROM board_move_boundaries WHERE board_id = ?')
+      .get(boardId)?.request_id ?? null
+  );
+}

package/src/server/code-graph.ts

@@ -18,6 +18,7 @@ import { resolve, dirname, basename, extname, relative } from 'node:path';
 import { existsSync } from 'node:fs';
 import { canvasState } from './canvas-state.js';
 import type { CanvasNodeState, CanvasEdge } from './canvas-state.js';
+import { createBoardLocal } from './board-local.js';
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -176,7 +177,7 @@ function tryResolveWithExtensions(basePath: string): string | null {
 const AUTO_EDGE_PREFIX = 'codegraph-';
 
 /** Cache of last recomputed edges for buildCodeGraphSummary() to reuse. */
-let _lastDiscoveredEdges: CodeGraphEdge[] = [];
+const discovered = createBoardLocal(() => ({ edges: [] as CodeGraphEdge[] }));
 
 /**
  * Get all file nodes currently on the canvas.
@@ -263,7 +264,7 @@ export function recomputeCodeGraph(): CodeGraphEdge[] {
     }
   });
 
-  _lastDiscoveredEdges = discoveredEdges;
+  discovered.current.edges = discoveredEdges;
   return discoveredEdges;
 }
 
@@ -295,7 +296,7 @@ export function buildCodeGraphSummary(): CodeGraphSummary {
   for (const node of fileNodes) idToPath.set(node.id, node.data.path as string);
 
   // Group import specifiers by source node from cached edges
-  for (const edge of _lastDiscoveredEdges) {
+  for (const edge of discovered.current.edges) {
     const specs = importSpecs.get(edge.fromNodeId);
     if (specs && !specs.includes(edge.importSpecifier)) {
       specs.push(edge.importSpecifier);

package/src/server/context-reads.ts

@@ -6,9 +6,11 @@
  * recording never notifies (a read must not trigger more reads).
  */
 import type { Database } from 'bun:sqlite';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { CARD_HISTORY_CTE } from './card-relocation.js';
 import type { MemoryGraph } from '../shared/memory-graph.js';
 import type { CompiledContextEntry } from './context-brief.js';
+import { OperationError } from './operations/types.js';
 
 export const CONTEXT_READ_RETENTION = 5000;
 const CONTEXT_READ_DEFAULT_LIMIT = 50;
@@ -51,6 +53,8 @@ export interface ContextRead {
 }
 
 export type ContextReadInput = Omit<ContextRead, 'seq' | 'id' | 'at' | 'boardId' | 'readNodes' | 'seenLinks'> & {
+  /** Stable adapter receipt identity. Retries record this delivery once per consumer and board. */
+  deliveryId?: string;
   /** Explicit read target, captured before asynchronous formatting/proxy work. */
   boardId?: string | null;
   /** Ids of every serialized node in what the reader received; the server keeps those on the board. */
@@ -264,6 +268,7 @@ export function graphReads(
 }
 
 export const CONTEXT_READS_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS context_read_receipts (id TEXT PRIMARY KEY);
   CREATE TABLE IF NOT EXISTS context_reads (
     seq INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,
@@ -289,30 +294,47 @@ export function appendContextReadToDB(
   readNodes: Record<string, number> = {},
   seenLinks: Record<string, number> = {},
 ): ContextRead {
-  const id = `read-${randomUUID()}`;
-  const at = new Date().toISOString();
-  db.run(
-    'INSERT INTO context_reads (id, at, channel, resource, source, consumer, agent_id, pinned_node_ids, delivered_node_ids, bytes, board_id, read_nodes, seen_links) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
-    [
-      id,
-      at,
-      input.channel,
-      input.resource,
-      input.source,
-      input.consumer,
-      input.agentId,
-      JSON.stringify(input.pinnedNodeIds),
-      JSON.stringify(input.deliveredNodeIds),
-      input.bytes,
-      boardId,
-      JSON.stringify(readNodes),
-      JSON.stringify(seenLinks),
-    ],
-  );
-  const seq = Number(db.query<{ seq: number }, []>('SELECT last_insert_rowid() AS seq').get()?.seq ?? 0);
-  db.run('DELETE FROM context_reads WHERE seq <= ?', [seq - CONTEXT_READ_RETENTION]);
-  const { readNodeIds: _readNodeIds, seenNodeIds: _seenNodeIds, ...record } = input;
-  return { ...record, seq, id, at, boardId, readNodes, seenLinks };
+  return db.transaction(() => {
+    const id = input.deliveryId
+      ? `read-${createHash('sha256')
+          .update(JSON.stringify([input.source, input.consumer, boardId, input.deliveryId]))
+          .digest('hex')}`
+      : `read-${randomUUID()}`;
+    if (input.deliveryId) {
+      const existing = db.query<ContextReadRow, [string]>('SELECT * FROM context_reads WHERE id = ?').get(id);
+      if (existing) {
+        db.run('INSERT OR IGNORE INTO context_read_receipts VALUES (?)', [id]);
+        return rowToContextRead(existing);
+      }
+      if (db.query('SELECT id FROM context_read_receipts WHERE id = ?').get(id))
+        throw new OperationError('Context receipt expired. Obtain fresh context instead of retrying this token.', 409, {
+          code: 'context_receipt_expired',
+        });
+    }
+    const at = new Date().toISOString();
+    db.run(
+      'INSERT INTO context_reads (id, at, channel, resource, source, consumer, agent_id, pinned_node_ids, delivered_node_ids, bytes, board_id, read_nodes, seen_links) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO NOTHING',
+      [
+        id,
+        at,
+        input.channel,
+        input.resource,
+        input.source,
+        input.consumer,
+        input.agentId,
+        JSON.stringify(input.pinnedNodeIds),
+        JSON.stringify(input.deliveredNodeIds),
+        input.bytes,
+        boardId,
+        JSON.stringify(readNodes),
+        JSON.stringify(seenLinks),
+      ],
+    );
+    const row = db.query<ContextReadRow, [string]>('SELECT * FROM context_reads WHERE id = ?').get(id)!;
+    if (input.deliveryId) db.run('INSERT INTO context_read_receipts VALUES (?)', [id]);
+    db.run('DELETE FROM context_reads WHERE seq <= ?', [row.seq - CONTEXT_READ_RETENTION]);
+    return rowToContextRead(row);
+  })();
 }
 
 interface ContextReadRow {
@@ -351,27 +373,43 @@ function rowToContextRead(row: ContextReadRow): ContextRead {
   };
 }
 
+/** Read only the matching card's observation, not a copy of the whole receipt for every card. */
+function loadCardReads(db: Database, boardId: string, field: 'read_nodes' | 'seen_links') {
+  const ids = db
+    .query<{ id: string }, [string, string, string]>(`
+    SELECT id FROM nodes WHERE board_id = ?
+    UNION SELECT j.key AS id FROM context_reads r, json_each(r.read_nodes) j WHERE r.board_id = ?
+    UNION SELECT j.key AS id FROM context_reads r, json_each(r.seen_links) j WHERE r.board_id = ?
+  `)
+    .all(boardId, boardId, boardId);
+  return db
+    .query<{ nodeId: string; revision: number; at: string; who: string }, [string]>(`
+    ${CARD_HISTORY_CTE} SELECT h.node_id AS nodeId, j.value AS revision, r.at,
+      COALESCE(r.consumer, r.agent_id, r.source) AS who FROM history h JOIN context_reads r
+      ON r.board_id = h.board_id AND r.seq > h.read_after AND r.seq <= h.read_through
+      JOIN json_each(r.${field}) j ON j.key = h.node_id
+    ORDER BY r.seq DESC
+  `)
+    .all(JSON.stringify(ids.map(({ id }) => ({ boardId, cardId: id }))));
+}
+
 /** Per node on a board, the latest agent read that delivered its content (newest row wins). */
 export function loadNodeReadStatusFromDB(db: Database, boardId: string): NodeReadStatus[] {
-  const rows = db
-    .query<ContextReadRow, [string]>('SELECT * FROM context_reads WHERE board_id = ? ORDER BY seq DESC')
-    .all(boardId);
   const status = new Map<string, NodeReadStatus>();
-  for (const read of rows.map(rowToContextRead)) {
-    for (const [nodeId, readRevision] of Object.entries(read.readNodes)) {
-      const known = status.get(nodeId);
-      if (known) {
-        known.readCount += 1;
-        continue;
-      }
-      status.set(nodeId, {
-        nodeId,
-        lastReadAt: read.at,
-        lastReadBy: read.consumer ?? read.agentId ?? read.source,
-        readRevision,
-        readCount: 1,
-      });
+  for (const read of loadCardReads(db, boardId, 'read_nodes')) {
+    const nodeId = read.nodeId;
+    const known = status.get(nodeId);
+    if (known) {
+      known.readCount += 1;
+      continue;
     }
+    status.set(nodeId, {
+      nodeId,
+      lastReadAt: read.at,
+      lastReadBy: read.who,
+      readRevision: read.revision,
+      readCount: 1,
+    });
   }
   return [...status.values()];
 }
@@ -391,27 +429,17 @@ export function loadBoardLastReadFromDB(
 
 /** Per node on a board, the newest links revision any agent read has carried (connection marks). */
 export function loadSeenLinksFromDB(db: Database, boardId: string): Record<string, number> {
-  const rows = db
-    .query<{ seen_links: string }, [string]>('SELECT seen_links FROM context_reads WHERE board_id = ?')
-    .all(boardId);
   const seen: Record<string, number> = {};
-  for (const row of rows) {
-    for (const [nodeId, revision] of Object.entries(JSON.parse(row.seen_links) as Record<string, number>)) {
-      if (revision > (seen[nodeId] ?? -1)) seen[nodeId] = revision;
-    }
+  for (const { nodeId, revision } of loadCardReads(db, boardId, 'seen_links')) {
+    if (revision > (seen[nodeId] ?? -1)) seen[nodeId] = revision;
   }
   return seen;
 }
 
 /** Every node on a board whose content an agent read at or after `since` (ISO). */
 export function loadReadNodeIdsSince(db: Database, boardId: string, since: string): string[] {
-  const rows = db
-    .query<{ read_nodes: string }, [string, string]>(
-      'SELECT read_nodes FROM context_reads WHERE board_id = ? AND at >= ? ORDER BY seq',
-    )
-    .all(boardId, since);
   const ids = new Set<string>();
-  for (const row of rows) for (const id of Object.keys(JSON.parse(row.read_nodes) as object)) ids.add(id);
+  for (const row of loadCardReads(db, boardId, 'read_nodes')) if (row.at >= since) ids.add(row.nodeId);
   return [...ids];
 }