openwriter 0.13.0 → 0.14.0

package/dist/server/state.js

@@ -6,11 +6,43 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync, statSync, utimesSync } from 'fs';
 import { join } from 'path';
 import matter from 'gray-matter';
-import { tiptapToMarkdown, tiptapToBody, markdownToTiptap } from './markdown.js';
+import { tiptapToMarkdown, tiptapToMarkdownChecked, tiptapToBody, markdownToTiptap } from './markdown.js';
 import { applyTextEditsToNode } from './text-edit.js';
 import { getDataDir, TEMP_PREFIX, ensureDataDir, filePathForTitle, tempFilePath, generateNodeId, LEAF_BLOCK_TYPES, resolveDocPath, isExternalDoc, atomicWriteFileSync } from './helpers.js';
 import { snapshotIfNeeded, ensureDocId } from './versions.js';
 import { extractForwardLinks, extractForwardLinksFromDisk, updateBacklinksForSource } from './backlinks.js';
+import { isAutoAcceptInheritedForDoc } from './workspaces.js';
+import { matchNodes } from './node-matcher.js';
+import { tiptapToBlocks, applyIdsToTiptap } from './node-blocks.js';
+/** Read the persisted identity graph (nodes + graveyard) from a file's
+ *  frontmatter. This is the matcher's previousNodes baseline at save time —
+ *  the disk is the source of truth, not a parallel in-memory cache. Returns
+ *  empty arrays for a brand-new file or unreadable frontmatter. */
+function readPersistedIdentity(filePath) {
+    if (!filePath || !existsSync(filePath))
+        return { previousNodes: [], graveyard: [] };
+    try {
+        const raw = readFileSync(filePath, 'utf-8');
+        const { data } = matter(raw);
+        return {
+            previousNodes: normalizeNodeEntries(data.nodes),
+            graveyard: normalizeNodeEntries(data.graveyard),
+        };
+    }
+    catch {
+        return { previousNodes: [], graveyard: [] };
+    }
+}
+/** Defensive parse of frontmatter node entries — drops any malformed rows.
+ *  Mirrors the same-named helper in markdown-parse.ts so save and load apply
+ *  identical validation. */
+function normalizeNodeEntries(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((entry) => entry && typeof entry === 'object' && entry.id && entry.fp)
+        .map((entry) => ({ id: String(entry.id), fingerprint: entry.fp }));
+}
 const DEFAULT_DOC = {
     type: 'doc',
     content: [{ type: 'paragraph', content: [] }],
@@ -577,43 +609,109 @@ function applyChangesToDoc(doc, changes, autoAccept = false) {
             const found = findNode(doc.content, change.nodeId, doc.content);
             if (!found)
                 continue;
-            const contentArray = Array.isArray(change.content) ? change.content : [change.content];
+            let contentArray = Array.isArray(change.content) ? change.content : [change.content];
             const originalNode = structuredClone(found.parent[found.index]);
+            // Preserve target node type when plain text would otherwise demote it.
+            // Markdown-it parses plain text as a paragraph, so rewriting a heading or
+            // list item with plain prose silently changes the type. Two adaptations:
+            //   - Block wrappers (listItem, blockquote) wrap the parsed paragraph as
+            //     their child, keeping the wrapper's type and attrs.
+            //   - Inline-content leaves (heading, codeBlock) take the paragraph's
+            //     inline text and host it inside the original type, preserving level
+            //     and other attrs.
+            // Explicit markdown (e.g. "## Foo", "- bar") still wins because the
+            // parser produces a matching node type before we get here.
+            const targetType = originalNode.type;
+            const parsedType = contentArray[0]?.type;
+            const BLOCK_WRAPPERS = new Set(['listItem', 'blockquote']);
+            const INLINE_LEAVES = new Set(['heading', 'codeBlock']);
+            let isWrappedRewrite = false;
+            if (parsedType === 'paragraph' && targetType !== 'paragraph') {
+                if (BLOCK_WRAPPERS.has(targetType)) {
+                    contentArray = [{
+                            type: targetType,
+                            attrs: { ...originalNode.attrs },
+                            content: contentArray,
+                        }];
+                    isWrappedRewrite = true;
+                }
+                else if (INLINE_LEAVES.has(targetType)) {
+                    // Standard stamping handles the leaf case — heading/codeBlock are
+                    // themselves the decoration target, so no special branch needed below.
+                    contentArray = [{
+                            type: targetType,
+                            attrs: { ...originalNode.attrs },
+                            content: contentArray[0].content || [],
+                        }];
+                }
+            }
             // Empty node rewrite → treat as insert (green, not blue)
             const originalText = extractText(originalNode.content || []);
             const isEmptyNode = !originalText.trim();
             // Only store original on first rewrite (preserve baseline for reject)
             const existingOriginal = found.parent[found.index].attrs?.pendingOriginalContent;
             // Detect partial change: if only a sub-range of the node text changed,
-            // attach selection range attrs so the frontend decorates only that part
+            // attach selection range attrs so the frontend decorates only that part.
+            // For wrapped rewrites (listItem), compare paragraph content against the
+            // listItem's inner paragraph so offsets align with what the user sees.
             let partialRange = null;
             if (!isEmptyNode && contentArray.length === 1 && !autoAccept) {
-                // Use true original for partial range when a prior pending rewrite exists,
-                // so offsets align with pendingOriginalContent
-                const baseContent = existingOriginal?.content || originalNode.content || [];
-                partialRange = computePartialRange(baseContent, contentArray[0].content || []);
+                const baseContent = isWrappedRewrite
+                    ? (existingOriginal?.content?.[0]?.content || originalNode.content?.[0]?.content || [])
+                    : (existingOriginal?.content || originalNode.content || []);
+                const newContent = isWrappedRewrite
+                    ? (contentArray[0].content?.[0]?.content || [])
+                    : (contentArray[0].content || []);
+                partialRange = computePartialRange(baseContent, newContent);
+            }
+            // Build first node. For wrapped rewrites, pendingStatus and related attrs
+            // belong on the inner leaf (paragraph) so the decoration renderer — which
+            // keys off LEAF_BLOCK_TYPES — picks them up. The wrapper keeps the original
+            // node's id/attrs so subsequent calls can still target it.
+            let firstNode;
+            if (isWrappedRewrite && !autoAccept) {
+                const innerLeaf = contentArray[0].content?.[0] || { type: 'paragraph', content: [] };
+                const innerWithPending = {
+                    ...innerLeaf,
+                    attrs: {
+                        ...innerLeaf.attrs,
+                        id: innerLeaf.attrs?.id || generateNodeId(),
+                        pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
+                        ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
+                        ...(partialRange ? {
+                            pendingSelectionFrom: partialRange.selectionFrom,
+                            pendingSelectionTo: partialRange.selectionTo,
+                            pendingOriginalFrom: partialRange.originalFrom,
+                            pendingOriginalTo: partialRange.originalTo,
+                        } : {}),
+                    },
+                };
+                firstNode = {
+                    type: 'listItem',
+                    attrs: { ...contentArray[0].attrs, id: change.nodeId },
+                    content: [innerWithPending, ...contentArray[0].content.slice(1)],
+                };
+            }
+            else {
+                firstNode = {
+                    ...contentArray[0],
+                    attrs: autoAccept ? {
+                        ...contentArray[0].attrs,
+                        id: change.nodeId,
+                    } : {
+                        ...contentArray[0].attrs,
+                        id: change.nodeId,
+                        pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
+                        ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
+                        ...(partialRange ? {
+                            pendingSelectionFrom: partialRange.selectionFrom,
+                            pendingSelectionTo: partialRange.selectionTo,
+                            pendingOriginalFrom: partialRange.originalFrom,
+                            pendingOriginalTo: partialRange.originalTo,
+                        } : {}),
+                    },
+                };
             }
-            // First node replaces the target (rewrite or insert if empty).
-            // In autoAccept mode, omit all pendingStatus/pendingOriginalContent attrs
-            // so the change commits cleanly with no review surface.
-            const firstNode = {
-                ...contentArray[0],
-                attrs: autoAccept ? {
-                    ...contentArray[0].attrs,
-                    id: change.nodeId,
-                } : {
-                    ...contentArray[0].attrs,
-                    id: change.nodeId,
-                    pendingStatus: isEmptyNode ? 'insert' : 'rewrite',
-                    ...(isEmptyNode ? {} : { pendingOriginalContent: existingOriginal || originalNode }),
-                    ...(partialRange ? {
-                        pendingSelectionFrom: partialRange.selectionFrom,
-                        pendingSelectionTo: partialRange.selectionTo,
-                        pendingOriginalFrom: partialRange.originalFrom,
-                        pendingOriginalTo: partialRange.originalTo,
-                    } : {}),
-                },
-            };
             // Additional nodes get inserted after — as pending inserts in normal mode,
             // as plain blocks in autoAccept mode.
             const extraNodes = contentArray.slice(1).map((node) => ({
@@ -741,17 +839,11 @@ function applyChangesToDoc(doc, changes, autoAccept = false) {
 export function isAutoAcceptActive(filename, metadata) {
     if (metadata?.autoAccept === true)
         return true;
+    if (metadata?.autoAccept === false)
+        return false; // explicit doc-level override of inheritance
     if (!filename)
         return false;
-    // Lazy import to avoid circular dep between state.ts and workspaces.ts
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { isAutoAcceptInheritedForDoc } = require('./workspaces.js');
-        return isAutoAcceptInheritedForDoc(filename);
-    }
-    catch {
-        return false;
-    }
+    return isAutoAcceptInheritedForDoc(filename);
 }
 /** Apply changes to the active document singleton. */
 function applyChangesToDocument(changes) {
@@ -789,7 +881,12 @@ export function applyTextEdits(nodeId, edits) {
         }]);
     return { success: true };
 }
-/** Set the active document state. Used by documents.ts for multi-doc operations. */
+/** Set the active document state. Used by documents.ts for multi-doc operations.
+ *
+ *  Identity tracking is NOT cached on PadState — the save-time matcher reads
+ *  previousNodes + graveyard directly from disk frontmatter every write
+ *  (Option B in adr/node-identity-matcher.md). Markdown is the source of
+ *  truth; memory is an ephemeral working copy. */
 export function setActiveDocument(doc, title, filePath, isTemp, lastModified, metadata, originalFrontmatter) {
     state.document = doc;
     state.title = title;
@@ -869,7 +966,11 @@ function populatePendingCache() {
     }
 }
 const docCache = new Map(); // key = filePath
-/** Cache the active document's full state, keyed by filePath. Call after save(). */
+/** Cache the active document's full state, keyed by filePath. Call after save().
+ *
+ *  Identity (nodes + graveyard) is NOT cached — the save-time matcher reads
+ *  it from disk frontmatter each write, so the cache stays a pure content
+ *  snapshot. */
 export function cacheActiveDocument() {
     if (!state.filePath)
         return;
@@ -1054,7 +1155,36 @@ function writeToDisk() {
             : body;
     }
     else {
-        markdown = tiptapToMarkdown(state.document, state.title, state.metadata);
+        // Save-time matcher pass (Option B: disk is the source of truth).
+        //
+        // Read the existing file's frontmatter to recover previousNodes +
+        // graveyard, run the matcher against the current TipTap tree, and apply
+        // pinned IDs back onto the tree. Without this, type-change and
+        // graveyard-restore never fire within a session — the editor mints fresh
+        // IDs at insert time and the load-time matcher only sees the post-edit
+        // state. Memory holds no identity cache; identity always re-derives from
+        // disk at the save boundary.
+        //
+        // adr: adr/node-identity-matcher.md
+        const { previousNodes, graveyard } = readPersistedIdentity(state.filePath);
+        let nextGraveyard = graveyard;
+        if (previousNodes.length > 0) {
+            const newBlocks = tiptapToBlocks(state.document);
+            const matchResult = matchNodes(previousNodes, newBlocks, { graveyard });
+            const pinnedByPosition = new Map();
+            for (const p of matchResult.pinned)
+                pinnedByPosition.set(p.position, p.id);
+            applyIdsToTiptap(state.document, pinnedByPosition);
+            nextGraveyard = matchResult.nextGraveyard;
+        }
+        // Pass graveyard through metadata so the serializer can emit it in frontmatter.
+        const metaWithGraveyard = nextGraveyard.length > 0
+            ? { ...state.metadata, graveyard: nextGraveyard.map((g) => ({ id: g.id, fp: g.fingerprint })) }
+            : state.metadata;
+        // Checked serializer — verifies the TipTap → markdown → TipTap round-trip
+        // preserves block shape. Logs to console on drift; never blocks the save.
+        const result = tiptapToMarkdownChecked(state.document, state.title, metaWithGraveyard);
+        markdown = result.markdown;
     }
     if (existsSync(state.filePath)) {
         // Skip write if content is identical (prevents phantom git changes on doc switch)
@@ -1448,12 +1578,8 @@ export function setAutoAcceptOnFile(filename, enabled) {
     try {
         const raw = readFileSync(targetPath, 'utf-8');
         const parsed = markdownToTiptap(raw);
-        if (enabled) {
-            parsed.metadata.autoAccept = true;
-        }
-        else {
-            delete parsed.metadata.autoAccept;
-        }
+        // Explicit false (not delete) so the user's "off" overrides any workspace inheritance.
+        parsed.metadata.autoAccept = enabled;
         let markdown;
         if (isExternalDoc(targetPath)) {
             const body = tiptapToBody(parsed.document);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "The open-source writing surface for AI agents. Markdown-native editor with pending change review — your agent writes, you accept or reject.",
   "type": "module",
   "license": "MIT",

package/skill/SKILL.md

@@ -205,6 +205,7 @@ For making changes to existing documents — rewrites, insertions, deletions:
 - Always `read_pad` before editing to get fresh node IDs
 - Respect `pendingChanges > 0` — wait for the user to accept/reject before sending more
 - Content accepts markdown strings (preferred) or TipTap JSON
+- **`rewrite` preserves the target node's type.** Sending plain prose to rewrite a heading keeps it a heading; the same for list items and blockquotes. To intentionally change a node's type, use `delete` + `insert`. For surgical text-only edits inside a node (no risk of restructuring), `edit_text` is the smaller hammer.
 - Decoration colors: **blue** = rewrite, **green** = insert, **red** = delete
 - **Never re-populate a document to fix it.** `populate_document` re-sends the entire document body — extremely token-expensive. To remove nodes, use `write_to_pad` with `{ operation: "delete", nodeId: "..." }`. To fix content, use `rewrite`. Only use `populate_document` once during initial creation, or as a last resort if the document is severely broken.