termdock 1.4.309 → 1.4.310

package/dist/server/architecture/documentDiff.js

@@ -0,0 +1,34 @@
+import { ARCHITECTURE_FIELDS } from './document.js';
+/** Compare semantic document content, excluding timestamps and update counters. */
+export function diffArchitecture(before, after) {
+    const changes = [];
+    const oldViews = new Map(before?.perspectives.map(view => [view.id, view]) ?? []);
+    for (const view of after.perspectives) {
+        const previous = oldViews.get(view.id);
+        oldViews.delete(view.id);
+        if (!previous)
+            changes.push({ perspective: view.id, title: view.title, kind: 'added', fields: [] });
+        else {
+            const changed = ['title', 'summary', 'edges', ...ARCHITECTURE_FIELDS].filter(key => JSON.stringify(previous[key]) !== JSON.stringify(view[key]));
+            if (changed.length)
+                changes.push({ perspective: view.id, title: view.title, kind: 'changed', fields: changed });
+        }
+        const oldNodes = new Map(previous?.nodes.map(node => [node.id, node]) ?? []);
+        for (const node of view.nodes) {
+            const old = oldNodes.get(node.id);
+            oldNodes.delete(node.id);
+            if (!old)
+                changes.push({ perspective: view.id, node: node.id, title: node.title, kind: 'added', fields: [] });
+            else {
+                const changed = ['title', 'summary', 'parentId', 'files', 'references', 'role', ...ARCHITECTURE_FIELDS].filter(key => JSON.stringify(old[key]) !== JSON.stringify(node[key]));
+                if (changed.length)
+                    changes.push({ perspective: view.id, node: node.id, title: node.title, kind: 'changed', fields: changed });
+            }
+        }
+        for (const old of oldNodes.values())
+            changes.push({ perspective: view.id, node: old.id, title: old.title, kind: 'removed', fields: [] });
+    }
+    for (const old of oldViews.values())
+        changes.push({ perspective: old.id, title: old.title, kind: 'removed', fields: [] });
+    return changes;
+}

package/dist/server/architecture/fieldMutation.js

