openwriter 0.12.1 → 0.13.0

package/dist/server/mcp.js

@@ -10,8 +10,9 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import { getDataDir, ensureDataDir, resolveDocPath, generateNodeId, atomicWriteFileSync } from './helpers.js';
-import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, findNodesByIds, getMetadata, setMetadata, mergeMetadataUpdates, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, updatePendingCacheForActiveDoc, populateDocumentFile, applyChangesToFile, applyTextEditsToFile, getDocId, getFilePath, extractText, countPending, addDocTag, removeDocTag, getDocTagsByFilename, getCachedDocument, invalidateDocCache, } from './state.js';
-import { listDocuments, switchDocument, createDocument, createDocumentFile, deleteDocument, openFile, getActiveFilename, updateDocumentTitle, promoteTempFile, archiveDocument, unarchiveDocument, resolveDocId } from './documents.js';
+import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, findNodesByIds, getMetadata, setMetadata, mergeMetadataUpdates, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, updatePendingCacheForActiveDoc, populateDocumentFile, applyChangesToFile, applyTextEditsToFile, getDocId, getFilePath, extractText, countPending, addDocTag, removeDocTag, getDocTagsByFilename, getCachedDocument, invalidateDocCache, isAutoAcceptActive, } from './state.js';
+import { listDocuments, switchDocument, createDocument, createDocumentFile, deleteDocument, openFile, getActiveFilename, updateDocumentTitle, promoteTempFile, archiveDocument, unarchiveDocument, resolveDocId, searchDocuments } from './documents.js';
+import { extractForwardLinks } from './backlinks.js';
 import { broadcastDocumentSwitched, broadcastDocumentsChanged, broadcastWorkspacesChanged, broadcastTitleChanged, broadcastMetadataChanged, broadcastPendingDocsChanged, broadcastWritingStarted, broadcastWritingFinished, broadcastMarksChanged } from './ws.js';
 import { listWorkspaces, getWorkspace, getDocTitle, getItemContext, addDoc, updateWorkspaceContext, createWorkspace, deleteWorkspace, addContainerToWorkspace, findOrCreateWorkspace, findOrCreateContainer, moveDoc, moveContainer, reorderWorkspaceAfter, removeContainer, renameWorkspace, renameContainer, removeDocFromAllWorkspaces } from './workspaces.js';
 import { findDocNode } from './workspace-tree.js';
@@ -221,8 +222,9 @@ export const TOOL_REGISTRY = [
                 pendingChanges: target.pendingCount,
                 lastModified: target.lastModified.toISOString(),
             };
-            // Surface autoAccept so the agent stops waiting for review when it's on.
-            if (target.metadata?.autoAccept === true)
+            // Surface effective autoAccept (doc flag OR workspace/container inherited)
+            // so the agent stops waiting for review when it's on.
+            if (isAutoAcceptActive(target.filename, target.metadata))
                 status.autoAccept = true;
             const latestVersion = getUpdateInfo();
             const payload = latestVersion ? { ...status, updateAvailable: latestVersion } : status;
@@ -414,9 +416,10 @@ export const TOOL_REGISTRY = [
                     };
                 }
                 // Active target (or no filename): existing flow.
-                // Skip pending tagging when autoAccept is on for this doc — content commits directly.
+                // Skip pending tagging when autoAccept is effectively on (doc flag or
+                // inherited from workspace/container) — content commits directly.
                 setAgentLock(); // Block browser doc-updates during population
-                if (getMetadata()?.autoAccept !== true) {
+                if (!isAutoAcceptActive(filename || getActiveFilename(), getMetadata())) {
                     markAllNodesAsPending(doc, 'insert');
                 }
                 updateDocument(doc);
@@ -1293,6 +1296,145 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text: ok ? `Removed task ${id}.` : `Task ${id} not found.` }] };
         },
     },
