structured-context 0.10.0 → 0.12.0

package/dist/plugins/markdown/extract-content-links.js

@@ -0,0 +1,123 @@
+import { toString as mdastToString } from 'mdast-util-to-string';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+import { parseWikilink } from '../../read/wikilink-utils';
+/**
+ * Extract wikilinks (and Obsidian embed wikilinks) from a plain text string.
+ * Matches [[target]], ![[target]], [[target#anchor]], [[target|alias]], etc.
+ */
+function extractWikilinksFromText(text) {
+    const links = [];
+    for (const match of text.matchAll(/(!?)\[\[([^\]]+)\]\]/g)) {
+        const isEmbed = match[1] === '!';
+        const inner = match[2];
+        const { target, anchor, displayText } = parseWikilink(inner);
+        if (!target)
+            continue;
+        links.push({
+            text: displayText ?? target,
+            target,
+            action: isEmbed ? 'embed' : 'link',
+            ...(anchor !== undefined ? { anchor } : {}),
+            linkSyntax: 'wikilink',
+        });
+    }
+    return links;
+}
+/**
+ * Recursively walk an mdast subtree and collect all links.
+ * Handles standard markdown link/image nodes and scans text nodes for wikilinks.
+ */
+export function extractLinksFromAstNode(node) {
+    const links = [];
+    function walk(n) {
+        switch (n.type) {
+            case 'link': {
+                const linkNode = n;
+                links.push({
+                    text: mdastToString(linkNode),
+                    target: linkNode.url,
+                    action: 'link',
+                    linkSyntax: 'markdown',
+                });
+                // Don't recurse into children — they are display text, not link targets
+                break;
+            }
+            case 'image': {
+                const imgNode = n;
+                links.push({
+                    text: imgNode.alt ?? '',
+                    target: imgNode.url,
+                    action: 'embed',
+                    linkSyntax: 'markdown',
+                });
+                break;
+            }
+            case 'text': {
+                // Remark does not parse wikilinks natively; scan text nodes for [[...]] patterns
+                links.push(...extractWikilinksFromText(n.value));
+                break;
+            }
+            default: {
+                if ('children' in n) {
+                    for (const child of n.children) {
+                        walk(child);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    walk(node);
+    return links;
+}
+/**
+ * Extract all links from a raw markdown body string.
+ * Parses the full document and collects links from every node in the tree.
+ */
+export function extractLinksFromBody(body) {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(body);
+    return extractLinksFromAstNode(tree);
+}
+/**
+ * Build the set of field names that serve as graph edges (hierarchy + relationship fields).
+ * Used to exclude edge fields from frontmatter link extraction.
+ */
+export function getEdgeFieldNames(metadata) {
+    const fields = new Set();
+    for (const hierarchy of metadata.hierarchies ?? []) {
+        for (const level of hierarchy.levels) {
+            fields.add(level.field);
+            if (level.selfRefField)
+                fields.add(level.selfRefField);
+        }
+    }
+    for (const rel of metadata.relationships ?? []) {
+        fields.add(rel.field);
+    }
+    return fields;
+}
+/**
+ * Extract links from frontmatter data fields, excluding known graph edge fields.
+ * Parses each string value as markdown (via mdast) to keep link extraction consistent
+ * with body content parsing — handles wikilinks, markdown links, images, and bare URLs.
+ */
+export function extractLinksFromFrontmatter(data, edgeFields) {
+    const links = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (edgeFields.has(key))
+            continue;
+        if (typeof value === 'string') {
+            links.push(...extractLinksFromBody(value));
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                if (typeof item === 'string') {
+                    links.push(...extractLinksFromBody(item));
+                }
+            }
+        }
+    }
+    return links;
+}

package/dist/plugins/markdown/index.js

@@ -2,7 +2,7 @@ import { statSync } from 'node:fs';
 import { PLUGIN_PREFIX } from '../util';
 import { readSpaceDirectory, readSpaceOnAPage } from './read-space';
 import { renderBullets } from './render-bullets';
-import { renderMermaid } from './render-mermaid';
+import { renderMarkdownDirectory } from './render-directory';
 import { templateSync } from './template-sync';
 const TYPE_INFERENCE_CONFIG_SCHEMA = {
     type: 'object',
@@ -39,13 +39,13 @@ export const markdownPlugin = {
     render: {
         formats: [
             { name: 'bullets', description: 'Indented bullet list' },
-            { name: 'mermaid', description: 'Mermaid graph TD diagram' },
+            { name: 'directory', description: 'Markdown space directory with one file per node' },
         ],
-        render(_context, graph, { format }) {
+        render(context, graph, { format, data }) {
             if (format === 'bullets')
                 return renderBullets(graph);
-            if (format === 'mermaid')
-                return renderMermaid(graph);
+            if (format === 'directory')
+                return renderMarkdownDirectory(context, graph, { format, data });
             throw new Error(`Unknown markdown render format: "${format}"`);
         },
     },

package/dist/plugins/markdown/parse-embedded.d.ts

@@ -74,11 +74,17 @@ export interface ExtractEmbeddedOptions {
      * Example: { "record_type": "type" } renames `record_type` to `type` in extracted data.
      */
     fieldMap?: Record<string, string>;
+    /** File path of the containing document, for populating node.source. */
+    file?: string;
+    /** Line offset of the body within the source file (e.g. frontmatter lines). */
+    lineOffset?: number;
 }
 export interface ExtractEmbeddedResult {
     nodes: BaseNode[];
     preambleNodeCount: number;
     terminatedHeadings: string[];
+    preambleContent?: string;
+    preambleFields?: Record<string, unknown>;
 }
 /**
  * Extract space nodes from markdown body text.

package/dist/plugins/markdown/parse-embedded.js

@@ -3,6 +3,7 @@ import { toString as mdastToString } from 'mdast-util-to-string';
 import remarkGfm from 'remark-gfm';
 import remarkParse from 'remark-parse';
 import { unified } from 'unified';
+import { extractLinksFromAstNode } from './extract-content-links';
 import { applyFieldMap, coerceDates } from './util';
 /** Type values that identify a space_on_a_page container (not themselves space nodes). */
 export const ON_A_PAGE_TYPES = ['ost_on_a_page', 'space_on_a_page'];
@@ -144,9 +145,11 @@ function appendContent(node, text) {
     if (!text)
         return;
     const existing = node.schemaData.content;
-    node.schemaData.content = existing ? `${existing}\n${text}` : text;
+    const updated = existing ? `${existing}\n${text}` : text;
+    node.schemaData.content = updated;
+    node.content = updated;
 }
-function processListItem(item, parentRef, contentTarget, nodes, makeLabel, buildLinkTargets, typeAliases, fieldMap, pendingType, parentFieldAppend, activeNodeFieldAppend) {
+function processListItem(item, parentRef, contentTarget, nodes, makeLabel, buildLinkTargets, typeAliases, fieldMap, pendingType, parentFieldAppend, activeNodeFieldAppend, file, lineOffset) {
     const firstPara = item.children.find((c) => c.type === 'paragraph');
     if (!firstPara) {
         appendContent(contentTarget, `- ${mdastToString(item)}`);
@@ -184,6 +187,11 @@ function processListItem(item, parentRef, contentTarget, nodes, makeLabel, build
             schemaData.parent = parentRef;
         if (summary)
             schemaData.summary = summary;
+        const line = item.position?.start.line ? item.position.start.line + (lineOffset ?? 0) : undefined;
+        const column = item.position?.start.column;
+        const source = file
+            ? { file, ...(line !== undefined ? { line } : {}), ...(column !== undefined ? { column } : {}) }
+            : undefined;
         const linkTargets = buildLinkTargets(title);
         const newNode = {
             label: makeLabel(title),
@@ -191,6 +199,9 @@ function processListItem(item, parentRef, contentTarget, nodes, makeLabel, build
             schemaData,
             linkTargets,
             type,
+            ...(schemaData.content !== undefined ? { content: schemaData.content } : {}),
+            contentLinks: [],
+            ...(source ? { source } : {}),
         };
         nodes.push(newNode);
         if (parentFieldAppend) {
@@ -200,7 +211,7 @@ function processListItem(item, parentRef, contentTarget, nodes, makeLabel, build
         for (const child of item.children) {
             if (child.type === 'list') {
                 for (const subItem of child.children) {
-                    processListItem(subItem, nestedParentRef, newNode, nodes, makeLabel, buildLinkTargets, typeAliases, fieldMap, pendingType);
+                    processListItem(subItem, nestedParentRef, newNode, nodes, makeLabel, buildLinkTargets, typeAliases, fieldMap, pendingType, undefined, undefined, file, lineOffset);
                 }
             }
         }
@@ -230,6 +241,7 @@ export function extractEmbeddedNodes(body, options) {
         schemaData: { type: 'space_on_a_page' },
         linkTargets: [],
         type: 'space_on_a_page',
+        contentLinks: [],
     };
     const tree = unified().use(remarkParse).use(remarkGfm).parse(body);
     // In typed-page mode: stack starts with the page's own virtual entry (depth 0).
@@ -237,7 +249,7 @@ export function extractEmbeddedNodes(body, options) {
     const stack = !isOnAPageMode && pageTitle !== undefined
         ? [{ depth: 0, title: pageTitle, nodeType: pageType, refTarget: pageTitle }]
         : [];
-    let parseState = 'preamble';
+    let parseState = isOnAPageMode ? 'preamble' : 'active';
     let preambleNodeCount = 0;
     const terminatedHeadings = [];
     /**
@@ -464,6 +476,11 @@ export function extractEmbeddedNodes(body, options) {
             };
             if (parentRef)
                 schemaData.parent = parentRef;
+            const line = heading.position?.start.line ? heading.position.start.line + (options.lineOffset ?? 0) : undefined;
+            const column = heading.position?.start.column;
+            const source = options.file
+                ? { file: options.file, ...(line !== undefined ? { line } : {}), ...(column !== undefined ? { column } : {}) }
+                : undefined;
             const linkTargets = buildHeadingLinkTargets(rawText, title, anchor);
             const headingNode = {
                 label: makeLabel(title),
@@ -471,6 +488,9 @@ export function extractEmbeddedNodes(body, options) {
                 schemaData,
                 linkTargets,
                 type,
+                ...(schemaData.content !== undefined ? { content: schemaData.content } : {}),
+                contentLinks: [],
+                ...(source ? { source } : {}),
             };
             // Push to stack BEFORE resolving semantic parent — stack[-2] is the correct parent.
             const refTarget = linkTargets[0] ?? title;
@@ -513,13 +533,13 @@ export function extractEmbeddedNodes(body, options) {
                     ? { node: semanticParent.node, field: definition.field }
                     : undefined;
                 for (const item of list.children) {
-                    processListItem(item, isParentSide ? undefined : semanticParent.ref, grouping.headingNode, nodes, makeLabel, buildListItemLinkTargets, typeAliases, fieldMap, definition.type, parentFieldAppendArg, activeNodeFieldAppendArg);
+                    processListItem(item, isParentSide ? undefined : semanticParent.ref, grouping.headingNode, nodes, makeLabel, buildListItemLinkTargets, typeAliases, fieldMap, definition.type, parentFieldAppendArg, activeNodeFieldAppendArg, options.file, options.lineOffset);
                 }
                 grouping = null;
             }
             else {
                 for (const item of list.children) {
-                    processListItem(item, parentRef, activeNode, nodes, makeLabel, buildListItemLinkTargets, typeAliases, fieldMap);
+                    processListItem(item, parentRef, activeNode, nodes, makeLabel, buildListItemLinkTargets, typeAliases, fieldMap, undefined, undefined, undefined, options.file, options.lineOffset);
                 }
             }
         }
@@ -601,6 +621,15 @@ export function extractEmbeddedNodes(body, options) {
                                 schemaData[mappedColName] = cellContent;
                             }
                         }
+                        const line = row.position?.start.line ? row.position.start.line + (options.lineOffset ?? 0) : undefined;
+                        const column = row.position?.start.column;
+                        const source = options.file
+                            ? {
+                                file: options.file,
+                                ...(line !== undefined ? { line } : {}),
+                                ...(column !== undefined ? { column } : {}),
+                            }
+                            : undefined;
                         const linkTargets = buildListItemLinkTargets(title);
                         const rowNode = {
                             label: makeLabel(title),
@@ -608,6 +637,8 @@ export function extractEmbeddedNodes(body, options) {
                             schemaData,
                             linkTargets,
                             type: rowTypeStr,
+                            contentLinks: [],
+                            ...(source ? { source } : {}),
                         };
                         nodes.push(rowNode);
                         if (tableParentFieldAppend) {
@@ -640,6 +671,8 @@ export function extractEmbeddedNodes(body, options) {
                 Object.assign(activeNode.schemaData, allFields);
                 if (remainingText)
                     appendContent(activeNode, remainingText);
+                activeNode.contentLinks ??= [];
+                activeNode.contentLinks.push(...extractLinksFromAstNode(child));
             }
             else if (child.type === 'code' && child.lang?.trim() === 'yaml') {
                 const code = child;
@@ -656,8 +689,18 @@ export function extractEmbeddedNodes(body, options) {
             }
             else {
                 appendContent(activeNode, mdastToString(child));
+                activeNode.contentLinks ??= [];
+                activeNode.contentLinks.push(...extractLinksFromAstNode(child));
             }
         }
     }
-    return { nodes, preambleNodeCount, terminatedHeadings };
+    const preambleContent = rootNode.schemaData.content;
+    const { type: _rootType, content: _rootContent, ...preambleFields } = rootNode.schemaData;
+    return {
+        nodes,
+        preambleNodeCount,
+        terminatedHeadings,
+        preambleContent,
+        preambleFields: Object.keys(preambleFields).length > 0 ? preambleFields : undefined,
+    };
 }

package/dist/plugins/markdown/read-space.js

@@ -3,6 +3,7 @@ import { basename, join, resolve } from 'node:path';
 import fg from 'fast-glob';
 import matter from 'gray-matter';
 import { extractSchemaTypeNames } from '../../schema/schema';
+import { extractLinksFromBody, extractLinksFromFrontmatter, getEdgeFieldNames } from './extract-content-links';
 import { extractEmbeddedNodes, ON_A_PAGE_TYPES } from './parse-embedded';
 import { applyFieldMap, coerceDates, inferTypeFromPath } from './util';
 export function readSpaceOnAPage(context) {
@@ -20,10 +21,15 @@ export function readSpaceOnAPage(context) {
         throw new Error(`Schema at ${resolvedSchemaPath} must define "$metadata.hierarchy.levels" to read a space_on_a_page file.`);
     }
     const pageTitle = basename(filePath, '.md');
+    const fmMatch = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+    const lineOffset = fmMatch ? (fmMatch[0].match(/\n/g) || []).length : 0;
+    const fileName = basename(filePath);
     const { nodes, preambleNodeCount, terminatedHeadings } = extractEmbeddedNodes(body, {
         pageTitle,
         pageType: 'space_on_a_page',
         metadata,
+        file: fileName,
+        lineOffset,
     });
     const parseIssues = terminatedHeadings.map((heading) => ({
         file: heading,
@@ -42,6 +48,7 @@ export async function readSpaceDirectory(context, options) {
     const absoluteTemplateDir = templateDir ? resolve(templateDir) : undefined;
     const typeInferenceCfg = mdCfg.typeInference;
     const knownTypes = typeInferenceCfg?.mode !== 'off' ? extractSchemaTypeNames(context.schema, context.schemaRefRegistry) : undefined;
+    const edgeFields = getEdgeFieldNames(metadata);
     const files = await fg('**/*.md', { cwd: directory, followSymbolicLinks: true });
     const nodes = [];
     const parseIssues = [];
@@ -61,16 +68,27 @@ export async function readSpaceDirectory(context, options) {
             // Clear the cache after any parse error to avoid stale state.
             // See: https://github.com/jonschlinkert/gray-matter/issues/166
             matter.clearCache();
+            const yamlErr = err;
+            const line = yamlErr.mark ? yamlErr.mark.line + 1 : undefined;
+            const column = yamlErr.mark ? yamlErr.mark.column + 1 : undefined;
             parseIssues.push({
                 file,
                 severity: 'error',
                 type: 'parse',
                 message: err instanceof Error ? err.message : String(err),
+                ...(line !== undefined ? { line } : {}),
+                ...(column !== undefined ? { column } : {}),
             });
             continue;
         }
         if (!parsed.data || Object.keys(parsed.data).length === 0) {
-            parseIssues.push({ file, severity: 'warning', type: 'no-type', message: 'No front-matter or type specified' });
+            parseIssues.push({
+                file,
+                severity: 'warning',
+                type: 'no-type',
+                message: 'No front-matter or type specified',
+                line: 1,
+            });
             continue;
         }
         const data = coerceDates(applyFieldMap(parsed.data, fieldMap));
@@ -78,7 +96,7 @@ export async function readSpaceDirectory(context, options) {
             data.type = inferTypeFromPath(file, typeInferenceCfg, knownTypes, context.schema.metadata.typeAliases);
         }
         if (!data.type) {
-            parseIssues.push({ file, severity: 'warning', type: 'no-type' });
+            parseIssues.push({ file, severity: 'warning', type: 'no-type', line: 1 });
             continue;
         }
         if (ON_A_PAGE_TYPES.includes(data.type) && !options?.includeOnAPageFiles) {
@@ -87,20 +105,35 @@ export async function readSpaceDirectory(context, options) {
         const pageType = data.type;
         const fileBase = basename(file, '.md');
         const title = data.title ?? fileBase;
-        nodes.push({
+        const fmMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+        const lineOffset = fmMatch ? (fmMatch[0].match(/\n/g) || []).length : 0;
+        const pageNode = {
             label: file,
             title,
             schemaData: { title, ...data },
             linkTargets: [title, fileBase],
             type: pageType,
-        });
+            source: { file, line: 1 },
+            ...(data.content !== undefined ? { content: data.content } : {}),
+            contentLinks: [...extractLinksFromFrontmatter(data, edgeFields), ...extractLinksFromBody(parsed.content)],
+        };
         if (!ON_A_PAGE_TYPES.includes(pageType)) {
-            const { nodes: embedded, terminatedHeadings } = extractEmbeddedNodes(parsed.content, {
+            const { nodes: embedded, preambleContent, preambleFields, terminatedHeadings, } = extractEmbeddedNodes(parsed.content, {
                 pageTitle: fileBase,
                 pageType,
                 metadata,
                 fieldMap,
+                file,
+                lineOffset,
             });
+            if (preambleFields) {
+                Object.assign(pageNode.schemaData, preambleFields);
+            }
+            if (preambleContent) {
+                pageNode.schemaData.content = preambleContent;
+                pageNode.content = preambleContent;
+            }
+            nodes.push(pageNode);
             nodes.push(...embedded);
             for (const heading of terminatedHeadings) {
                 parseIssues.push({
@@ -111,6 +144,9 @@ export async function readSpaceDirectory(context, options) {
                 });
             }
         }
+        else {
+            nodes.push(pageNode);
+        }
     }
     return { nodes, parseIssues, diagnostics: { kind: 'directory' } };
 }

package/dist/plugins/markdown/render-directory.d.ts

@@ -0,0 +1,11 @@
+import type { SpaceGraph } from '../../space-graph';
+import type { PluginContext, RenderMultiFileOutput, RenderOptions } from '../util';
+/**
+ * Sanitize a node title into a valid filesystem filename.
+ * Strips Obsidian/OS forbidden characters: \ / : * ? " < > | # ^ [ ]
+ */
+export declare function sanitizeFilename(title: string): string;
+/**
+ * Render a space graph as a markdown directory with one file per node.
+ */
+export declare function renderMarkdownDirectory(context: PluginContext, graph: SpaceGraph, options: RenderOptions): RenderMultiFileOutput;

package/dist/plugins/markdown/render-directory.js

@@ -0,0 +1,130 @@
+import { posix } from 'node:path';
+import matter from 'gray-matter';
+import { getMarkdownConfig } from './index';
+import { coerceDates, invertFieldMap } from './util';
+/**
+ * Sanitize a node title into a valid filesystem filename.
+ * Strips Obsidian/OS forbidden characters: \ / : * ? " < > | # ^ [ ]
+ */
+export function sanitizeFilename(title) {
+    const sanitized = title
+        .replace(/[\\/:*?"<>|#^[\]]/g, '-')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^[-.]+/, '')
+        .replace(/[-.]+$/, '');
+    return sanitized || 'untitled';
+}
+const PREFERRED_FIELD_ORDER = ['type', 'title', 'status', 'summary', 'status_tweet'];
+const EDGE_FIELDS = new Set(['parent', 'dependsOn', 'flowsTo', 'anchors', 'pipelineOf']);
+/**
+ * Format frontmatter object with preferred key ordering for Obsidian notes.
+ */
+function sortFrontmatterKeys(data) {
+    const keys = Object.keys(data);
+    const preferred = [];
+    const edge = [];
+    const middle = [];
+    for (const k of PREFERRED_FIELD_ORDER) {
+        if (keys.includes(k))
+            preferred.push(k);
+    }
+    for (const k of keys) {
+        if (EDGE_FIELDS.has(k)) {
+            edge.push(k);
+        }
+        else if (!PREFERRED_FIELD_ORDER.includes(k)) {
+            middle.push(k);
+        }
+    }
+    const sorted = {};
+    for (const k of [...preferred, ...middle, ...edge]) {
+        sorted[k] = data[k];
+    }
+    return sorted;
+}
+/**
+ * Render a space graph as a markdown directory with one file per node.
+ */
+export function renderMarkdownDirectory(context, graph, options) {
+    const markdownConfig = getMarkdownConfig(context.space?.plugins);
+    const reverseFieldMap = markdownConfig.fieldMap ? invertFieldMap(markdownConfig.fieldMap) : {};
+    const foldersOption = options.data?.folders;
+    let useFolders = false;
+    if (foldersOption === 'type') {
+        useFolders = true;
+    }
+    else if (foldersOption === 'flat') {
+        useFolders = false;
+    }
+    else if (markdownConfig.typeInference?.folderMap) {
+        useFolders = true;
+    }
+    // Build type-to-folder mapping from typeInference.folderMap if available
+    const folderMap = markdownConfig.typeInference?.folderMap;
+    const typeToFolder = new Map();
+    if (folderMap) {
+        for (const [folderPath, mappedType] of Object.entries(folderMap)) {
+            const cleanFolder = folderPath.replace(/\\/g, '/').replace(/\/+$/, '');
+            typeToFolder.set(mappedType.toLowerCase(), cleanFolder);
+        }
+    }
+    const files = [];
+    const usedPaths = new Set();
+    for (const node of graph.nodes.values()) {
+        const baseName = sanitizeFilename(node.title);
+        let folder = '';
+        if (useFolders) {
+            const typeKey = (node.resolvedType || node.type || '').toLowerCase();
+            folder = typeToFolder.get(typeKey) ?? (node.resolvedType || node.type || 'other');
+        }
+        let candidateName = `${baseName}.md`;
+        let counter = 2;
+        let relPath = folder ? posix.join(folder, candidateName) : candidateName;
+        while (usedPaths.has(relPath)) {
+            candidateName = `${baseName}-${counter}.md`;
+            relPath = folder ? posix.join(folder, candidateName) : candidateName;
+            counter++;
+        }
+        usedPaths.add(relPath);
+        const finalBase = candidateName.slice(0, -3);
+        // Prepare frontmatter data from schemaData with reverse fieldMap
+        const rawData = node.schemaData ?? {};
+        const frontmatterData = {};
+        for (const [key, value] of Object.entries(rawData)) {
+            // Body content is not written to frontmatter
+            if (key === 'content')
+                continue;
+            // Omit title only if it matches the final filename base
+            if (key === 'title' && finalBase === node.title)
+                continue;
+            const fileKey = reverseFieldMap[key] ?? key;
+            frontmatterData[fileKey] = value;
+        }
+        // Preserve exact title if final filename differed or disambiguation occurred
+        if (finalBase !== node.title && !frontmatterData.title) {
+            const titleKey = reverseFieldMap.title ?? 'title';
+            frontmatterData[titleKey] = node.title;
+        }
+        // Ensure type is in frontmatter
+        const nodeType = node.type || node.resolvedType;
+        if (nodeType && !frontmatterData.type) {
+            const typeKey = reverseFieldMap.type ?? 'type';
+            frontmatterData[typeKey] = nodeType;
+        }
+        const coercedData = coerceDates(sortFrontmatterKeys(frontmatterData));
+        const body = (node.content ?? '').trim();
+        let fileContent;
+        if (Object.keys(coercedData).length > 0) {
+            fileContent = matter.stringify(body ? `\n${body}\n` : '', coercedData);
+        }
+        else {
+            fileContent = body ? `${body}\n` : '';
+        }
+        files.push({
+            path: relPath,
+            content: fileContent,
+        });
+    }
+    return { files };
+}

package/dist/plugins/mermaid/index.d.ts

@@ -0,0 +1,2 @@
+import type { StructuredContextPlugin } from '../util';
+export declare const mermaidPlugin: StructuredContextPlugin;

package/dist/plugins/mermaid/index.js

@@ -0,0 +1,14 @@
+import { PLUGIN_PREFIX } from '../util';
+import { renderMermaid } from './render-mermaid';
+export const mermaidPlugin = {
+    name: `${PLUGIN_PREFIX}mermaid`,
+    configSchema: { type: 'object', additionalProperties: false },
+    render: {
+        formats: [{ name: 'graph', description: 'Mermaid graph TD diagram' }],
+        render(_context, graph, { format }) {
+            if (format === 'graph')
+                return renderMermaid(graph);
+            throw new Error(`Unknown mermaid render format: "${format}"`);
+        },
+    },
+};

package/dist/plugins/{markdown → mermaid}/render-mermaid.js

@@ -1,3 +1,13 @@
+const LEVEL_PALETTE = [
+    { fill: '#ff9999', stroke: '#ff0000' },
+    { fill: '#99ccff', stroke: '#0066cc' },
+    { fill: '#99ff99', stroke: '#00cc00' },
+    { fill: '#ffcc99', stroke: '#cc9900' },
+    { fill: '#cc99ff', stroke: '#6600cc' },
+    { fill: '#ff99cc', stroke: '#cc0066' },
+    { fill: '#99ffff', stroke: '#009999' },
+    { fill: '#ffff99', stroke: '#cccc00' },
+];
 function escapeMermaidString(str) {
     return str.replace(/"/g, '"');
 }
@@ -6,19 +16,13 @@ function safeNodeId(id) {
 }
 export function renderMermaid(graph) {
     const { hierarchyRoots, orphans, hierarchyChildren: children, hierarchyTitles: hierarchyNodeSet } = graph;
+    const levels = graph.hierarchy?.levels ?? [];
     let mmd = 'graph TD\n';
-    mmd += '  classDef vision fill:#ff9999,stroke:#ff0000,stroke-width:2px\n';
-    mmd += '  classDef mission fill:#99ccff,stroke:#0066cc,stroke-width:2px\n';
-    mmd += '  classDef goal fill:#99ff99,stroke:#00cc00,stroke-width:2px\n';
-    mmd += '  classDef opportunity fill:#ffcc99,stroke:#cc9900,stroke-width:2px\n';
-    mmd += '  classDef solution fill:#cc99ff,stroke:#6600cc,stroke-width:2px\n';
-    mmd += '  classDef identified fill:#f0f0f0,stroke:#999999,stroke-dasharray: 5 5\n';
-    mmd += '  classDef wondering fill:#fff0cc,stroke:#cccc00,stroke-dasharray: 5 5\n';
-    mmd += '  classDef exploring fill:#ffcc99,stroke:#cc9900,stroke-dasharray: 5 5\n';
-    mmd += '  classDef active fill:#99ff99,stroke:#00cc00,stroke-width:2px\n';
-    mmd += '  classDef paused fill:#ffcc99,stroke:#cc9900,stroke-width:2px\n';
-    mmd += '  classDef completed fill:#ccccff,stroke:#6666cc,stroke-width:2px\n';
-    mmd += '  classDef archived fill:#e0e0e0,stroke:#999999,stroke-width:2px\n';
+    for (let i = 0; i < levels.length; i++) {
+        const level = levels[i];
+        const color = LEVEL_PALETTE[i % LEVEL_PALETTE.length];
+        mmd += `  classDef ${level.type} fill:${color.fill},stroke:${color.stroke},stroke-width:2px\n`;
+    }
     const addedNodes = new Set();
     function addNodeAndChildren(node) {
         const nodeId = node.title;
@@ -26,13 +30,11 @@ export function renderMermaid(graph) {
             return;
         addedNodes.add(nodeId);
         const type = node.resolvedType;
-        const status = node.schemaData.status;
         const priority = node.schemaData.priority;
         const label = priority ? `${nodeId} (${priority})` : nodeId;
-        const className = `${type}_${status}`;
         const safeId = safeNodeId(nodeId);
         const escapedLabel = escapeMermaidString(label);
-        mmd += `  ${safeId}["${escapedLabel}"]:::${className}\n`;
+        mmd += `  ${safeId}["${escapedLabel}"]:::${type}\n`;
         const nodeChildren = children.get(nodeId) ?? [];
         for (const child of nodeChildren) {
             const childTitle = child.title;

package/dist/{integrations → plugins}/miro/cache.d.ts

@@ -1,4 +1,4 @@
-import type { SpaceNode } from '../../types';
+import type { SpaceNode } from '../../api';
 export interface CachedNode {
     miroCardId: string;
     contentHash: string;