openwriter 0.37.1 → 0.38.0

package/dist/server/manuscript/render/md.js

@@ -0,0 +1,41 @@
+/**
+ * Shared markdown-it instance for manuscript rendering — matches the
+ * configuration in export-routes.ts (the single-doc export path) so manuscript
+ * output is consistent with OpenWriter's existing exports: same flavor, same
+ * footnote plugin. `xhtml` mode self-closes void elements for EPUB's XHTML.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import MarkdownIt from 'markdown-it';
+import markdownItIns from 'markdown-it-ins';
+import markdownItMark from 'markdown-it-mark';
+import markdownItSub from 'markdown-it-sub';
+import markdownItSup from 'markdown-it-sup';
+import markdownItFootnote from 'markdown-it-footnote';
+export function createMd(xhtml = false) {
+    const md = new MarkdownIt({ linkify: false, html: true, xhtmlOut: xhtml });
+    md.enable('strikethrough');
+    md.use(markdownItIns);
+    md.use(markdownItMark);
+    md.use(markdownItSub);
+    md.use(markdownItSup);
+    md.use(markdownItFootnote);
+    // Chapter anchors: every top-level heading (h1 = a chapter; beats are demoted
+    // to h2+) gets a stable sequential id `ch-N`. The assembler's {{toc}} links to
+    // these (#ch-N) and the preview's chapter tick-rail also keys off them, so the
+    // contents page and the side navigator point at the same targets.
+    md.core.ruler.push('chapter_ids', (state) => {
+        let n = 0;
+        for (const tok of state.tokens) {
+            if (tok.type === 'heading_open' && tok.tag === 'h1') {
+                n += 1;
+                tok.attrSet('id', `ch-${n}`);
+            }
+        }
+    });
+    return md;
+}
+/** Render a markdown string to an HTML fragment. */
+export function renderBodyHtml(markdown, xhtml = false) {
+    return createMd(xhtml).render(markdown);
+}

package/dist/server/manuscript/resolve.js

@@ -0,0 +1,42 @@
+/**
+ * Manuscript doc resolution — disk I/O.
+ *
+ * Maps each manifest doc-pointer (docId) to its current on-disk body. Resolution
+ * is by stable docId (rename-safe): filenameByDocId → readFrontmatter().content.
+ * The body read from disk is the canonical, ACCEPTED text — pending agent
+ * suggestions live in the `_pending/<docId>.json` sidecar, never in the .md body
+ * — so a compiled manuscript never ships an un-accepted edit. A docId resolves
+ * regardless of which workspace/container the doc lives in (location-independent),
+ * which is why a transition doc written "in some random folder" links fine.
+ *
+ * adr: adr/manuscript-engine.md
+ */
+import { filenameByDocId } from '../documents.js';
+import { readFrontmatter } from '../backlinks.js';
+export function resolveManifestDocs(manifest) {
+    const bodyMap = new Map();
+    const warnings = [];
+    for (const section of manifest.sections) {
+        for (const item of section.items) {
+            if (item.kind !== 'doc' || !item.docId)
+                continue;
+            if (bodyMap.has(item.docId))
+                continue;
+            const filename = filenameByDocId(item.docId);
+            if (!filename) {
+                warnings.push(`docId ${item.docId} not found (${item.text ?? ''})`);
+                continue;
+            }
+            const fm = readFrontmatter(filename);
+            if (!fm) {
+                warnings.push(`Could not read ${filename} for docId ${item.docId}`);
+                continue;
+            }
+            bodyMap.set(item.docId, {
+                title: fm.data.title || item.text || 'Untitled',
+                body: fm.content,
+            });
+        }
+    }
+    return { bodyMap, warnings };
+}

package/dist/server/manuscript-routes.js

