openwriter 0.1.0

package/dist/server/sync-routes.js

@@ -0,0 +1,75 @@
+/**
+ * Express routes for GitHub sync.
+ * Mounted in index.ts — follows version-routes.ts pattern.
+ */
+import { Router } from 'express';
+import { getSyncStatus, getCapabilities, getPendingFiles, setupWithGh, setupWithPat, connectExisting, pushSync, } from './git-sync.js';
+export function createSyncRouter(broadcastSyncStatus) {
+    const router = Router();
+    router.get('/api/sync/status', async (_req, res) => {
+        try {
+            res.json(await getSyncStatus());
+        }
+        catch (err) {
+            res.status(500).json({ state: 'error', error: err.message });
+        }
+    });
+    router.get('/api/sync/capabilities', async (_req, res) => {
+        try {
+            res.json(await getCapabilities());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.get('/api/sync/pending', async (_req, res) => {
+        try {
+            res.json(await getPendingFiles());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/api/sync/setup', async (req, res) => {
+        try {
+            const { method, repoName, remoteUrl, pat, isPrivate } = req.body;
+            if (method === 'gh') {
+                await setupWithGh(repoName || 'openwriter-docs', isPrivate !== false);
+            }
+            else if (method === 'pat') {
+                if (!pat) {
+                    res.status(400).json({ error: 'PAT is required' });
+                    return;
+                }
+                await setupWithPat(pat, repoName || 'openwriter-docs', isPrivate !== false);
+            }
+            else if (method === 'connect') {
+                if (!remoteUrl) {
+                    res.status(400).json({ error: 'Remote URL is required' });
+                    return;
+                }
+                await connectExisting(remoteUrl, pat);
+            }
+            else {
+                res.status(400).json({ error: 'Invalid method. Use: gh, pat, or connect' });
+                return;
+            }
+            const status = await getSyncStatus();
+            broadcastSyncStatus(status);
+            res.json({ success: true, status });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    router.post('/api/sync/push', async (_req, res) => {
+        try {
+            const result = await pushSync(broadcastSyncStatus);
+            res.json(result);
+        }
+        catch (err) {
+            res.status(500).json({ state: 'error', error: err.message });
+        }
+    });
+    return router;
+}

package/dist/server/text-edit.js

@@ -0,0 +1,249 @@
+/**
+ * Text matching + content manipulation helpers for fine-grained agent edits.
+ * Works on TipTap JSON node content arrays (text nodes with marks).
+ */
+/**
+ * Find text within a flat array of TipTap text nodes.
+ * Returns the indices and offsets of the matching text nodes.
+ */
+function findTextInContent(content, searchText) {
+    // Build a flat text string from all text nodes
+    let flatText = '';
+    const offsets = [];
+    for (let i = 0; i < content.length; i++) {
+        const node = content[i];
+        if (node.type !== 'text' || !node.text)
+            continue;
+        const start = flatText.length;
+        flatText += node.text;
+        offsets.push({ idx: i, start, end: flatText.length });
+    }
+    const matchStart = flatText.indexOf(searchText);
+    if (matchStart === -1)
+        return null;
+    const matchEnd = matchStart + searchText.length;
+    let startIdx = -1, startOffset = 0;
+    let endIdx = -1, endOffset = 0;
+    for (const o of offsets) {
+        if (startIdx === -1 && matchStart >= o.start && matchStart < o.end) {
+            startIdx = o.idx;
+            startOffset = matchStart - o.start;
+        }
+        if (matchEnd > o.start && matchEnd <= o.end) {
+            endIdx = o.idx;
+            endOffset = matchEnd - o.start;
+            break;
+        }
+    }
+    if (startIdx === -1 || endIdx === -1)
+        return null;
+    return { startIdx, startOffset, endIdx, endOffset };
+}
+/**
+ * Deep clone a node.
+ */
+function cloneNode(node) {
+    return JSON.parse(JSON.stringify(node));
+}
+/**
+ * Split a text node at a character offset, returning [before, after].
+ * Either may be null if the split is at the boundary.
+ */
+function splitTextNode(node, offset) {
+    if (offset <= 0)
+        return [null, cloneNode(node)];
+    if (offset >= node.text.length)
+        return [cloneNode(node), null];
+    const before = {
+        type: 'text',
+        text: node.text.slice(0, offset),
+    };
+    if (node.marks)
+        before.marks = cloneNode(node.marks);
+    const after = {
+        type: 'text',
+        text: node.text.slice(offset),
+    };
+    if (node.marks)
+        after.marks = cloneNode(node.marks);
+    return [before, after];
+}
+/**
+ * Apply a single text edit to a node's content array.
+ * Returns the modified content array and the character range of the edit
+ * (for inline decoration tracking).
+ */
+function applySingleEdit(content, edit) {
+    const match = findTextInContent(content, edit.find);
+    if (!match)
+        return null;
+    const { startIdx, startOffset, endIdx, endOffset } = match;
+    // Calculate character offsets for the edit range (for inline decorations)
+    let charsBefore = 0;
+    for (let i = 0; i < startIdx; i++) {
+        if (content[i].type === 'text')
+            charsBefore += content[i].text.length;
+    }
+    const editFrom = charsBefore + startOffset;
+    // Build new content array with the edit applied
+    const result = [];
+    // Copy nodes before the match
+    for (let i = 0; i < startIdx; i++) {
+        result.push(cloneNode(content[i]));
+    }
+    // Handle the matched region
+    if (startIdx === endIdx) {
+        // Match is within a single text node
+        const node = content[startIdx];
+        const [beforePart] = splitTextNode(node, startOffset);
+        const [, afterPart] = splitTextNode(node, endOffset);
+        if (beforePart)
+            result.push(beforePart);
+        if (edit.replace !== undefined) {
+            // Replace text
+            const replaced = {
+                type: 'text',
+                text: edit.replace,
+            };
+            if (node.marks)
+                replaced.marks = cloneNode(node.marks);
+            if (edit.addMark) {
+                replaced.marks = replaced.marks || [];
+                replaced.marks.push(cloneNode(edit.addMark));
+            }
+            if (edit.removeMark) {
+                replaced.marks = (replaced.marks || []).filter((m) => m.type !== edit.removeMark);
+            }
+            if (replaced.text)
+                result.push(replaced);
+        }
+        else {
+            // Keep text, modify marks
+            const matched = {
+                type: 'text',
+                text: node.text.slice(startOffset, endOffset),
+                marks: node.marks ? cloneNode(node.marks) : [],
+            };
+            if (edit.addMark) {
+                matched.marks = matched.marks || [];
+                matched.marks.push(cloneNode(edit.addMark));
+            }
+            if (edit.removeMark) {
+                matched.marks = (matched.marks || []).filter((m) => m.type !== edit.removeMark);
+            }
+            result.push(matched);
+        }
+        if (afterPart)
+            result.push(afterPart);
+    }
+    else {
+        // Match spans multiple text nodes
+        // Start node: text after startOffset
+        const startNode = content[startIdx];
+        const [beforeStart] = splitTextNode(startNode, startOffset);
+        if (beforeStart)
+            result.push(beforeStart);
+        if (edit.replace !== undefined) {
+            // Replace entire matched span with new text
+            const replaced = {
+                type: 'text',
+                text: edit.replace,
+            };
+            if (startNode.marks)
+                replaced.marks = cloneNode(startNode.marks);
+            if (edit.addMark) {
+                replaced.marks = replaced.marks || [];
+                replaced.marks.push(cloneNode(edit.addMark));
+            }
+            if (edit.removeMark) {
+                replaced.marks = (replaced.marks || []).filter((m) => m.type !== edit.removeMark);
+            }
+            if (replaced.text)
+                result.push(replaced);
+        }
+        else {
+            // Keep text, modify marks on each matched node
+            const startText = startNode.text.slice(startOffset);
+            if (startText) {
+                const modified = {
+                    type: 'text',
+                    text: startText,
+                    marks: startNode.marks ? cloneNode(startNode.marks) : [],
+                };
+                if (edit.addMark) {
+                    modified.marks = modified.marks || [];
+                    modified.marks.push(cloneNode(edit.addMark));
+                }
+                if (edit.removeMark) {
+                    modified.marks = (modified.marks || []).filter((m) => m.type !== edit.removeMark);
+                }
+                result.push(modified);
+            }
+            // Middle nodes: fully inside match
+            for (let i = startIdx + 1; i < endIdx; i++) {
+                const midNode = cloneNode(content[i]);
+                if (edit.addMark) {
+                    midNode.marks = midNode.marks || [];
+                    midNode.marks.push(cloneNode(edit.addMark));
+                }
+                if (edit.removeMark) {
+                    midNode.marks = (midNode.marks || []).filter((m) => m.type !== edit.removeMark);
+                }
+                result.push(midNode);
+            }
+            // End node: text before endOffset
+            const endNode = content[endIdx];
+            const endText = endNode.text.slice(0, endOffset);
+            if (endText) {
+                const modified = {
+                    type: 'text',
+                    text: endText,
+                    marks: endNode.marks ? cloneNode(endNode.marks) : [],
+                };
+                if (edit.addMark) {
+                    modified.marks = modified.marks || [];
+                    modified.marks.push(cloneNode(edit.addMark));
+                }
+                if (edit.removeMark) {
+                    modified.marks = (modified.marks || []).filter((m) => m.type !== edit.removeMark);
+                }
+                result.push(modified);
+            }
+        }
+        // End node remainder
+        const endNode = content[endIdx];
+        const [, afterEnd] = splitTextNode(endNode, endOffset);
+        if (afterEnd)
+            result.push(afterEnd);
+    }
+    // Copy nodes after the match
+    for (let i = endIdx + 1; i < content.length; i++) {
+        result.push(cloneNode(content[i]));
+    }
+    // Calculate the edit end position in the new content
+    const editTo = editFrom + (edit.replace !== undefined ? edit.replace.length : edit.find.length);
+    const editType = edit.replace !== undefined ? 'rewrite' : (edit.addMark ? 'insert' : 'rewrite');
+    return { content: result, from: editFrom, to: editTo, type: editType };
+}
+/**
+ * Apply multiple text edits to a TipTap node (block-level node with inline content).
+ * Returns the modified node and the array of inline edit ranges for decorations.
+ */
+export function applyTextEditsToNode(node, edits) {
+    if (!node.content || !Array.isArray(node.content))
+        return null;
+    let currentContent = node.content.filter((n) => n.type === 'text');
+    const textEditRanges = [];
+    for (const edit of edits) {
+        const result = applySingleEdit(currentContent, edit);
+        if (!result)
+            continue;
+        currentContent = result.content;
+        textEditRanges.push({ from: result.from, to: result.to, type: result.type });
+    }
+    if (textEditRanges.length === 0)
+        return null;
+    const modifiedNode = cloneNode(node);
+    modifiedNode.content = currentContent;
+    return { node: modifiedNode, textEdits: textEditRanges };
+}

package/dist/server/version-routes.js

@@ -0,0 +1,79 @@
+/**
+ * Express routes for document version history.
+ * Mounted in index.ts to keep the main file lean.
+ */
+import { Router } from 'express';
+import { forceSnapshot, listVersions, getVersionContent, restoreVersion } from './versions.js';
+import { markAllNodesAsPending } from './state.js';
+export function createVersionRouter(s) {
+    const router = Router();
+    // List versions for current doc
+    router.get('/api/versions', (_req, res) => {
+        const docId = s.getDocId();
+        if (!docId) {
+            res.json([]);
+            return;
+        }
+        res.json(listVersions(docId));
+    });
+    // Get version content by timestamp
+    router.get('/api/versions/:ts', (req, res) => {
+        const docId = s.getDocId();
+        const ts = parseInt(req.params.ts, 10);
+        if (!docId || isNaN(ts)) {
+            res.status(400).json({ error: 'Invalid request' });
+            return;
+        }
+        const content = getVersionContent(docId, ts);
+        if (!content) {
+            res.status(404).json({ error: 'Version not found' });
+            return;
+        }
+        res.json({ content });
+    });
+    // Restore a version
+    router.post('/api/versions/:ts/restore', (req, res) => {
+        const docId = s.getDocId();
+        const ts = parseInt(req.params.ts, 10);
+        const mode = req.body.mode;
+        if (!docId || isNaN(ts) || !mode) {
+            res.status(400).json({ error: 'docId, ts, and mode are required' });
+            return;
+        }
+        // Safety net: snapshot current state before restoring
+        try {
+            forceSnapshot(docId, s.getFilePath());
+        }
+        catch { /* best effort */ }
+        const parsed = restoreVersion(docId, ts);
+        if (!parsed) {
+            res.status(404).json({ error: 'Version not found' });
+            return;
+        }
+        if (mode === 'review') {
+            markAllNodesAsPending(parsed.document, 'rewrite');
+        }
+        s.updateDocument(parsed.document);
+        s.save();
+        const filePath = s.getFilePath();
+        const filename = filePath ? filePath.split(/[/\\]/).pop() || '' : '';
+        s.broadcastDocumentSwitched(parsed.document, parsed.title, filename);
+        res.json({ success: true, mode });
+    });
+    // Manual checkpoint
+    router.post('/api/versions/snapshot', (_req, res) => {
+        const docId = s.getDocId();
+        if (!docId) {
+            res.status(400).json({ error: 'No active document' });
+            return;
+        }
+        try {
+            forceSnapshot(docId, s.getFilePath());
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/server/versions.js

@@ -0,0 +1,198 @@
+/**
+ * Document version history for OpenWriter.
+ * Automatic file-level snapshots so any document state can be recovered.
+ * Storage: ~/.openwriter/.versions/{docId}/{timestamp}.md
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { VERSIONS_DIR } from './helpers.js';
+import { markdownToTiptap } from './markdown.js';
+// ============================================================================
+// DEDUP STATE
+// ============================================================================
+const lastSnapshot = new Map();
+const MIN_INTERVAL_MS = 30_000; // 30 seconds between snapshots of same content
+function contentHash(markdown) {
+    return createHash('sha256').update(markdown).digest('hex').slice(0, 16);
+}
+// ============================================================================
+// DOC ID
+// ============================================================================
+/**
+ * Ensure metadata has a docId. Assigns an 8-char hex ID if missing.
+ * Returns the docId (existing or newly assigned).
+ */
+export function ensureDocId(metadata) {
+    if (metadata.docId && typeof metadata.docId === 'string') {
+        return metadata.docId;
+    }
+    const id = createHash('sha256')
+        .update(Date.now().toString() + Math.random().toString())
+        .digest('hex')
+        .slice(0, 8);
+    metadata.docId = id;
+    return id;
+}
+// ============================================================================
+// SNAPSHOT
+// ============================================================================
+function docDir(docId) {
+    return join(VERSIONS_DIR, docId);
+}
+function ensureDocDir(docId) {
+    const dir = docDir(docId);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+/**
+ * Seed the in-memory dedup map from the latest version on disk.
+ * Prevents duplicate snapshot after server restart.
+ */
+function seedLastSnapshot(docId) {
+    if (lastSnapshot.has(docId))
+        return;
+    const dir = docDir(docId);
+    if (!existsSync(dir))
+        return;
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => parseInt(f.replace('.md', ''), 10))
+        .filter((ts) => !isNaN(ts))
+        .sort((a, b) => b - a); // newest first
+    if (files.length === 0)
+        return;
+    const latest = files[0];
+    const content = readFileSync(join(dir, `${latest}.md`), 'utf-8');
+    lastSnapshot.set(docId, { time: latest, hash: contentHash(content) });
+}
+/**
+ * Snapshot after every writeToDisk() — skips if content unchanged or within throttle window.
+ * Called in best-effort mode (caller wraps in try/catch).
+ */
+export function snapshotIfNeeded(docId, filePath) {
+    if (!docId || !filePath || !existsSync(filePath))
+        return;
+    seedLastSnapshot(docId);
+    const markdown = readFileSync(filePath, 'utf-8');
+    const hash = contentHash(markdown);
+    const now = Date.now();
+    const last = lastSnapshot.get(docId);
+    if (last) {
+        // Skip if content hasn't changed (regardless of time)
+        if (hash === last.hash)
+            return;
+        // Skip if within minimum interval even if content changed
+        if ((now - last.time) < MIN_INTERVAL_MS)
+            return;
+    }
+    ensureDocDir(docId);
+    writeFileSync(join(docDir(docId), `${now}.md`), markdown, 'utf-8');
+    lastSnapshot.set(docId, { time: now, hash });
+    pruneVersions(docId);
+}
+/**
+ * Force a snapshot regardless of dedup. Used before restores as a safety net.
+ */
+export function forceSnapshot(docId, filePath) {
+    if (!docId || !filePath || !existsSync(filePath))
+        return;
+    const markdown = readFileSync(filePath, 'utf-8');
+    const hash = contentHash(markdown);
+    const now = Date.now();
+    ensureDocDir(docId);
+    writeFileSync(join(docDir(docId), `${now}.md`), markdown, 'utf-8');
+    lastSnapshot.set(docId, { time: now, hash });
+}
+// ============================================================================
+// LIST / GET
+// ============================================================================
+/**
+ * List all versions for a docId, sorted newest-first.
+ */
+export function listVersions(docId) {
+    if (!docId)
+        return [];
+    const dir = docDir(docId);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => {
+        const ts = parseInt(f.replace('.md', ''), 10);
+        if (isNaN(ts))
+            return null;
+        const fullPath = join(dir, f);
+        try {
+            const stat = statSync(fullPath);
+            const content = readFileSync(fullPath, 'utf-8');
+            const words = content.trim() ? content.trim().split(/\s+/).length : 0;
+            return {
+                timestamp: ts,
+                date: new Date(ts).toISOString(),
+                size: stat.size,
+                wordCount: words,
+            };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter((v) => v !== null)
+        .sort((a, b) => b.timestamp - a.timestamp);
+}
+/**
+ * Get raw markdown content of a specific version.
+ */
+export function getVersionContent(docId, ts) {
+    if (!docId)
+        return null;
+    const file = join(docDir(docId), `${ts}.md`);
+    if (!existsSync(file))
+        return null;
+    return readFileSync(file, 'utf-8');
+}
+/**
+ * Restore a version. Parses the snapshot markdown into TipTap JSON.
+ * Returns the parsed document for the caller to apply.
+ */
+export function restoreVersion(docId, ts) {
+    const markdown = getVersionContent(docId, ts);
+    if (!markdown)
+        return null;
+    return markdownToTiptap(markdown);
+}
+// ============================================================================
+// PRUNE
+// ============================================================================
+const MAX_VERSIONS = 50;
+const KEEP_ALL_WITHIN_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+/**
+ * Enforce retention: keep max(MAX_VERSIONS, all from last 7 days).
+ */
+export function pruneVersions(docId) {
+    if (!docId)
+        return;
+    const dir = docDir(docId);
+    if (!existsSync(dir))
+        return;
+    const files = readdirSync(dir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => ({
+        name: f,
+        ts: parseInt(f.replace('.md', ''), 10),
+    }))
+        .filter((f) => !isNaN(f.ts))
+        .sort((a, b) => b.ts - a.ts); // newest first
+    if (files.length <= MAX_VERSIONS)
+        return;
+    const cutoff = Date.now() - KEEP_ALL_WITHIN_MS;
+    // Keep all within 7 days + at most MAX_VERSIONS total
+    const toDelete = files.slice(MAX_VERSIONS).filter((f) => f.ts < cutoff);
+    for (const f of toDelete) {
+        try {
+            unlinkSync(join(dir, f.name));
+        }
+        catch { /* ignore */ }
+    }
+}