npm - openwriter - Versions diffs - 0.12.0 → 0.13.0 - Mend

openwriter 0.12.0 → 0.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/dist/bin/pad.js +101 -146
package/dist/client/assets/index-BlLnLdoc.js +212 -0
package/dist/client/assets/{index-CRImKlcp.css → index-OV13QtgQ.css} +1 -1
package/dist/client/index.html +2 -2
package/dist/server/backlinks.js +323 -0
package/dist/server/index.js +130 -1
package/dist/server/markdown-parse.js +45 -6
package/dist/server/markdown-serialize.js +10 -2
package/dist/server/marks.js +9 -0
package/dist/server/mcp.js +148 -6
package/dist/server/state.js +47 -6
package/dist/server/workspace-routes.js +31 -3
package/dist/server/workspaces.js +85 -0
package/package.json +1 -1
package/skill/SKILL.md +3 -7
package/dist/client/assets/index-CNmzNvB_.js +0 -211
package/skill/docs/anti-ai.md +0 -71
package/skill/docs/voices.md +0 -88
package/skill/voices/authority.md +0 -102
package/skill/voices/business.md +0 -103
package/skill/voices/logical.md +0 -104
package/skill/voices/provocateur.md +0 -101
package/skill/voices/storyteller.md +0 -104

package/dist/client/index.html CHANGED Viewed

@@ -10,8 +10,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Charter:ital,wght@0,400;0,700;1,400&family=Crimson+Pro:ital,wght@0,300;0,400;0,600;0,700;1,400&family=DM+Sans:ital,wght@0,400;0,500;0,600;0,700;1,400&family=DM+Serif+Display&family=IBM+Plex+Mono:wght@400;500;600&family=IBM+Plex+Sans:wght@400;500;600&family=Inter:wght@400;500;600;700&family=Libre+Baskerville:ital,wght@0,400;0,700;1,400&family=Literata:ital,opsz,wght@0,7..72,400;0,7..72,600;0,7..72,700;1,7..72,400&family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,600;1,6..72,400&family=Playfair+Display:wght@400;600;700;900&family=Source+Serif+4:ital,opsz,wght@0,8..60,400;0,8..60,600;0,8..60,700;1,8..60,400&family=Space+Grotesk:wght@400;500;600;700&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-CNmzNvB_.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CRImKlcp.css">
+    <script type="module" crossorigin src="/assets/index-BlLnLdoc.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-OV13QtgQ.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/backlinks.js ADDED Viewed