@@ -0,0 +1,78 @@
+/**
+ * Manuscript routes: compile + render a manuscript doc to a file or preview.
+ *
+ *   GET /api/manuscript/preview?docId=<id>            -> book HTML (iframe source)
+ *   GET /api/manuscript/export?docId=<id>&format=epub -> epub | docx | html | md
+ *
+ * Both resolve the manifest doc by stable docId, compile it (resolve pointers +
+ * assemble), then render. Preview and export share the same compile() path, so
+ * the preview can never disagree with the exported book. adr: adr/manuscript-engine.md
+ */
+import { Router } from 'express';
+import { compileManuscript, renderBookHtml, renderEpub, renderDocx, } from './manuscript/index.js';
+import { listManuscripts, loadManifest, safeName } from './manuscript/load.js';
+export function createManuscriptRouter() {
+    const router = Router();
+    // Always-on launcher list for the right rail — every manuscript in the profile.
+    router.get('/api/manuscripts', (_req, res) => {
+        res.json({ manuscripts: listManuscripts() });
+    });
+    router.get('/api/manuscript/preview', (req, res) => {
+        const ms = loadManifest(String(req.query.docId || ''));
+        if (!ms)
+            return res.status(404).json({ error: 'manuscript doc not found' });
+        const { markdown, meta } = compileManuscript(ms.body, ms.meta);
+        // The manuscript compose view frames this preview SAME-ORIGIN. The global
+        // security gate sends X-Frame-Options: DENY + frame-ancestors 'none', which
+        // blocks the iframe entirely. Relax BOTH to same-origin for this route only —
+        // a self-contained book page, framed by the app itself, nothing external.
+        res.setHeader('X-Frame-Options', 'SAMEORIGIN');
+        res.setHeader('Content-Security-Policy', "default-src 'self'; img-src 'self' data: blob: https:; style-src 'self' 'unsafe-inline'; font-src 'self' data:; frame-ancestors 'self'");
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        // Screen light/dark follows the app's Appearance setting, passed by the
+        // compose view. Export (below) never does — the book ships print-light.
+        const mode = req.query.mode === 'dark' ? 'dark' : 'light';
+        res.send(renderBookHtml(markdown, meta, mode));
+    });
+    router.get('/api/manuscript/export', async (req, res) => {
+        const ms = loadManifest(String(req.query.docId || ''));
+        if (!ms)
+            return res.status(404).json({ error: 'manuscript doc not found' });
+        const format = String(req.query.format || 'epub').toLowerCase();
+        const result = compileManuscript(ms.body, ms.meta);
+        const name = safeName(result.meta.title || '');
+        try {
+            switch (format) {
+                case 'epub': {
+                    const buf = await renderEpub(result.markdown, result.meta);
+                    res.setHeader('Content-Type', 'application/epub+zip');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.epub"`);
+                    return res.send(buf);
+                }
+                case 'docx': {
+                    const buf = await renderDocx(result.markdown, result.meta);
+                    res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.docx"`);
+                    return res.send(buf);
+                }
+                case 'html': {
+                    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.html"`);
+                    return res.send(renderBookHtml(result.markdown, result.meta));
+                }
+                case 'md': {
+                    res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
+                    res.setHeader('Content-Disposition', `attachment; filename="${name}.md"`);
+                    return res.send(result.markdown);
+                }
+                default:
+                    return res.status(400).json({ error: `Unknown format: ${format}. Use epub, docx, html, or md.` });
+            }
+        }
+        catch (err) {
+            console.error('[Manuscript] export error:', err?.message);
+            return res.status(500).json({ error: 'Manuscript export failed' });
+        }
+    });
+    return router;
+}

package/dist/server/mcp.js

@@ -9,7 +9,9 @@ import { randomUUID } from 'crypto';
 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, readConfig } from './helpers.js';
+import { getDataDir, ensureDataDir, resolveDocPath, generateNodeId, atomicWriteFileSync, readConfig, ROOT_DIR } from './helpers.js';
+import { compileManuscript, renderBookHtml, renderEpub, renderDocx } from './manuscript/index.js';
+import { loadManifest, safeName } from './manuscript/load.js';
 import { getDocument, getWordCount, getPendingChangeCount, getTitle, getStatus, getNodesByIds, findNodesByIds, getMetadata, setMetadata, mergeMetadataUpdates, applyChanges, applyTextEdits, updateDocument, save, markAllNodesAsPending, setAgentLock, setAgentLockActive, updatePendingCacheForActiveDoc, populateDocumentFile, applyChangesToFile, applyTextEditsToFile, getDocId, getFilePath, getIsTemp, extractText, countPending, addDocTag, removeDocTag, getCachedDocument, invalidateDocCache, isAutoAcceptActive, removePendingCacheEntry, getExternalMtimeDrift, reloadActiveDocFromDisk, getCanonical, cloneWithPendingReverted, bumpDocVersion, setSortProposalOnFile, clearSortRequestOnFile, } from './state.js';
 import { tiptapToBlocks } from './node-blocks.js';
 import { readBlame, summarizeBlame } from './attribution.js';