+    {
+        name: 'link_to',
+        description: 'Wrap anchor text in the ACTIVE doc with a doc: link pointing at another doc. Optionally target a specific paragraph (target_node_id) for paragraph-level navigation, with an optional quote for scroll-anchor fallback. The on-save backlinks pipeline then auto-updates the target doc\'s frontmatter `backlinks` field — so this single tool call creates both the forward link and the backlink. Use after writing prose to cross-reference concepts: agent writes about "territorial imperative" then calls link_to to point that phrase at the canonical concept doc.',
+        schema: {
+            text: z.string().describe('Anchor text in the active doc to wrap with the link. Exact substring match. First occurrence wins if the text appears multiple times.'),
+            target_doc_id: z.string().describe('Target document docId (8-char hex from list_documents or search_docs).'),
+            target_node_id: z.string().optional().describe('Optional 8-char hex nodeId for paragraph-level targeting. When provided, clicking the link scrolls to that paragraph in the target doc.'),
+            quote: z.string().optional().describe('Optional text snippet for scroll-anchor fallback when target_node_id has drifted (e.g. paragraph was rewritten).'),
+        },
+        handler: async ({ text, target_doc_id, target_node_id, quote }) => {
+            // 1. Locate the block in the active doc that contains the anchor text
+            const doc = getDocument();
+            let sourceNodeId = null;
+            function walk(nodes) {
+                if (sourceNodeId)
+                    return;
+                for (const node of nodes) {
+                    if (sourceNodeId)
+                        return;
+                    if (Array.isArray(node.content)) {
+                        const blockText = node.content.map((c) => c.text || '').join('');
+                        if (node.attrs?.id && blockText.includes(text)) {
+                            sourceNodeId = node.attrs.id;
+                            return;
+                        }
+                        walk(node.content);
+                    }
+                }
+            }
+            walk(doc.content);
+            if (!sourceNodeId) {
+                return { content: [{ type: 'text', text: `Anchor text "${text}" not found in the active doc. Use search_docs first to locate the right doc.` }] };
+            }
+            // 2. Build the href in canonical doc:DOCID#NODEID?q=quote form
+            let href = `doc:${target_doc_id}`;
+            if (target_node_id)
+                href += `#${target_node_id}`;
+            if (quote)
+                href += `?q=${encodeURIComponent(quote)}`;
+            // 3. Apply the link mark to the matched substring via the existing text-edit pipeline
+            const result = applyTextEdits(sourceNodeId, [{
+                    find: text,
+                    addMark: { type: 'link', attrs: { href } },
+                }]);
+            if (!result.success) {
+                return { content: [{ type: 'text', text: `Failed to apply link mark: ${result.error}` }] };
+            }
+            save(); // triggers writeToDisk → backlinks pipeline auto-updates the target's frontmatter
+            return { content: [{ type: 'text', text: `Linked "${text}" in node ${sourceNodeId} → ${href}. Target doc's backlinks frontmatter will refresh on next save.` }] };
+        },
+    },
+    {
+        name: 'search_docs',
+        description: 'Full-text search across all documents. Returns ranked candidates with docId, title, match type, and snippet. Use this BEFORE link_to to find the right target — the agent\'s primary primitive for resolving concept references to their canonical docs.',
+        schema: {
+            query: z.string().describe('Search query (case-insensitive substring match against title, tags, then content).'),
+            limit: z.number().optional().describe('Max results to return (default 10, max 50).'),
+        },
+        handler: async ({ query, limit = 10 }) => {
+            const cap = Math.min(Math.max(limit, 1), 50);
+            const raw = searchDocuments(query);
+            // Enrich with docId by reading each result's frontmatter
+            const enriched = raw.slice(0, cap).map((r) => {
+                let docId = null;
+                try {
+                    const filePath = resolveDocPath(r.filename);
+                    const fileRaw = readFileSync(filePath, 'utf-8');
+                    const fm = matter(fileRaw);
+                    docId = fm.data?.docId || null;
+                }
+                catch { /* docId stays null */ }
+                return {
+                    docId,
+                    title: r.title,
+                    filename: r.filename,
+                    matchType: r.matchType,
+                    snippet: r.snippet,
+                    matchedTag: r.matchedTag,
+                };
+            });
+            return { content: [{ type: 'text', text: JSON.stringify(enriched) }] };
+        },
+    },
+    {
+        name: 'get_graph',
+        description: 'Return forward links + backlinks for a doc — the crawl primitive for cross-doc context retrieval. Forward links extracted from the doc body, backlinks read from the doc\'s frontmatter (maintained by the on-save backlinks pipeline). Optional depth walks neighbors recursively (cap 3).',
+        schema: {
+            docId: z.string().describe('Center docId for the graph walk (8-char hex).'),
+            depth: z.number().optional().describe('Hops to walk outward (default 1, max 3). depth=1 returns just the center\'s links; depth=2 also includes neighbors\' links.'),
+        },
+        handler: async ({ docId, depth = 1 }) => {
+            const maxDepth = Math.min(Math.max(depth, 1), 3);
+            const seen = new Set();
+            const nodes = [];
+            function visit(id, hopsLeft) {
+                if (seen.has(id) || hopsLeft < 0)
+                    return;
+                seen.add(id);
+                let target;
+                try {
+                    target = resolveDocTarget(id);
+                }
+                catch {
+                    return;
+                }
+                const forward = extractForwardLinks(target.document, id);
+                const backlinks = Array.isArray(target.metadata.backlinks) ? target.metadata.backlinks : [];
+                nodes.push({
+                    docId: id,
+                    title: target.title,
+                    forward: forward.map((l) => ({
+                        text: l.text,
+                        from_node: l.from_node,
+                        to_doc: l.to_doc,
+                        ...(l.to_node ? { to_node: l.to_node } : {}),
+                    })),
+                    backlinks: backlinks.map((b) => ({
+                        text: b.text,
+                        from_doc: b.from_doc,
+                        from_node: b.from_node,
+                        ...(b.to_node ? { to_node: b.to_node } : {}),
+                    })),
+                });
+                if (hopsLeft > 0) {
+                    const neighbors = new Set();
+                    for (const l of forward)
+                        neighbors.add(l.to_doc);
+                    for (const b of backlinks)
+                        neighbors.add(b.from_doc);
+                    for (const n of neighbors) {
+                        if (!seen.has(n))
+                            visit(n, hopsLeft - 1);
+                    }
+                }
+            }
+            visit(docId, maxDepth - 1);
+            return { content: [{ type: 'text', text: JSON.stringify(nodes) }] };
+        },
+    },
 ];
 /** Live MCP server instance — used to register plugin tools dynamically. */
 let mcpServerInstance = null;