@@ -0,0 +1,52 @@
+import { ARCHITECTURE_FIELDS, parseArchitecture } from './document.js';
+import { parseFlowchart } from './flowchart.js';
+/** Keep native structural data and its editable Mermaid field consistent. */
+export function updateArchitectureField(input, perspective, nodeId, field, value) {
+    if (!ARCHITECTURE_FIELDS.includes(field) || typeof value !== 'string' || value.length > 100_000)
+        throw new Error('Invalid architecture field');
+    const document = parseArchitecture(JSON.stringify(input));
+    const view = document.perspectives.find(view => view.id === perspective);
+    const target = nodeId ? view?.nodes.find(node => node.id === nodeId) : view;
+    if (!view || !target)
+        throw new Error('Architecture element not found');
+    target[field] = value;
+    if (field === 'description')
+        target.summary = value.replace(/[#*`]/g, '').split(/\n\s*\n/)[0].slice(0, 600);
+    if (field === 'diagram') {
+        const graph = parseFlowchart(value);
+        const invalid = graph.issues.filter(issue => !issue.startsWith('Connection needs'));
+        if (invalid.length)
+            throw new Error(invalid.join('\n'));
+        const direct = view.nodes.filter(node => node.parentId === nodeId);
+        const removed = new Set(direct.filter(node => !graph.nodes.some(item => item.id === node.id)).map(node => node.id));
+        for (let index = 0; index < view.nodes.length; index++)
+            for (const node of view.nodes)
+                if (node.parentId && removed.has(node.parentId))
+                    removed.add(node.id);
+        view.nodes = view.nodes.filter(node => !removed.has(node.id));
+        const directIds = new Set(direct.map(node => node.id));
+        view.edges = view.edges.filter(edge => !removed.has(edge.from) && !removed.has(edge.to) && !(directIds.has(edge.from) && directIds.has(edge.to)));
+        for (const item of graph.nodes) {
+            let node = view.nodes.find(node => node.id === item.id);
+            if (node && node.parentId !== nodeId)
+                throw new Error(`Diagram ID belongs to another level: ${item.id}`);
+            if (!node) {
+                node = { id: item.id, title: item.label.split('\n')[0], summary: '', files: [], ...(nodeId ? { parentId: nodeId } : {}) };
+                view.nodes.push(node);
+            }
+            node.title = item.label.split('\n')[0];
+            node.role = item.role;
+            if (item.ref) {
+                if (!document.perspectives.some(view => view.id === item.ref))
+                    throw new Error(`Reference does not exist: ${item.ref}`);
+                node.references = [{ perspective: item.ref }];
+            }
+        }
+        view.edges.push(...graph.edges);
+        for (const other of document.perspectives)
+            for (const node of other.nodes)
+                if (node.references?.some(ref => ref.perspective === perspective && ref.node && removed.has(ref.node)))
+                    throw new Error('A removed node is referenced by another perspective');
+    }
+    return parseArchitecture(JSON.stringify(document));
+}

package/dist/server/architecture/flowchart.js

@@ -0,0 +1,62 @@
+export function parseFlowchart(raw) {
+    if (raw.length > 100_000)
+        throw new Error('Diagram is too large');
+    const nodes = new Map(), edges = [], issues = [];
+    const clean = (value) => value.replace(/<br\s*\/?>/gi, '\n').replace(/\\n/g, '\n');
+    const token = (value) => {
+        const match = value.trim().match(/^(@?[\w-]+)(?:\s*(?:\[|\(\(?|\{)\s*(.*?)\s*(?:\]|\)\)?|\}))?(?:::\w+)?$/);
+        if (!match)
+            return null;
+        const id = match[1].replace(/^@/, ''), label = clean((match[2] ?? id).replace(/^"|"$/g, ''));
+        const ref = label.match(/^@([\w-]+)(?:\n|$)/)?.[1] ?? (match[1].startsWith('@') ? id : undefined);
+        return { id, label, ...(ref ? { ref } : {}) };
+    };
+    const put = (node) => { const previous = nodes.get(node.id); if (!previous || node.label !== node.id)
+        nodes.set(node.id, node); };
+    const lines = raw.split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('%%'));
+    if (raw && !/^(?:graph|flowchart)\s+(?:LR|RL|TD|TB|BT)\b/i.test(lines[0] ?? ''))
+        issues.push('Diagram must start with a flowchart direction');
+    for (const original of lines) {
+        const line = original.replace(/;\s*$/, '');
+        if (/^(graph|flowchart|classDef|click\s|style\s|linkStyle|subgraph|end$)/i.test(line))
+            continue;
+        const cls = line.match(/^class\s+([\w\-,\s]+)\s+(entry|store|external|concern)$/);
+        if (cls) {
+            for (const id of cls[1].split(',').map(value => value.trim())) {
+                const node = nodes.get(id);
+                if (node)
+                    node.role = cls[2];
+            }
+            continue;
+        }
+        if (/^class\s/.test(line))
+            continue;
+        const quoted = line.match(/^(.+?)\s+--\s+"([^"]+)"\s+-->\s+(.+)$/);
+        const parts = quoted ? [quoted[1], quoted[2], quoted[3]] : line.split(/(-->(?:\|[^|]*\|)?|--o|--x|---|-\.->|==>|~~>)/);
+        if (parts.length >= 3) {
+            for (let index = 0; index + 2 < parts.length; index += 2) {
+                const from = token(parts[index]), to = token(parts[index + 2]);
+                if (!from || !to) {
+                    issues.push(`Unrecognized connection: ${line}`);
+                    continue;
+                }
+                put(from);
+                put(to);
+                const label = clean(quoted ? parts[index + 1] : (parts[index + 1].match(/\|([^|]*)\|/)?.[1] ?? '').replace(/^"|"$/g, ''));
+                edges.push({ from: from.id, to: to.id, label });
+                if (!label)
+                    issues.push(`Connection needs a label: ${from.id} → ${to.id}`);
+            }
+        }
+        else {
+            const node = token(line);
+            if (node)
+                put(node);
+            else
+                issues.push(`Unrecognized diagram line: ${line}`);
+        }
+    }
+    if (nodes.size > 200 || edges.length > 600)
+        throw new Error('Diagram exceeds the architecture limit');
+    return { nodes: [...nodes.values()], edges, issues };
+}

package/dist/server/architecture/mermaidDiff.js