@@ -489,7 +491,7 @@ export const TOOL_REGISTRY = [
             workspace: z.string().optional().describe('Workspace title to add this doc to. Creates the workspace if it doesn\'t exist.'),
             container: z.string().optional().describe('Container name within the workspace (e.g. "Chapters", "Notes", "References"). Creates the container if it doesn\'t exist. Requires workspace.'),
             empty: z.boolean().optional().describe('ONLY for content_type template docs (tweets, articles) that start blank. Skips the spinner and switches immediately. Do NOT set this for content documents — use the two-step flow (create_document → populate_document) instead.'),
-            content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog']).describe('Required. Use "document" for plain documents. Tweet/reply/quote/article/linkedin/newsletter/blog set type-specific metadata automatically.'),
+            content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog', 'manuscript']).describe('Required. Use "document" for plain documents. Tweet/reply/quote/article/linkedin/newsletter/blog set type-specific metadata automatically. "manuscript" = a binding doc whose body is an ordered list of [text](doc:ID) pointers under ## chapter headings; populate it with the manifest, then it compiles to EPUB/DOCX via the manuscript routes.'),
             url: z.string().optional().describe('Tweet URL — REQUIRED for content_type "reply" or "quote" (e.g. "https://x.com/user/status/123"). Sets tweetContext.url automatically. Ignored for other content types.'),
             afterId: z.string().optional().describe('Place the new doc immediately after this docId (8-char hex) or containerId inside its parent. Omit to append to the bottom of the parent (the default — matches ascending-order convention: newest at bottom). Requires workspace.'),
             status: z.enum(['canonical', 'draft']).optional().describe('Agent-owned lifecycle. "canonical" = committed to spine / load-bearing for the workspace (use for Beats docs that have locked, Research Notes, Master References). "draft" = working / not load-bearing yet / scratch (DUMP docs, first-pass beats). Defaults to "draft" when omitted. Change later via set_metadata({ status: ... }) on lifecycle transitions. v0.19.0.'),
@@ -728,7 +730,7 @@ export const TOOL_REGISTRY = [
         schema: {
             writes: z.array(z.object({
                 title: z.string().describe('Title for the document.'),
-                content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog']).describe('Content type. Use "document" for plain docs.'),
+                content_type: z.enum(['document', 'tweet', 'reply', 'quote', 'article', 'linkedin', 'newsletter', 'blog', 'manuscript']).describe('Content type. Use "document" for plain docs. "manuscript" = a binding doc of ordered doc: pointers.'),
                 workspace: z.string().optional().describe('Workspace title to add this doc to. Creates the workspace if it does not exist.'),
                 container: z.string().optional().describe('Container name within the workspace (e.g. "Chapters"). Requires workspace.'),
                 url: z.string().optional().describe('Tweet URL — REQUIRED for content_type "reply" or "quote".'),
@@ -877,6 +879,78 @@ export const TOOL_REGISTRY = [
             return { content: [{ type: 'text', text: `Restored "${result.title}" [${docId}] from archive` }] };
         },
     },
+    {
+        name: 'compile_manuscript',
+        description: 'Compile a manuscript doc (content_type "manuscript") into the assembled master book and report its structure + any problems — WITHOUT writing a file. Resolves every `doc:` pointer in the manifest, concatenates the canonical (accepted) bodies in manifest order under their chapter headings, namespaces footnotes, then returns: title, per-chapter word counts, chapter count, total word count, and warnings. Warnings flag unresolved pointers — a beat that points at a missing/renamed/archived doc — so this is the build-time feedback loop: run it to confirm the binding resolves and see how each chapter is sizing up. Pass includeMarkdown:true to also return the full assembled markdown (large for a real book). Target the manifest by docId (8-char hex).',
+        schema: {
+            docId: z.string().describe('The manuscript doc (the manifest) by docId (8-char hex from list_documents).'),
+            includeMarkdown: z.boolean().optional().describe('Also return the full assembled master markdown. Off by default — for a long book this is very large.'),
+        },
+        handler: async ({ docId, includeMarkdown }) => {
+            const ms = loadManifest(docId);
+            if (!ms)
+                return { content: [{ type: 'text', text: `No manuscript doc found for docId ${docId}. Is it content_type "manuscript"?` }] };
+            const { markdown, meta, warnings } = compileManuscript(ms.body, ms.meta);
+            const wc = (s) => { const t = s.trim(); return t ? t.split(/\s+/).length : 0; };
+            const chapters = [];
+            let cur = null;
+            for (const line of markdown.split('\n')) {
+                const h = line.match(/^# (.+)/);
+                if (h) {
+                    cur = { title: h[1].trim(), words: 0 };
+                    chapters.push(cur);
+                }
+                else if (cur)
+                    cur.words += wc(line);
+            }
+            const summary = {
+                title: meta.title,
+                chapterCount: chapters.length,
+                totalWords: wc(markdown),
+                chapters,
+                warnings,
+            };
+            if (includeMarkdown)
+                summary.markdown = markdown;
+            return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] };
+        },
+    },
+    {
+        name: 'export_manuscript',
+        description: 'Compile a manuscript doc and WRITE the rendered book to a file: epub (KDP-ready ebook), docx (Word), html (single styled file), or md (the raw assembled master markdown). Same compile + render path as the in-app preview, so the file matches what you see there. Writes to ~/.openwriter/exports/<title>.<ext> by default (or an explicit outputPath) and returns the absolute path plus any compile warnings. EPUB/HTML ship print-light (e-readers handle their own dark mode). Target the manifest by docId (8-char hex).',
+        schema: {
+            docId: z.string().describe('The manuscript doc (the manifest) by docId (8-char hex from list_documents).'),
+            format: z.enum(['epub', 'docx', 'html', 'md']).describe('Output format. epub = KDP-ready ebook; docx = Word; html = single styled file; md = raw assembled master markdown.'),
+            outputPath: z.string().optional().describe('Absolute file path to write. Defaults to ~/.openwriter/exports/<title>.<ext>.'),
+        },
+        handler: async ({ docId, format, outputPath }) => {
+            const ms = loadManifest(docId);
+            if (!ms)
+                return { content: [{ type: 'text', text: `No manuscript doc found for docId ${docId}. Is it content_type "manuscript"?` }] };
+            const result = compileManuscript(ms.body, ms.meta);
+            const dir = join(ROOT_DIR, 'exports');
+            mkdirSync(dir, { recursive: true });
+            const outPath = outputPath || join(dir, `${safeName(result.meta.title || '')}.${format}`);
+            switch (format) {
+                case 'epub':
+                    writeFileSync(outPath, await renderEpub(result.markdown, result.meta));
+                    break;
+                case 'docx':
+                    writeFileSync(outPath, await renderDocx(result.markdown, result.meta));
+                    break;
+                case 'html':
+                    writeFileSync(outPath, renderBookHtml(result.markdown, result.meta), 'utf-8');
+                    break;
+                case 'md':
+                    writeFileSync(outPath, result.markdown, 'utf-8');
+                    break;
+            }
+            const warn = result.warnings.length
+                ? ` — ${result.warnings.length} warning(s): ${result.warnings.slice(0, 3).join('; ')}${result.warnings.length > 3 ? ' …' : ''}`
+                : '';
+            return { content: [{ type: 'text', text: `Exported "${result.meta.title}" (${format}) → ${outPath}${warn}` }] };
+        },
+    },
     {
         name: 'get_metadata',
         description: 'Get the JSON frontmatter metadata for a document. Returns all key-value pairs stored in frontmatter (title, summary, characters, tags, etc.). Useful for understanding document context without reading full content.',
@@ -1358,7 +1432,7 @@ export const TOOL_REGISTRY = [
                 settings: z.record(z.string()).optional().describe('Setting name → description (merged)'),
                 rules: z.array(z.string()).optional().describe('Writing rules for this workspace (replaces)'),
                 logline: z.string().nullable().optional().describe('One-sentence "what this workspace is for". Set null to clear.'),
-                domain: z.string().nullable().optional().describe('Subject area (e.g. "Male ethology"). Set null to clear.'),
+                domain: z.string().nullable().optional().describe('Subject area (e.g. "Marine biology"). Set null to clear.'),
                 schema: z.string().nullable().optional().describe('Workspace kind: book / concept-library / inbox / social / reference. Set null to clear.'),
                 vocab: z.array(z.string()).nullable().optional().describe('Closed list of valid domain names — Haiku classifies docs INTO these. Set null to clear (opens vocab to free-form).'),
                 relatedWorkspaces: z.array(z.string()).nullable().optional().describe('Sibling workspace filenames. Set null to clear.'),

package/dist/server/state.js

@@ -831,7 +831,7 @@ export function mergeMetadataUpdates(existing, updates) {
             return null;
     }
     // Deep-merge known context objects
-    const CONTEXT_KEYS = ['blogContext', 'newsletterContext', 'articleContext', 'tweetContext', 'linkedinContext'];
+    const CONTEXT_KEYS = ['blogContext', 'newsletterContext', 'articleContext', 'tweetContext', 'linkedinContext', 'manuscriptContext'];
     for (const key of CONTEXT_KEYS) {
         if (updates[key] && typeof updates[key] === 'object' && existing?.[key] && typeof existing[key] === 'object') {
             updates[key] = { ...existing[key], ...updates[key] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openwriter",
-  "version": "0.37.1",
+  "version": "0.38.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",
@@ -63,6 +63,7 @@
     "@xdevplatform/xdk": "^0.4.0",
     "express": "^4.21.0",
     "gray-matter": "^4.0.3",
+    "jszip": "^3.10.1",
     "lowlight": "^3.3.0",
     "markdown-it": "^14.1.1",
     "markdown-it-footnote": "^4.0.0",