package/dist/server/state.js

@@ -10,6 +10,7 @@ import { tiptapToMarkdown, 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';
 const DEFAULT_DOC = {
     type: 'doc',
     content: [{ type: 'paragraph', content: [] }],
@@ -733,9 +734,28 @@ function applyChangesToDoc(doc, changes, autoAccept = false) {
     }
     return processed;
 }
+/**
+ * Effective auto-accept for a doc: true if the doc's own frontmatter has it,
+ * OR if any workspace/container ancestor in the workspace tree has it on.
+ */
+export function isAutoAcceptActive(filename, metadata) {
+    if (metadata?.autoAccept === true)
+        return true;
+    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;
+    }
+}
 /** Apply changes to the active document singleton. */
 function applyChangesToDocument(changes) {
-    const autoAccept = state.metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(activeDocFilename(), state.metadata);
     const processed = applyChangesToDoc(state.document, changes, autoAccept);
     if (processed.length > 0) {
         state.lastModified = new Date();
@@ -755,7 +775,7 @@ export function applyTextEdits(nodeId, edits) {
     if (!result)
         return { success: false, error: 'No edits matched' };
     // Inline edit decoration only matters when there's a review surface — skip in autoAccept.
-    if (state.metadata?.autoAccept !== true) {
+    if (!isAutoAcceptActive(activeDocFilename(), state.metadata)) {
         result.node.attrs = {
             ...result.node.attrs,
             pendingTextEdits: result.textEdits,
@@ -1015,6 +1035,16 @@ export function getPendingDocInfo() {
 // ============================================================================
 function writeToDisk() {
     ensureDataDir();
+    // Capture old forward links BEFORE we overwrite the file — needed by the
+    // backlinks engine to know which target docs to refresh when source changes.
+    // Skip for external docs (they don't participate in the doc graph).
+    let oldForwardLinks = [];
+    if (!isExternalDoc(state.filePath) && state.docId) {
+        try {
+            oldForwardLinks = extractForwardLinksFromDisk(state.filePath, state.docId);
+        }
+        catch { /* best-effort */ }
+    }
     let markdown;
     if (isExternalDoc(state.filePath)) {
         // External files: preserve original frontmatter verbatim, no OpenWriter metadata injected
@@ -1054,6 +1084,17 @@ function writeToDisk() {
         snapshotIfNeeded(state.docId, state.filePath);
     }
     catch { /* ignore */ }
+    // Backlinks update: refresh target docs' backlinks frontmatter if source's
+    // forward links changed. Best-effort — never blocks the save it follows.
+    if (!isExternalDoc(state.filePath) && state.docId) {
+        try {
+            const newForwardLinks = extractForwardLinks(state.document, state.docId);
+            updateBacklinksForSource(state.docId, newForwardLinks, oldForwardLinks);
+        }
+        catch (err) {
+            console.error('[State] backlinks update failed:', err);
+        }
+    }
 }
 export function save() {
     if (!state.filePath) {
@@ -1501,9 +1542,9 @@ export function populateDocumentFile(filename, doc) {
     const targetPath = resolveDocPath(filename);
     const raw = readFileSync(targetPath, 'utf-8');
     const parsed = markdownToTiptap(raw);
-    // Skip pending tagging when the target doc has autoAccept on —
+    // Skip pending tagging when the target doc effectively has autoAccept on —
     // content commits directly as accepted.
-    if (parsed.metadata?.autoAccept !== true) {
+    if (!isAutoAcceptActive(filename, parsed.metadata)) {
         markAllNodesAsPending(doc, 'insert');
     }
     flushDocToFile(filename, doc, parsed.title, parsed.metadata);
@@ -1541,7 +1582,7 @@ export function applyChangesToFile(filename, changes) {
         docId = metadata.docId || '';
         isTemp = false;
     }
-    const autoAccept = metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(filename, metadata);
     const processed = applyChangesToDoc(doc, changes, autoAccept);
     if (processed.length > 0) {
         flushDocToFile(filename, doc, title, metadata);
@@ -1597,7 +1638,7 @@ export function applyTextEditsToFile(filename, nodeId, edits) {
     const result = applyTextEditsToNode(originalNode, edits);
     if (!result)
         return { success: false, error: 'No edits matched' };
-    const autoAccept = metadata?.autoAccept === true;
+    const autoAccept = isAutoAcceptActive(filename, metadata);
     // pendingTextEdits is the fine-grained inline-edit decoration — skip in autoAccept
     // since the change commits directly.
     if (!autoAccept) {

package/dist/server/workspace-routes.js

@@ -4,6 +4,17 @@
  */
 import { Router } from 'express';
 import { listWorkspaces, getWorkspace, createWorkspace, deleteWorkspace, reorderWorkspaces, addDoc, removeDoc, moveDoc, reorderDoc, addContainerToWorkspace, removeContainer, renameContainer, renameWorkspace, reorderContainer, crossMoveContainer, promoteContainerToWorkspace, } from './workspaces.js';
+import { findNode } from './workspace-tree.js';
+import { deleteDocument } from './documents.js';
+function collectDocFilesInSubtree(nodes, out = []) {
+    for (const n of nodes) {
+        if (n.type === 'doc')
+            out.push(n.file);
+        else if (n.type === 'container')
+            collectDocFilesInSubtree(n.items, out);
+    }
+    return out;
+}
 export function createWorkspaceRouter(b) {
     const router = Router();
     router.get('/api/workspaces', (_req, res) => {
@@ -130,11 +141,28 @@ export function createWorkspaceRouter(b) {
             res.status(400).json({ error: err.message });
         }
     });
-    router.delete('/api/workspaces/:filename/containers/:containerId', (req, res) => {
-        try {
+    router.delete('/api/workspaces/:filename/containers/:containerId', async (req, res) => {
+        try {
+            const cascade = req.query.cascade === 'true' || req.query.cascade === '1';
+            let deletedDocs = 0;
+            if (cascade) {
+                // Find the container, collect all docs in its subtree, delete them from disk.
+                const current = getWorkspace(req.params.filename);
+                const found = findNode(current.root, (n) => n.type === 'container' && n.id === req.params.containerId);
+                if (found && found.node.type === 'container') {
+                    const files = collectDocFilesInSubtree(found.node.items);
+                    for (const file of files) {
+                        try {
+                            await deleteDocument(file);
+                            deletedDocs++;
+                        }
+                        catch { /* swallow per-doc failures; keep going */ }
+                    }
+                }
+            }
             const ws = removeContainer(req.params.filename, req.params.containerId);
             b.broadcastWorkspacesChanged();
-            res.json(ws);
+            res.json({ ...ws, deletedDocs });
         }
         catch (err) {
             res.status(400).json({ error: err.message });

package/dist/server/workspaces.js

@@ -437,6 +437,91 @@ export function getWorkspaceAssignedFiles() {
     }
     return assigned;
 }
+/**
+ * Walk every workspace and return true if `file` is inside one where auto-accept
+ * is on at the workspace level or on any ancestor container. Returns false when
+ * the doc isn't in any workspace or no ancestor has the flag set.
+ *
+ * A doc's own `autoAccept` frontmatter is NOT checked here — that's the caller's
+ * job (combined with this lookup, OR-style).
+ */
+export function isAutoAcceptInheritedForDoc(file) {
+    const workspaces = listWorkspaces();
+    for (const info of workspaces) {
+        try {
+            const ws = readWorkspace(info.filename);
+            // Walk root to find the doc; collect ancestor containers along the way.
+            function walk(nodes, ancestors) {
+                for (const n of nodes) {
+                    if (n.type === 'doc' && n.file === file) {
+                        if (ws.autoAccept === true)
+                            return true;
+                        for (const c of ancestors)
+                            if (c.autoAccept === true)
+                                return true;
+                        return false; // doc lives here but no ancestor flag set
+                    }
+                    if (n.type === 'container') {
+                        const result = walk(n.items, [...ancestors, n]);
+                        if (result !== null)
+                            return result;
+                    }
+                }
+                return null;
+            }
+            const found = walk(ws.root, []);
+            if (found === true)
+                return true;
+            // if found === false, doc IS in this workspace but no ancestor flag is on;
+            // continue scanning other workspaces (a doc could be referenced in multiple)
+        }
+        catch { /* skip corrupt manifests */ }
+    }
+    return false;
+}
+/** Set or clear workspace-level autoAccept. */
+export function setWorkspaceAutoAccept(wsFile, enabled) {
+    const ws = readWorkspace(wsFile);
+    if (enabled)
+        ws.autoAccept = true;
+    else
+        delete ws.autoAccept;
+    writeWorkspace(wsFile, ws);
+}
+/** Set or clear container-level autoAccept. */
+export function setContainerAutoAccept(wsFile, containerId, enabled) {
+    const ws = readWorkspace(wsFile);
+    const found = findContainer(ws.root, containerId);
+    if (!found)
+        throw new Error(`Container ${containerId} not found in ${wsFile}`);
+    if (enabled)
+        found.node.autoAccept = true;
+    else
+        delete found.node.autoAccept;
+    writeWorkspace(wsFile, ws);
+}
+/** Collect every file inside a workspace or container subtree. Used for broadcast. */
+export function collectFilesInWorkspace(wsFile) {
+    try {
+        const ws = readWorkspace(wsFile);
+        return collectAllFiles(ws.root);
+    }
+    catch {
+        return [];
+    }
+}
+export function collectFilesInContainer(wsFile, containerId) {
+    try {
+        const ws = readWorkspace(wsFile);
+        const found = findContainer(ws.root, containerId);
+        if (!found)
+            return [];
+        return collectAllFiles(found.node.items);
+    }
+    catch {
+        return [];
+    }
+}
 export function getWorkspaceStructure(filename) {
     return getWorkspace(filename);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.12.1",
+  "version": "0.13.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

@@ -16,7 +16,7 @@ description: |
   Requires: OpenWriter MCP server configured. Browser UI at localhost:5050.
 metadata:
   author: travsteward
-  version: "0.6.0"
+  version: "0.7.0"
   repository: https://github.com/travsteward/openwriter
 license: MIT
 ---
@@ -278,13 +278,9 @@ When creating **two or more documents together** — a tweet thread saved as sep
 - `reply` / `quote` types still require `url`
 - For a **single** document, use `create_document` — don't reach for `declare_writes` just to wrap one entry
 
-## Voice Frames
+## Companion Skills (optional)
 
-Pre-built voice postures for when the user wants a specific style but has no custom voice profile. Five frames cover the common needs: authority, provocateur, logical, storyteller, business.
-
-**Triggers** — any of the following should make you load frames: "write authoritatively", "authority voice", "contrarian take", "provocateur", "first principles", "logical/analytical essay", "tell the story", "storyteller", "business email", "high-status brevity", or an explicit frame name.
-
-**Protocol** — load `docs/voices.md` for the full selection guide and 4-step protocol. Then read the specific `voices/<frame>.md` for the rules. Apply all 6 category rules as hard constraints while drafting in the editor, and run the `docs/anti-ai.md` Tier 1 pass before leaving the output.
+For voice-matched drafting without a custom Author's Voice profile, install the **voice-presets** skill — 5 frames (authority, provocateur, logical, storyteller, business). For an AI-detection pass on output, install **anti-ai**. Both are optional and ship separately from this skill.
 
 ## Workflow