@@ -0,0 +1,323 @@
+/**
+ * Backlinks engine: keeps each doc's frontmatter `backlinks` field in sync
+ * with the forward links pointing at it from other docs.
+ *
+ * Design:
+ *   - Forward links in prose = source of truth (link mark with `doc:` href).
+ *   - Backlinks frontmatter = derived projection, eventually consistent.
+ *   - Incremental on save: when a doc's forward links change, only the
+ *     affected target docs get their backlinks refreshed.
+ *   - Full rebuild via /api/rebuild-backlinks (idempotent rescue path).
+ *
+ * Frontmatter schema (lean — anchor text + refs only, no snippet/context):
+ *   backlinks:
+ *     - text: "the territorial imperative"
+ *       from_doc: a3f2c1d4         # source docId
+ *       from_node: f6c3830d        # source nodeId where link mark lives
+ *       to_node: 1a2b3c4d          # optional: target nodeId being linked to
+ */
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import matter from 'gray-matter';
+import { getDataDir, atomicWriteFileSync, resolveDocPath, isExternalDoc } from './helpers.js';
+import { filenameByDocId } from './documents.js';
+import { markdownToTiptap } from './markdown-parse.js';
+const HEX8 = /^[a-f0-9]{8}$/;
+const ANCHOR_TEXT_MAX = 80; // truncate long anchor text in backlinks frontmatter
+/** Parse the post-`doc:` portion of an href into {docId, nodeId}. Mirrors src/editor/link-href.ts. */
+function parseDocHref(href) {
+    if (!href.startsWith('doc:'))
+        return { docId: null, nodeId: null };
+    let body = href.slice(4);
+    // Strip query string (?q=...) — only needed for client-side scroll
+    const qIdx = body.indexOf('?q=');
+    if (qIdx >= 0)
+        body = body.slice(0, qIdx);
+    // Split fragment
+    let target = body, nodeId = null;
+    const hashIdx = body.indexOf('#');
+    if (hashIdx >= 0) {
+        const frag = body.slice(hashIdx + 1);
+        nodeId = HEX8.test(frag) ? frag : null;
+        target = body.slice(0, hashIdx);
+    }
+    return {
+        docId: HEX8.test(target) ? target : null,
+        nodeId,
+    };
+}
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return s.slice(0, n - 1) + '…';
+}
+/**
+ * Walk a TipTap doc, return every `doc:` link found.
+ * Each entry includes the enclosing block's nodeId (from_node) and the
+ * anchor text (the text wrapped by the link mark).
+ */
+export function extractForwardLinks(doc, sourceDocId) {
+    const links = [];
+    function walkBlock(block) {
+        if (!block)
+            return;
+        const blockId = block.attrs?.id;
+        if (Array.isArray(block.content)) {
+            // Inline pass: collect contiguous text runs with same link mark
+            // (a mark may span multiple text nodes if other marks toggle inside)
+            let currentHref = null;
+            let currentText = [];
+            const flush = () => {
+                if (currentHref && currentText.length > 0 && blockId) {
+                    const parsed = parseDocHref(currentHref);
+                    if (parsed.docId) {
+                        links.push({
+                            text: truncate(currentText.join(''), ANCHOR_TEXT_MAX),
+                            from_doc: sourceDocId,
+                            from_node: blockId,
+                            to_doc: parsed.docId,
+                            ...(parsed.nodeId ? { to_node: parsed.nodeId } : {}),
+                        });
+                    }
+                }
+                currentText = [];
+            };
+            for (const child of block.content) {
+                if (child.type === 'text') {
+                    const linkMark = (child.marks || []).find((m) => m.type === 'link');
+                    const href = linkMark?.attrs?.href || null;
+                    if (href !== currentHref) {
+                        flush();
+                        currentHref = href;
+                    }
+                    if (href && child.text)
+                        currentText.push(child.text);
+                }
+                else {
+                    flush();
+                    currentHref = null;
+                    // Recurse into nested block-level content (e.g., listItem -> paragraph)
+                    walkBlock(child);
+                }
+            }
+            flush();
+            // Also recurse for blocks whose content is sub-blocks (list, blockquote)
+            for (const child of block.content) {
+                if (child.type && child.type !== 'text' && Array.isArray(child.content)) {
+                    // Already handled above via flush() recursion guard — skip duplicate
+                    // (We need to recurse into blocks that contain block-level content,
+                    //  but not the text children we already iterated.)
+                }
+            }
+        }
+    }
+    if (doc?.content) {
+        for (const node of doc.content)
+            walkBlock(node);
+    }
+    return links;
+}
+/**
+ * Read a doc's frontmatter from disk and parse it.
+ * Returns null if the file doesn't exist or can't be parsed.
+ */
+function readFrontmatter(filename) {
+    try {
+        const filePath = resolveDocPath(filename);
+        if (!existsSync(filePath))
+            return null;
+        const raw = readFileSync(filePath, 'utf-8');
+        const parsed = matter(raw);
+        return { data: parsed.data, content: parsed.content, rawMatter: parsed.matter };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write a doc's file with updated frontmatter (preserves body verbatim).
+ * Only touches the frontmatter — does NOT re-serialize the body, which would
+ * lose nodeIds and reformat. This is safe to call on non-active docs.
+ */
+function writeFrontmatter(filename, newData) {
+    const filePath = resolveDocPath(filename);
+    const raw = readFileSync(filePath, 'utf-8');
+    const parsed = matter(raw);
+    // Clean up: drop null/undefined fields
+    for (const key of Object.keys(newData)) {
+        if (newData[key] === undefined || newData[key] === null)
+            delete newData[key];
+        else if (Array.isArray(newData[key]) && newData[key].length === 0)
+            delete newData[key];
+    }
+    // Match the project convention: JSON-encoded YAML frontmatter
+    const newFrontmatter = `---\n${JSON.stringify(newData)}\n---\n\n${parsed.content.trimStart()}`;
+    // Avoid no-op writes
+    if (newFrontmatter === raw)
+        return;
+    atomicWriteFileSync(filePath, newFrontmatter);
+}
+/** Convert ForwardLinks targeting a given doc into Backlink entries for its frontmatter. */
+function toBacklinks(targetDocId, allLinks) {
+    return allLinks
+        .filter((l) => l.to_doc === targetDocId)
+        .map((l) => {
+        const entry = {
+            text: l.text,
+            from_doc: l.from_doc,
+            from_node: l.from_node,
+        };
+        if (l.to_node)
+            entry.to_node = l.to_node;
+        return entry;
+    });
+}
+/**
+ * Incremental update: source doc's forward links changed from oldLinks to newLinks.
+ * Update each affected target doc's backlinks frontmatter.
+ *
+ * If `currentDocMetadata` is provided, it's the live in-memory metadata for the
+ * source doc (the active doc). The caller is responsible for persisting it.
+ * For OTHER target docs we touch their files directly.
+ */
+export function updateBacklinksForSource(sourceDocId, newLinks, oldLinks) {
+    const oldTargets = new Set(oldLinks.map((l) => l.to_doc));
+    const newTargets = new Set(newLinks.map((l) => l.to_doc));
+    const affected = new Set([...oldTargets, ...newTargets]);
+    const touched = [];
+    for (const targetDocId of affected) {
+        if (targetDocId === sourceDocId)
+            continue; // Skip self-links (rare; if any, handled by caller)
+        const targetFilename = filenameByDocId(targetDocId);
+        if (!targetFilename) {
+            // Target doc not found anywhere — broken link, source-side surface added in a follow-up
+            continue;
+        }
+        const fm = readFrontmatter(targetFilename);
+        if (!fm)
+            continue;
+        // Pull all existing backlinks, drop ones from this source, then add new
+        const existing = Array.isArray(fm.data.backlinks) ? fm.data.backlinks : [];
+        const kept = existing.filter((b) => b.from_doc !== sourceDocId);
+        const fromThisSource = newLinks
+            .filter((l) => l.to_doc === targetDocId)
+            .map((l) => {
+            const entry = {
+                text: l.text,
+                from_doc: l.from_doc,
+                from_node: l.from_node,
+            };
+            if (l.to_node)
+                entry.to_node = l.to_node;
+            return entry;
+        });
+        const updated = [...kept, ...fromThisSource];
+        // Stable ordering for diff-friendliness: by from_doc, from_node
+        updated.sort((a, b) => {
+            if (a.from_doc !== b.from_doc)
+                return a.from_doc < b.from_doc ? -1 : 1;
+            return a.from_node < b.from_node ? -1 : 1;
+        });
+        const newData = { ...fm.data };
+        if (updated.length > 0)
+            newData.backlinks = updated;
+        else
+            delete newData.backlinks;
+        try {
+            writeFrontmatter(targetFilename, newData);
+            touched.push(targetDocId);
+        }
+        catch {
+            // Best-effort — skip on error
+        }
+    }
+    return { touched };
+}
+/**
+ * Read all docs in the data dir, return their parsed frontmatter + tiptap doc.
+ * Used by full rebuild.
+ */
+function loadAllDocsForRebuild() {
+    const out = [];
+    let files = [];
+    try {
+        files = readdirSync(getDataDir()).filter((f) => f.endsWith('.md'));
+    }
+    catch {
+        return out;
+    }
+    for (const f of files) {
+        try {
+            const raw = readFileSync(join(getDataDir(), f), 'utf-8');
+            const parsed = markdownToTiptap(raw);
+            const docId = parsed.metadata?.docId;
+            if (!docId)
+                continue;
+            out.push({ docId, filename: f, doc: parsed.document });
+        }
+        catch {
+            // skip unreadable
+        }
+    }
+    return out;
+}
+/**
+ * Full rebuild: scan all docs, compute backlinks for each from scratch,
+ * write updated frontmatter to docs whose backlinks changed.
+ * Idempotent. Run via /api/rebuild-backlinks.
+ */
+export function rebuildAllBacklinks() {
+    const allDocs = loadAllDocsForRebuild();
+    // Collect every forward link in the workspace
+    const allLinks = [];
+    for (const d of allDocs) {
+        allLinks.push(...extractForwardLinks(d.doc, d.docId));
+    }
+    // For each doc, compute its inbound = backlinks, write if changed
+    let updated = 0;
+    for (const d of allDocs) {
+        const newBacklinks = toBacklinks(d.docId, allLinks);
+        newBacklinks.sort((a, b) => {
+            if (a.from_doc !== b.from_doc)
+                return a.from_doc < b.from_doc ? -1 : 1;
+            return a.from_node < b.from_node ? -1 : 1;
+        });
+        const fm = readFrontmatter(d.filename);
+        if (!fm)
+            continue;
+        const existing = Array.isArray(fm.data.backlinks) ? fm.data.backlinks : [];
+        if (JSON.stringify(existing) === JSON.stringify(newBacklinks))
+            continue;
+        const newData = { ...fm.data };
+        if (newBacklinks.length > 0)
+            newData.backlinks = newBacklinks;
+        else
+            delete newData.backlinks;
+        try {
+            writeFrontmatter(d.filename, newData);
+            updated++;
+        }
+        catch {
+            // skip
+        }
+    }
+    return { scanned: allDocs.length, updated };
+}
+/**
+ * Read previously-saved markdown from disk for a given source filename
+ * and extract its forward links. Used by the save hook to compute the
+ * "old" link set before the new write lands.
+ */
+export function extractForwardLinksFromDisk(filename, sourceDocId) {
+    try {
+        const filePath = resolveDocPath(filename);
+        if (isExternalDoc(filename) || !existsSync(filePath))
+            return [];
+        const raw = readFileSync(filePath, 'utf-8');
+        const parsed = markdownToTiptap(raw);
+        return extractForwardLinks(parsed.document, sourceDocId);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/server/index.js CHANGED Viewed

@@ -34,7 +34,7 @@ import { createTaskRouter } from './task-routes.js';
 import { platformFetch, isAuthenticated } from './connections.js';
 import { PluginManager } from './plugin-manager.js';
 import { checkForUpdate, getUpdateInfo, getCurrentVersion } from './update-check.js';
-import { addMark, getMarks, resolveMarks } from './marks.js';
+import { addMark, getMarks, resolveMarks, editMark } from './marks.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 export async function startHttpServer(options = {}) {
@@ -191,6 +191,55 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // Toggle auto-accept on a workspace or container. Inherits to every doc inside.
+    // Body: { wsFile, containerId?, enabled }. Omit containerId to target the
+    // whole workspace; pass it to target a specific container.
+    app.post('/api/auto-accept/inherit', async (req, res) => {
+        try {
+            const wsFile = req.body?.wsFile;
+            const containerId = req.body?.containerId;
+            const enabled = req.body?.enabled === true;
+            if (!wsFile)
+                return res.status(400).json({ error: 'wsFile required' });
+            const { setWorkspaceAutoAccept, setContainerAutoAccept, collectFilesInWorkspace, collectFilesInContainer } = await import('./workspaces.js');
+            if (containerId) {
+                setContainerAutoAccept(wsFile, containerId, enabled);
+            }
+            else {
+                setWorkspaceAutoAccept(wsFile, enabled);
+            }
+            // If enabling, sweep any in-flight pending changes on every affected doc.
+            // (Pure inheritance leaves doc flags alone, but existing pending decorations
+            //  should clear so the user enters a clean draft state.)
+            const affected = containerId ? collectFilesInContainer(wsFile, containerId) : collectFilesInWorkspace(wsFile);
+            if (enabled) {
+                const activeFn = getActiveFilename();
+                for (const file of affected) {
+                    if (file === activeFn) {
+                        stripPendingAttrs();
+                    }
+                    else {
+                        stripPendingAttrsFromFile(file, true);
+                    }
+                }
+                if (affected.includes(activeFn)) {
+                    save();
+                    updatePendingCacheForActiveDoc();
+                }
+            }
+            broadcastWorkspacesChanged();
+            broadcastDocumentsChanged();
+            broadcastPendingDocsChanged();
+            // Surface metadata change for the active doc so the editor banner updates.
+            if (affected.includes(getActiveFilename())) {
+                broadcastMetadataChanged(getMetadata());
+            }
+            res.json({ success: true, affected: affected.length });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.post('/api/save', (_req, res) => {
         save();
         res.json({ success: true });
@@ -226,6 +275,67 @@ export async function startHttpServer(options = {}) {
     app.get('/api/documents', (_req, res) => {
         res.json(listDocuments());
     });
+    // Backlinks: full rebuild across all docs (idempotent rescue path).
+    // The normal flow updates backlinks incrementally on each save; this endpoint
+    // exists for repair after external edits or to bootstrap an unmigrated workspace.
+    app.post('/api/rebuild-backlinks', async (_req, res) => {
+        try {
+            const { rebuildAllBacklinks } = await import('./backlinks.js');
+            const result = rebuildAllBacklinks();
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // List a doc's block-level paragraphs/headings for the manual paragraph-target
+    // picker in the right-click "Link to doc" UI. Returns nodeId + type + level +
+    // a short text preview per block. Active doc reads from in-memory state; other
+    // docs are parsed from disk.
+    app.get('/api/documents/by-doc-id/:docId/paragraphs', async (req, res) => {
+        try {
+            const { resolveDocId } = await import('./documents.js');
+            const filename = resolveDocId(req.params.docId);
+            const activeFilename = getActiveFilename();
+            let doc;
+            if (filename === activeFilename) {
+                doc = getDocument();
+            }
+            else {
+                const filePath = resolveDocPath(filename);
+                const raw = readFileSync(filePath, 'utf-8');
+                const parsed = markdownToTiptap(raw);
+                doc = parsed.document;
+            }
+            const out = [];
+            function walk(nodes) {
+                for (const node of nodes) {
+                    if (node.type === 'heading' || node.type === 'paragraph') {
+                        const text = (node.content || [])
+                            .map((c) => (c.type === 'text' ? (c.text || '') : ''))
+                            .join('')
+                            .trim();
+                        if (!text)
+                            continue; // skip empty paragraphs
+                        const preview = text.length > 80 ? text.slice(0, 79) + '…' : text;
+                        const entry = { nodeId: node.attrs?.id || '', type: node.type, preview };
+                        if (node.type === 'heading')
+                            entry.level = node.attrs?.level || 1;
+                        if (entry.nodeId)
+                            out.push(entry);
+                    }
+                    else if (Array.isArray(node.content)) {
+                        walk(node.content);
+                    }
+                }
+            }
+            walk(doc.content || []);
+            res.json({ paragraphs: out });
+        }
+        catch (err) {
+            res.status(404).json({ error: err.message });
+        }
+    });
     app.get('/api/documents/:filename/text', (req, res) => {
         try {
             const filepath = resolveDocPath(req.params.filename);
@@ -529,6 +639,25 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    app.patch('/api/marks', (req, res) => {
+        try {
+            const { filename, id, note } = req.body;
+            if (!filename || !id || typeof note !== 'string') {
+                res.status(400).json({ error: 'filename, id, and note are required' });
+                return;
+            }
+            const mark = editMark(filename, id, note);
+            if (!mark) {
+                res.status(404).json({ error: 'mark not found' });
+                return;
+            }
+            broadcastMarksChanged(filename);
+            res.json({ success: true, mark });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.delete('/api/marks', (req, res) => {
         try {
             const { ids } = req.body;

package/dist/server/markdown-parse.js CHANGED Viewed

@@ -116,19 +116,21 @@ function tokensToTiptap(tokens) {
         if (token.type === 'heading_open') {
             const level = parseInt(token.tag.slice(1));
             const inlineToken = tokens[i + 1];
-            const content = inlineToken?.children ? inlineTokensToTiptap(inlineToken.children) : [];
-            nodes.push({ type: 'heading', attrs: { id: generateNodeId(), level }, content });
+            const rawContent = inlineToken?.children ? inlineTokensToTiptap(inlineToken.children) : [];
+            const { content, id } = extractTrailingNodeId(rawContent);
+            nodes.push({ type: 'heading', attrs: { id: id || generateNodeId(), level }, content });
             i += 3;
         }
         else if (token.type === 'paragraph_open') {
             const inlineToken = tokens[i + 1];
-            const content = inlineToken?.children ? inlineTokensToTiptap(inlineToken.children) : [];
+            const rawContent = inlineToken?.children ? inlineTokensToTiptap(inlineToken.children) : [];
+            const { content, id } = extractTrailingNodeId(rawContent);
             // Check for solo image — promote to block-level image node
             if (content.length === 1 && content[0].type === 'image') {
                 nodes.push(content[0]);
             }
             else {
-                nodes.push({ type: 'paragraph', attrs: { id: generateNodeId() }, content });
+                nodes.push({ type: 'paragraph', attrs: { id: id || generateNodeId() }, content });
             }
             i += 3;
         }
@@ -168,10 +170,18 @@ function tokensToTiptap(tokens) {
             i += 1;
         }
         else if (token.type === 'html_block') {
-            // <!-- --> is our sentinel for empty paragraphs
-            if (token.content.trim() === '<!-- -->') {
+            // <!-- --> is our sentinel for empty paragraphs.
+            // <!-- ^abc12345 --> is the same sentinel with a persisted nodeId.
+            const trimmed = token.content.trim();
+            if (trimmed === '<!-- -->') {
                 nodes.push({ type: 'paragraph', attrs: { id: generateNodeId() }, content: [] });
             }
+            else {
+                const idMatch = trimmed.match(/^<!--\s*\^([a-f0-9]{8})\s*-->$/);
+                if (idMatch) {
+                    nodes.push({ type: 'paragraph', attrs: { id: idMatch[1] }, content: [] });
+                }
+            }
             i += 1;
         }
         else if (token.type === 'table_open') {
@@ -440,3 +450,32 @@ function popMarkByType(stack, type) {
         }
     }
 }
+/**
+ * Extract a trailing nodeId anchor from inline content.
+ * Format: ` ^abc12345` (space + caret + 8 lowercase hex chars at end of line).
+ * Matches Obsidian's block-reference convention. Strips the marker from the
+ * visible text and returns the captured id. Returns id=null if no anchor found.
+ *
+ * Known limit: prose ending with the literal pattern ` ^[8 lowercase hex]`
+ * will be interpreted as an anchor. Vanishingly rare in real writing.
+ */
+function extractTrailingNodeId(content) {
+    if (!content || content.length === 0)
+        return { content, id: null };
+    const lastNode = content[content.length - 1];
+    if (lastNode.type !== 'text' || !lastNode.text)
+        return { content, id: null };
+    const match = lastNode.text.match(/ \^([a-f0-9]{8})\s*$/);
+    if (!match)
+        return { content, id: null };
+    const id = match[1];
+    const newText = lastNode.text.slice(0, match.index);
+    const newContent = [...content];
+    if (newText) {
+        newContent[newContent.length - 1] = { ...lastNode, text: newText };
+    }
+    else {
+        newContent.pop();
+    }
+    return { content: newContent, id };
+}

package/dist/server/markdown-serialize.js CHANGED Viewed

@@ -98,11 +98,19 @@ function nodeToMarkdown(node, indent) {
         case 'heading': {
             const level = node.attrs?.level || 1;
             const prefix = '#'.repeat(level);
-            return `${prefix} ${inlineToMarkdown(node.content)}\n\n`;
+            const idSuffix = node.attrs?.id ? ` ^${node.attrs.id}` : '';
+            return `${prefix} ${inlineToMarkdown(node.content)}${idSuffix}\n\n`;
         }
         case 'paragraph': {
             const text = inlineToMarkdown(node.content);
-            return text ? `${indent}${text}\n\n` : `${indent}<!-- -->\n\n`;
+            const id = node.attrs?.id;
+            if (text) {
+                const idSuffix = id ? ` ^${id}` : '';
+                return `${indent}${text}${idSuffix}\n\n`;
+            }
+            // Empty paragraph: embed id in the existing sentinel comment
+            const emptyMarker = id ? `<!-- ^${id} -->` : '<!-- -->';
+            return `${indent}${emptyMarker}\n\n`;
         }
         case 'bulletList':
             return listToMarkdown(node.content, '- ', indent);

package/dist/server/marks.js CHANGED Viewed

@@ -114,6 +114,15 @@ export function getGlobalMarkSummary(excludeFilename) {
     catch { /* dir doesn't exist */ }
     return { totalMarks, docCount };
 }
+export function editMark(filename, id, note) {
+    const data = readMarkFile(filename);
+    const mark = data.marks.find((m) => m.id === id);
+    if (!mark)
+        return null;
+    mark.note = note;
+    writeMarkFile(filename, data);
+    return mark;
+}
 export function resolveMarks(ids) {
     const idSet = new Set(ids);
     const resolved = [];