openwriter 0.1.0

package/dist/server/markdown-parse.js

@@ -0,0 +1,405 @@
+/**
+ * Markdown -> TipTap JSON parsing.
+ * Parses markdown (with optional YAML frontmatter) into TipTap document JSON.
+ */
+import MarkdownIt from 'markdown-it';
+import matter from 'gray-matter';
+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 { generateNodeId, LEAF_BLOCK_TYPES } from './helpers.js';
+import { nodeText } from './markdown-serialize.js';
+// ============================================================================
+// Markdown -> TipTap
+// ============================================================================
+const md = new MarkdownIt({ linkify: false });
+md.enable('strikethrough');
+md.use(markdownItIns);
+md.use(markdownItMark);
+md.use(markdownItSub);
+md.use(markdownItSup);
+export function markdownToTiptap(markdown) {
+    const { data, content } = matter(markdown);
+    const title = data.title || 'Untitled';
+    const tokens = md.parse(content, {});
+    const docContent = tokensToTiptap(tokens);
+    const doc = {
+        type: 'doc',
+        content: docContent.length > 0 ? docContent : [{ type: 'paragraph', attrs: { id: generateNodeId() }, content: [] }],
+    };
+    // Rehydrate pending state from frontmatter into node attrs
+    if (data.pending) {
+        rehydratePendingState(doc, data.pending);
+    }
+    // Strip pending from returned metadata (consumed into node attrs)
+    const metadata = { ...data };
+    delete metadata.pending;
+    return { title, metadata, document: doc };
+}
+/**
+ * Rehydrate pending state from frontmatter into leaf block node attrs.
+ * Uses text fingerprint matching to survive position shifts caused by
+ * empty paragraphs disappearing during markdown round-trips.
+ */
+function rehydratePendingState(doc, pending) {
+    // Build ordered list of leaf blocks with text fingerprints
+    const leaves = [];
+    function collect(nodes) {
+        if (!nodes)
+            return;
+        for (const node of nodes) {
+            if (LEAF_BLOCK_TYPES.has(node.type)) {
+                leaves.push({ node, text: nodeText(node) });
+            }
+            else if (node.content) {
+                collect(node.content);
+            }
+        }
+    }
+    collect(doc.content);
+    const used = new Set();
+    for (const [posStr, entry] of Object.entries(pending)) {
+        const pos = parseInt(posStr, 10);
+        let target = null;
+        // 1. Try position match (with text verification if fingerprint exists)
+        if (pos < leaves.length && !used.has(pos)) {
+            if (!entry.t || leaves[pos].text === entry.t) {
+                target = leaves[pos].node;
+                used.add(pos);
+            }
+        }
+        // 2. Fallback: search by text fingerprint
+        if (!target && entry.t) {
+            for (let i = 0; i < leaves.length; i++) {
+                if (!used.has(i) && leaves[i].text === entry.t) {
+                    target = leaves[i].node;
+                    used.add(i);
+                    break;
+                }
+            }
+        }
+        if (target) {
+            target.attrs = target.attrs || {};
+            target.attrs.pendingStatus = entry.s;
+            if (entry.o) {
+                target.attrs.pendingOriginalContent = entry.o;
+            }
+        }
+    }
+}
+/** Parse a markdown string into TipTap block nodes (no frontmatter). */
+export function markdownToNodes(markdown) {
+    const tokens = md.parse(markdown, {});
+    const nodes = tokensToTiptap(tokens);
+    return nodes.length > 0 ? nodes : [{ type: 'paragraph', attrs: { id: generateNodeId() }, content: [] }];
+}
+// ---- Token tree walker ----
+function tokensToTiptap(tokens) {
+    const nodes = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        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 });
+            i += 3;
+        }
+        else if (token.type === 'paragraph_open') {
+            const inlineToken = tokens[i + 1];
+            const content = inlineToken?.children ? inlineTokensToTiptap(inlineToken.children) : [];
+            // 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 });
+            }
+            i += 3;
+        }
+        else if (token.type === 'bullet_list_open') {
+            const end = findClosingToken(tokens, i, 'bullet_list');
+            const items = parseListItems(tokens.slice(i + 1, end));
+            const listNode = { type: 'bulletList', attrs: { id: generateNodeId() }, content: items };
+            // Try converting to taskList if all items start with checkboxes
+            const taskNode = tryConvertToTaskList(listNode);
+            nodes.push(taskNode || listNode);
+            i = end + 1;
+        }
+        else if (token.type === 'ordered_list_open') {
+            const end = findClosingToken(tokens, i, 'ordered_list');
+            const items = parseListItems(tokens.slice(i + 1, end));
+            nodes.push({ type: 'orderedList', attrs: { id: generateNodeId() }, content: items });
+            i = end + 1;
+        }
+        else if (token.type === 'blockquote_open') {
+            const end = findClosingToken(tokens, i, 'blockquote');
+            const inner = tokensToTiptap(tokens.slice(i + 1, end));
+            nodes.push({ type: 'blockquote', attrs: { id: generateNodeId() }, content: inner });
+            i = end + 1;
+        }
+        else if (token.type === 'fence') {
+            const lang = token.info?.trim() || '';
+            const text = token.content.replace(/\n$/, '');
+            const content = text ? [{ type: 'text', text }] : [];
+            const attrs = { id: generateNodeId() };
+            if (lang)
+                attrs.language = lang;
+            nodes.push({ type: 'codeBlock', attrs, content });
+            i += 1;
+        }
+        else if (token.type === 'hr') {
+            nodes.push({ type: 'horizontalRule', attrs: { id: generateNodeId() } });
+            i += 1;
+        }
+        else if (token.type === 'table_open') {
+            const end = findClosingToken(tokens, i, 'table');
+            const tableNode = parseTableTokens(tokens.slice(i + 1, end));
+            nodes.push(tableNode);
+            i = end + 1;
+        }
+        else {
+            i += 1;
+        }
+    }
+    return nodes;
+}
+function findClosingToken(tokens, startIndex, type) {
+    let depth = 0;
+    for (let i = startIndex; i < tokens.length; i++) {
+        if (tokens[i].type === `${type}_open`)
+            depth++;
+        if (tokens[i].type === `${type}_close`) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return tokens.length - 1;
+}
+function parseListItems(tokens) {
+    const items = [];
+    let i = 0;
+    while (i < tokens.length) {
+        if (tokens[i].type === 'list_item_open') {
+            const end = findClosingToken(tokens, i, 'list_item');
+            const inner = tokensToTiptap(tokens.slice(i + 1, end));
+            items.push({ type: 'listItem', attrs: { id: generateNodeId() }, content: inner });
+            i = end + 1;
+        }
+        else {
+            i++;
+        }
+    }
+    return items;
+}
+/**
+ * Post-process a bulletList: if every listItem starts with [ ] or [x],
+ * convert to taskList/taskItem nodes and strip the checkbox prefix.
+ */
+function tryConvertToTaskList(bulletList) {
+    const items = bulletList.content;
+    if (!items || items.length === 0)
+        return null;
+    const checkboxRe = /^\[([ xX])\]\s?/;
+    const taskItems = [];
+    for (const item of items) {
+        const firstChild = item.content?.[0];
+        if (!firstChild || firstChild.type !== 'paragraph')
+            return null;
+        const firstText = firstChild.content?.[0];
+        if (!firstText || firstText.type !== 'text')
+            return null;
+        const match = checkboxRe.exec(firstText.text);
+        if (!match)
+            return null;
+        const checked = match[1] !== ' ';
+        // Strip checkbox prefix from text
+        const remaining = firstText.text.slice(match[0].length);
+        const newContent = [...firstChild.content];
+        if (remaining) {
+            newContent[0] = { ...firstText, text: remaining };
+        }
+        else {
+            newContent.shift();
+        }
+        const newParagraph = { ...firstChild, content: newContent };
+        const restChildren = item.content.slice(1);
+        taskItems.push({
+            type: 'taskItem',
+            attrs: { id: generateNodeId(), checked },
+            content: [newParagraph, ...restChildren],
+        });
+    }
+    return {
+        type: 'taskList',
+        attrs: { id: generateNodeId() },
+        content: taskItems,
+    };
+}
+function parseTableTokens(tokens) {
+    const rows = [];
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'thead_open' || token.type === 'tbody_open') {
+            i++; // skip section open, process rows inside
+            continue;
+        }
+        if (token.type === 'thead_close' || token.type === 'tbody_close') {
+            i++;
+            continue;
+        }
+        if (token.type === 'tr_open') {
+            const trEnd = findClosingToken(tokens, i, 'tr');
+            const cells = [];
+            let j = i + 1;
+            while (j < trEnd) {
+                const cellToken = tokens[j];
+                if (cellToken.type === 'th_open' || cellToken.type === 'td_open') {
+                    const cellType = cellToken.type === 'th_open' ? 'tableHeader' : 'tableCell';
+                    const cellEnd = findClosingToken(tokens, j, cellToken.type === 'th_open' ? 'th' : 'td');
+                    // Inline content is between open and close
+                    let content = [];
+                    if (j + 1 < cellEnd && tokens[j + 1].type === 'inline') {
+                        content = tokens[j + 1].children ? inlineTokensToTiptap(tokens[j + 1].children) : [];
+                    }
+                    cells.push({
+                        type: cellType,
+                        attrs: { id: generateNodeId() },
+                        content: [{
+                                type: 'paragraph',
+                                attrs: { id: generateNodeId() },
+                                content,
+                            }],
+                    });
+                    j = cellEnd + 1;
+                }
+                else {
+                    j++;
+                }
+            }
+            rows.push({
+                type: 'tableRow',
+                attrs: { id: generateNodeId() },
+                content: cells,
+            });
+            i = trEnd + 1;
+        }
+        else {
+            i++;
+        }
+    }
+    return {
+        type: 'table',
+        attrs: { id: generateNodeId() },
+        content: rows,
+    };
+}
+function inlineTokensToTiptap(tokens) {
+    const nodes = [];
+    const markStack = [];
+    for (const token of tokens) {
+        if (token.type === 'text') {
+            if (!token.content)
+                continue; // ProseMirror rejects empty text nodes
+            const textNode = { type: 'text', text: token.content };
+            if (markStack.length > 0) {
+                textNode.marks = deduplicateMarks(markStack);
+            }
+            nodes.push(textNode);
+        }
+        else if (token.type === 'code_inline') {
+            if (!token.content)
+                continue;
+            const marks = deduplicateMarks([...markStack, { type: 'code' }]);
+            nodes.push({ type: 'text', text: token.content, marks });
+        }
+        else if (token.type === 'strong_open') {
+            markStack.push({ type: 'bold' });
+        }
+        else if (token.type === 'strong_close') {
+            popMarkByType(markStack, 'bold');
+        }
+        else if (token.type === 'em_open') {
+            markStack.push({ type: 'italic' });
+        }
+        else if (token.type === 'em_close') {
+            popMarkByType(markStack, 'italic');
+        }
+        else if (token.type === 's_open') {
+            markStack.push({ type: 'strike' });
+        }
+        else if (token.type === 's_close') {
+            popMarkByType(markStack, 'strike');
+        }
+        else if (token.type === 'ins_open') {
+            markStack.push({ type: 'underline' });
+        }
+        else if (token.type === 'ins_close') {
+            popMarkByType(markStack, 'underline');
+        }
+        else if (token.type === 'mark_open') {
+            markStack.push({ type: 'highlight' });
+        }
+        else if (token.type === 'mark_close') {
+            popMarkByType(markStack, 'highlight');
+        }
+        else if (token.type === 'sub_open') {
+            markStack.push({ type: 'subscript' });
+        }
+        else if (token.type === 'sub_close') {
+            popMarkByType(markStack, 'subscript');
+        }
+        else if (token.type === 'sup_open') {
+            markStack.push({ type: 'superscript' });
+        }
+        else if (token.type === 'sup_close') {
+            popMarkByType(markStack, 'superscript');
+        }
+        else if (token.type === 'link_open') {
+            const rawHref = token.attrGet('href') || '';
+            const href = decodeURI(rawHref);
+            markStack.push({ type: 'link', attrs: { href } });
+        }
+        else if (token.type === 'link_close') {
+            popMarkByType(markStack, 'link');
+        }
+        else if (token.type === 'image') {
+            const src = token.attrGet('src') || '';
+            const alt = token.content || token.attrGet('alt') || '';
+            nodes.push({
+                type: 'image',
+                attrs: { id: generateNodeId(), src, alt },
+            });
+        }
+        else if (token.type === 'hardbreak') {
+            nodes.push({ type: 'hardBreak' });
+        }
+        else if (token.type === 'softbreak') {
+            nodes.push({ type: 'text', text: ' ' });
+        }
+    }
+    return nodes;
+}
+/** Remove duplicate mark types (e.g. nested **bold** producing two bold marks). */
+function deduplicateMarks(marks) {
+    const seen = new Set();
+    return marks.filter((m) => {
+        const key = m.type === 'link' ? `link:${m.attrs?.href}` : m.type;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function popMarkByType(stack, type) {
+    for (let i = stack.length - 1; i >= 0; i--) {
+        if (stack[i].type === type) {
+            stack.splice(i, 1);
+            return;
+        }
+    }
+}

package/dist/server/markdown-serialize.js

@@ -0,0 +1,263 @@
+/**
+ * TipTap JSON -> Markdown serialization.
+ * Converts TipTap document to markdown with YAML frontmatter.
+ */
+import { LEAF_BLOCK_TYPES } from './helpers.js';
+// ============================================================================
+// TipTap -> Markdown
+// ============================================================================
+/** Extract plain text from a TipTap node's inline content. */
+export function nodeText(node) {
+    if (!node.content)
+        return '';
+    return node.content.map((c) => c.text || '').join('');
+}
+/**
+ * Collect pending state from leaf blocks into a position-indexed map.
+ * Each entry includes a text fingerprint (`t`) for robust matching
+ * across markdown round-trips where empty paragraphs may disappear.
+ */
+function collectPendingState(doc) {
+    const pending = {};
+    let index = 0;
+    function walk(nodes) {
+        if (!nodes)
+            return;
+        for (const node of nodes) {
+            if (LEAF_BLOCK_TYPES.has(node.type)) {
+                if (node.attrs?.pendingStatus) {
+                    const entry = { s: node.attrs.pendingStatus };
+                    if (node.attrs.pendingOriginalContent) {
+                        entry.o = node.attrs.pendingOriginalContent;
+                    }
+                    const t = nodeText(node);
+                    if (t)
+                        entry.t = t;
+                    pending[String(index)] = entry;
+                }
+                index++;
+            }
+            else if (node.content) {
+                walk(node.content);
+            }
+        }
+    }
+    walk(doc.content || []);
+    return Object.keys(pending).length > 0 ? pending : undefined;
+}
+/**
+ * Convert TipTap document to markdown with JSON frontmatter.
+ * Metadata stored as minified JSON between --- delimiters (valid YAML).
+ * Editor never sees frontmatter — it's stripped on load, regenerated on save.
+ * Pending state is persisted in frontmatter `pending` key.
+ */
+export function tiptapToMarkdown(doc, title, metadata) {
+    const meta = { ...metadata, title };
+    // Collect pending state from node attrs into frontmatter
+    const pendingState = collectPendingState(doc);
+    if (pendingState) {
+        meta.pending = pendingState;
+    }
+    else {
+        delete meta.pending;
+    }
+    // Strip undefined/null values
+    for (const key of Object.keys(meta)) {
+        if (meta[key] === undefined || meta[key] === null)
+            delete meta[key];
+    }
+    const frontmatter = `---\n${JSON.stringify(meta)}\n---\n\n`;
+    const body = nodesToMarkdown(doc.content || []);
+    return frontmatter + body;
+}
+function nodesToMarkdown(nodes) {
+    let result = '';
+    for (const node of nodes) {
+        result += nodeToMarkdown(node, '');
+    }
+    return result;
+}
+function nodeToMarkdown(node, indent) {
+    switch (node.type) {
+        case 'heading': {
+            const level = node.attrs?.level || 1;
+            const prefix = '#'.repeat(level);
+            return `${prefix} ${inlineToMarkdown(node.content)}\n\n`;
+        }
+        case 'paragraph': {
+            const text = inlineToMarkdown(node.content);
+            return text ? `${indent}${text}\n\n` : '\n';
+        }
+        case 'bulletList':
+            return listToMarkdown(node.content, '- ', indent);
+        case 'orderedList':
+            return listToMarkdown(node.content, null, indent);
+        case 'taskList':
+            return taskListToMarkdown(node.content, indent);
+        case 'blockquote': {
+            const inner = nodesToMarkdown(node.content || []);
+            return inner
+                .split('\n')
+                .map((line) => (line ? `> ${line}` : '>'))
+                .join('\n') + '\n';
+        }
+        case 'codeBlock': {
+            const lang = node.attrs?.language || '';
+            const text = extractPlainText(node.content);
+            return `\`\`\`${lang}\n${text}\n\`\`\`\n\n`;
+        }
+        case 'horizontalRule':
+            return '---\n\n';
+        case 'image': {
+            const src = node.attrs?.src || '';
+            const alt = node.attrs?.alt || '';
+            return `![${alt}](${src})\n\n`;
+        }
+        case 'table':
+            return tableToMarkdown(node);
+        default:
+            if (node.content)
+                return nodesToMarkdown(node.content);
+            if (node.text)
+                return node.text;
+            return '';
+    }
+}
+function listToMarkdown(items, bullet, indent) {
+    if (!items)
+        return '';
+    let result = '';
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const prefix = bullet || `${i + 1}. `;
+        const content = item.content || [];
+        for (let j = 0; j < content.length; j++) {
+            const child = content[j];
+            if (j === 0) {
+                const text = child.type === 'paragraph' ? inlineToMarkdown(child.content) : nodeToMarkdown(child, '');
+                result += `${indent}${prefix}${text.trimEnd()}\n`;
+            }
+            else {
+                result += nodeToMarkdown(child, indent + '  ');
+            }
+        }
+    }
+    return result + '\n';
+}
+function taskListToMarkdown(items, indent) {
+    if (!items)
+        return '';
+    let result = '';
+    for (const item of items) {
+        const checked = item.attrs?.checked ? 'x' : ' ';
+        const content = item.content || [];
+        for (let j = 0; j < content.length; j++) {
+            const child = content[j];
+            if (j === 0) {
+                const text = child.type === 'paragraph' ? inlineToMarkdown(child.content) : nodeToMarkdown(child, '');
+                result += `${indent}- [${checked}] ${text.trimEnd()}\n`;
+            }
+            else {
+                result += nodeToMarkdown(child, indent + '  ');
+            }
+        }
+    }
+    return result + '\n';
+}
+function tableToMarkdown(node) {
+    const rows = node.content || [];
+    if (rows.length === 0)
+        return '';
+    const lines = [];
+    let isFirstRow = true;
+    for (const row of rows) {
+        const cells = row.content || [];
+        const cellTexts = cells.map((cell) => {
+            const para = cell.content?.[0];
+            return para ? inlineToMarkdown(para.content) : '';
+        });
+        lines.push(`| ${cellTexts.join(' | ')} |`);
+        if (isFirstRow) {
+            const hasHeaders = cells.some((c) => c.type === 'tableHeader');
+            if (hasHeaders) {
+                lines.push(`| ${cellTexts.map(() => '---').join(' | ')} |`);
+            }
+            isFirstRow = false;
+        }
+    }
+    return lines.join('\n') + '\n\n';
+}
+// ---- Inline mark serialization ----
+const SERIALIZED_MARKS = ['bold', 'italic', 'code', 'strike', 'underline', 'highlight', 'subscript', 'superscript', 'link'];
+export function inlineToMarkdown(nodes) {
+    if (!nodes)
+        return '';
+    let result = '';
+    let openMarks = [];
+    for (const node of nodes) {
+        if (node.type === 'hardBreak') {
+            result += closeAllMarks(openMarks);
+            openMarks = [];
+            result += '\n';
+            continue;
+        }
+        if (node.type !== 'text')
+            continue;
+        const targetMarks = (node.marks || []).filter((m) => SERIALIZED_MARKS.includes(m.type));
+        // Find common prefix of marks between open and target
+        let commonLen = 0;
+        while (commonLen < openMarks.length && commonLen < targetMarks.length) {
+            if (!marksEqual(openMarks[commonLen], targetMarks[commonLen]))
+                break;
+            commonLen++;
+        }
+        // Close marks that are no longer needed (reverse order)
+        for (let i = openMarks.length - 1; i >= commonLen; i--) {
+            result += markSyntax(openMarks[i], false);
+        }
+        // Open new marks
+        for (let i = commonLen; i < targetMarks.length; i++) {
+            result += markSyntax(targetMarks[i], true);
+        }
+        result += node.text || '';
+        openMarks = [...targetMarks];
+    }
+    // Close remaining marks
+    for (let i = openMarks.length - 1; i >= 0; i--) {
+        result += markSyntax(openMarks[i], false);
+    }
+    return result;
+}
+function markSyntax(mark, isOpen) {
+    switch (mark.type) {
+        case 'bold': return '**';
+        case 'italic': return '*';
+        case 'code': return '`';
+        case 'strike': return '~~';
+        case 'underline': return '++';
+        case 'highlight': return '==';
+        case 'subscript': return '~';
+        case 'superscript': return '^';
+        case 'link': return isOpen ? '[' : `](<${mark.attrs?.href || ''}>)`;
+        default: return '';
+    }
+}
+function marksEqual(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.type === 'link')
+        return a.attrs?.href === b.attrs?.href;
+    return true;
+}
+function closeAllMarks(marks) {
+    let result = '';
+    for (let i = marks.length - 1; i >= 0; i--) {
+        result += markSyntax(marks[i], false);
+    }
+    return result;
+}
+function extractPlainText(nodes) {
+    if (!nodes)
+        return '';
+    return nodes.map((n) => n.text || '').join('');
+}

package/dist/server/markdown.js

@@ -0,0 +1,6 @@
+/**
+ * Barrel re-export for markdown serialization and parsing.
+ * All existing imports from './markdown.js' continue to work unchanged.
+ */
+export { tiptapToMarkdown, nodeText, inlineToMarkdown } from './markdown-serialize.js';
+export { markdownToTiptap, markdownToNodes } from './markdown-parse.js';