@@ -0,0 +1,85 @@
+/**
+ * Lightweight mermaid parser — extracts node IDs and edges from mermaid text.
+ * Handles: graph/flowchart LR/TD/TB, subgraph, and common arrow syntaxes.
+ */
+export function parseMermaid(text) {
+    const nodes = new Set();
+    const edges = new Set();
+    const lines = text.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('%%'));
+    for (const line of lines) {
+        // Skip directives, classDef, click, style, etc.
+        if (/^(graph|flowchart|sequenceDiagram|classDiagram|erDiagram|gantt|pie|gitGraph)/i.test(line))
+            continue;
+        if (/^(classDef|class |click |style |linkStyle|subgraph|end$)/i.test(line))
+            continue;
+        if (/^%%\{/.test(line))
+            continue;
+        // Match edges: A --> B, A -->|label| B, A -- text --> B, etc.
+        const edgePattern = /^(\S+?)(?:\[.*?\]|(?:\(.*?\))|\{.*?\}|>.*?])?(\s*)(-->|--o|--x|---|-.->|==>|~~>|--\|.*?\|)(\s*)(\S+?)(?:\[.*?\]|(?:\(.*?\))|\{.*?\}|>.*?])?$/;
+        const edgeMatch = line.match(edgePattern);
+        if (edgeMatch) {
+            const [, src, , arrow, , dst] = edgeMatch;
+            const srcId = src.replace(/["']/g, '');
+            const dstId = dst.replace(/["']/g, '');
+            nodes.add(srcId);
+            nodes.add(dstId);
+            edges.add(`${srcId} ${arrow} ${dstId}`);
+            continue;
+        }
+        // Broader edge match for complex syntax: A[Label] --> B[Label]
+        const broadEdge = /^([^\s[\]({]+).*?(-->|--o|--x|---|-.->|==>|~~>).*?([^\s[\]({]+)/;
+        const broadMatch = line.match(broadEdge);
+        if (broadMatch) {
+            const [, src, arrow, dst] = broadMatch;
+            const srcId = src.replace(/["']/g, '');
+            const dstId = dst.replace(/["']/g, '');
+            nodes.add(srcId);
+            nodes.add(dstId);
+            edges.add(`${srcId} ${arrow} ${dstId}`);
+            continue;
+        }
+        // Standalone node: A[Label] or A((Label)) or A{Label}
+        const nodeMatch = line.match(/^([^\s[\]({]+)[\[({]/);
+        if (nodeMatch) {
+            nodes.add(nodeMatch[1].replace(/["']/g, ''));
+        }
+    }
+    return { nodes, edges };
+}
+export function diffMermaid(before, after) {
+    const prev = parseMermaid(before);
+    const curr = parseMermaid(after);
+    const added_nodes = [...curr.nodes].filter(n => !prev.nodes.has(n));
+    const removed_nodes = [...prev.nodes].filter(n => !curr.nodes.has(n));
+    const added_edges = [...curr.edges].filter(e => !prev.edges.has(e));
+    const removed_edges = [...prev.edges].filter(e => !curr.edges.has(e));
+    return {
+        added_nodes,
+        removed_nodes,
+        added_edges,
+        removed_edges,
+        has_changes: added_nodes.length > 0 || removed_nodes.length > 0 || added_edges.length > 0 || removed_edges.length > 0,
+    };
+}
+export function formatDiff(diff) {
+    if (!diff.has_changes)
+        return 'No changes detected.\n';
+    const lines = [];
+    if (diff.added_nodes.length) {
+        lines.push('Added nodes:');
+        diff.added_nodes.forEach(n => lines.push(`  + ${n}`));
+    }
+    if (diff.removed_nodes.length) {
+        lines.push('Removed nodes:');
+        diff.removed_nodes.forEach(n => lines.push(`  - ${n}`));
+    }
+    if (diff.added_edges.length) {
+        lines.push('Added edges:');
+        diff.added_edges.forEach(e => lines.push(`  + ${e}`));
+    }
+    if (diff.removed_edges.length) {
+        lines.push('Removed edges:');
+        diff.removed_edges.forEach(e => lines.push(`  - ${e}`));
+    }
+    return lines.join('\n') + '\n';
+}

package/dist/server/architecture/routes.js

@@ -0,0 +1,117 @@
+import { Router } from 'express';
+import { pathValidator } from '../utils/pathValidator.js';
+import { ARCHITECTURE_FIELDS, ARCHITECTURE_FILE } from './document.js';
+import { ArchitectureConflict, ArchitectureStore } from './store.js';
+import { updateArchitectureField } from './fieldMutation.js';
+/** Mounted below /api/terminal, after its existing auth, CSRF and encrypted transport. */
+export function architectureRoutes() {
+    const router = Router();
+    router.use(async (req, res, next) => {
+        try {
+            const requested = req.method === 'GET' ? req.query.root : req.body?.root;
+            if (typeof requested !== 'string') {
+                res.status(400).json({ error: 'Project root is required' });
+                return;
+            }
+            const root = await (req.pathValidator ?? pathValidator).validateAsync(requested);
+            res.locals.architectureStore = new ArchitectureStore(root);
+            next();
+        }
+        catch (error) {
+            res.status(403).json({ error: error instanceof Error ? error.message : 'Project cannot be accessed' });
+        }
+    });
+    const store = (res) => res.locals.architectureStore;
+    router.get('/documents', async (_req, res, next) => { try {
+        res.json({ files: await store(res).list() });
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.get('/document', async (req, res, next) => { try {
+        res.json(await store(res).read(typeof req.query.file === 'string' ? req.query.file : ARCHITECTURE_FILE));
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.put('/document', async (req, res, next) => { try {
+        res.json(await store(res).save(req.body.file ?? ARCHITECTURE_FILE, req.body.document, req.body.revision));
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.get('/history', async (req, res, next) => { try {
+        res.json({ versions: await store(res).history(String(req.query.file ?? ARCHITECTURE_FILE)) });
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.get('/version', async (req, res, next) => { try {
+        res.json({ document: await store(res).historical(String(req.query.file), String(req.query.id)) });
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.get('/bundle', async (req, res, next) => {
+        try {
+            const file = String(req.query.file ?? ARCHITECTURE_FILE), storage = store(res);
+            const loaded = await storage.read(file);
+            if (!loaded.document) {
+                res.status(404).json({ error: 'Architecture document not found' });
+                return;
+            }
+            res.json(file === '.omm' ? await storage.exportOmmBundle() : await storage.exportOmmBundle(loaded.document));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.put('/bundle', async (req, res, next) => { try {
+        await store(res).importOmmBundle(req.body.bundle, req.body.revision);
+        res.json(await store(res).read('.omm'));
+    }
+    catch (error) {
+        next(error);
+    } });
+    router.put('/field', async (req, res, next) => {
+        try {
+            const { file = ARCHITECTURE_FILE, perspective, node, field, value, revision } = req.body;
+            if (!ARCHITECTURE_FIELDS.includes(field) || typeof value !== 'string' || value.length > 100_000) {
+                res.status(400).json({ error: 'Invalid architecture field' });
+                return;
+            }
+            const storage = store(res);
+            if (file === '.omm') {
+                const loaded = await storage.read('.omm'), view = loaded.document?.perspectives.find(view => view.id === perspective);
+                const target = node ? view?.nodes.find(item => item.id === node) : view;
+                if (!view || !target) {
+                    res.status(404).json({ error: 'Architecture element not found' });
+                    return;
+                }
+                // Resolve opaque viewer IDs back to .omm paths through the store's stable IDs.
+                const { createHash } = await import('node:crypto');
+                const element = node ? ('documentPath' in target && typeof target.documentPath === 'string' && target.documentPath.startsWith(`${view.id}/`) && `e_${createHash('sha256').update(target.documentPath).digest('hex').slice(0, 20)}` === node ? target.documentPath : undefined) : view.id;
+                if (!element) {
+                    res.status(404).json({ error: 'Architecture element has no document yet' });
+                    return;
+                }
+                res.json(await storage.writeOmmField(element, field, value, revision));
+                return;
+            }
+            const loaded = await storage.read(file);
+            if (!loaded.document) {
+                res.status(404).json({ error: 'Architecture document not found' });
+                return;
+            }
+            const document = updateArchitectureField(loaded.document, perspective, node, field, value);
+            res.json(await storage.save(file, document, revision));
+        }
+        catch (error) {
+            next(error);
+        }
+    });
+    router.use((error, _req, res, _next) => {
+        res.status(error instanceof ArchitectureConflict ? 409 : 400).json({ error: error instanceof Error ? error.message : 'Architecture operation failed' });
+    });
+    return router;
+}