@justyork/repo-mind 0.3.0

package/dist/ui/fs-operations.js

@@ -0,0 +1,304 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { getBacklinksForSlug } from '../index/link-index.js';
+import { inferTypeFromRelative, resolveDomain } from '../index/path-inference.js';
+import { slugFromRelativePath } from '../index/slug.js';
+import { buildLinkIndexForDocs } from '../tools/explore-graph.js';
+import { readPageTemplate } from './templates.js';
+import { isValidFsName, joinRelativePath, normalizeRelativePath, parentRelativePath, resolveRelativeMdPath, resolveUnderKnowledgeRoot, } from './safe-path.js';
+import { cascadeSlugDelete, cascadeSlugRename, toRelativePaths } from './link-cascade.js';
+function inferTypeFromParent(parentPath) {
+    return inferTypeFromRelative(`${parentPath}/page.md`);
+}
+export function createFolder(index, parentPath, name) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    if (!isValidFsName(name)) {
+        throw new Error(`invalid folder name: ${name}`);
+    }
+    const relativePath = joinRelativePath(parentPath, name);
+    const absolutePath = resolveUnderKnowledgeRoot(knowledgeRoot, relativePath);
+    if (!absolutePath) {
+        throw new Error('path escapes docs/');
+    }
+    if (fs.existsSync(absolutePath)) {
+        throw new Error(`already exists: ${relativePath}`);
+    }
+    fs.mkdirSync(absolutePath, { recursive: true });
+    return { relativePath: normalizeRelativePath(relativePath), absolutePath };
+}
+export function createPageFile(index, parentPath, name, options = {}) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    const baseName = name.endsWith('.md') ? name.slice(0, -3) : name;
+    if (!isValidFsName(baseName)) {
+        throw new Error(`invalid page name: ${name}`);
+    }
+    const relativePath = joinRelativePath(parentPath, `${baseName}.md`);
+    const absolutePath = resolveRelativeMdPath(knowledgeRoot, relativePath);
+    if (!absolutePath) {
+        throw new Error('path escapes docs/');
+    }
+    if (fs.existsSync(absolutePath)) {
+        throw new Error(`already exists: ${relativePath}`);
+    }
+    const relativeNorm = normalizeRelativePath(relativePath);
+    const type = inferTypeFromParent(parentPath);
+    const slug = slugFromRelativePath(relativeNorm);
+    const domain = resolveDomain(relativeNorm, undefined);
+    const pageTitle = options.title?.trim() || baseName.replace(/[-_]/g, ' ');
+    let body = `# ${pageTitle}\n\n`;
+    if (options.templateId) {
+        const template = readPageTemplate(options.templateId);
+        body = template.body || body;
+        if (!options.title?.trim() && template.title) {
+            options.title = template.title;
+        }
+    }
+    const resolvedTitle = options.title?.trim() || pageTitle;
+    const frontmatter = {
+        type,
+        slug,
+        status: 'draft',
+        domain,
+        title: resolvedTitle,
+        tags: [],
+        related: [],
+        updated: new Date().toISOString().slice(0, 10),
+    };
+    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+    fs.writeFileSync(absolutePath, matter.stringify(body, frontmatter), 'utf8');
+    index.refresh();
+    return {
+        relativePath: normalizeRelativePath(relativePath),
+        absolutePath,
+        slug,
+        type,
+    };
+}
+function readPageSlug(absolutePath) {
+    const raw = fs.readFileSync(absolutePath, 'utf8');
+    const parsed = matter(raw);
+    const slug = parsed.data.slug;
+    if (typeof slug === 'string' && slug.trim()) {
+        return slug.trim();
+    }
+    const relative = path.basename(absolutePath, '.md');
+    return slugFromRelativePath(`${relative}.md`);
+}
+function collectInboundWarnings(index, slug) {
+    const docs = index.refresh();
+    const snapshot = buildLinkIndexForDocs(index);
+    const docsBySlug = new Map(docs.map((doc) => [doc.slug, doc]));
+    return getBacklinksForSlug(snapshot, slug, docsBySlug).map((entry) => ({
+        slug: entry.slug,
+        title: entry.title,
+    }));
+}
+function rewritePageFrontmatter(absolutePath, newRelativePath) {
+    const raw = fs.readFileSync(absolutePath, 'utf8');
+    const parsed = matter(raw);
+    const parentPath = parentRelativePath(newRelativePath);
+    const newSlug = slugFromRelativePath(newRelativePath);
+    const newType = inferTypeFromParent(parentPath);
+    const nextData = {
+        ...parsed.data,
+        slug: newSlug,
+        type: newType,
+        updated: new Date().toISOString().slice(0, 10),
+    };
+    fs.writeFileSync(absolutePath, matter.stringify(parsed.content, nextData), 'utf8');
+    return { newSlug, newType };
+}
+export function movePageFile(index, fromPath, toDir) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    const normalizedFrom = normalizeRelativePath(fromPath);
+    const sourceAbsolute = resolveRelativeMdPath(knowledgeRoot, normalizedFrom);
+    if (!sourceAbsolute || !fs.existsSync(sourceAbsolute)) {
+        throw new Error(`page not found: ${fromPath}`);
+    }
+    const destDirRelative = normalizeRelativePath(toDir);
+    const destDirAbsolute = resolveUnderKnowledgeRoot(knowledgeRoot, destDirRelative);
+    if (!destDirAbsolute || !fs.existsSync(destDirAbsolute)) {
+        throw new Error(`destination folder not found: ${toDir}`);
+    }
+    if (!fs.statSync(destDirAbsolute).isDirectory()) {
+        throw new Error(`destination is not a folder: ${toDir}`);
+    }
+    const fileName = path.basename(sourceAbsolute);
+    const destRelative = joinRelativePath(destDirRelative, fileName);
+    const destAbsolute = resolveRelativeMdPath(knowledgeRoot, destRelative);
+    if (!destAbsolute) {
+        throw new Error('path escapes docs/');
+    }
+    if (fs.existsSync(destAbsolute)) {
+        throw new Error(`already exists: ${destRelative}`);
+    }
+    const previousSlug = readPageSlug(sourceAbsolute);
+    const inboundWarnings = collectInboundWarnings(index, previousSlug);
+    fs.mkdirSync(path.dirname(destAbsolute), { recursive: true });
+    fs.renameSync(sourceAbsolute, destAbsolute);
+    const { newSlug } = rewritePageFrontmatter(destAbsolute, destRelative);
+    let cascadeUpdated = [];
+    if (newSlug !== previousSlug) {
+        cascadeUpdated = toRelativePaths(knowledgeRoot, cascadeSlugRename(knowledgeRoot, previousSlug, newSlug, {
+            excludeAbsolutePath: destAbsolute,
+        }));
+    }
+    index.refresh();
+    return {
+        relativePath: normalizeRelativePath(destRelative),
+        absolutePath: destAbsolute,
+        slug: newSlug,
+        previousSlug,
+        slugChanged: newSlug !== previousSlug,
+        inboundWarnings: previousSlug !== newSlug ? inboundWarnings : [],
+        cascadeUpdated,
+    };
+}
+export function renamePageFile(index, pagePath, newName) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    const baseName = newName.endsWith('.md') ? newName.slice(0, -3) : newName;
+    if (!isValidFsName(baseName)) {
+        throw new Error(`invalid page name: ${newName}`);
+    }
+    const normalizedFrom = normalizeRelativePath(pagePath);
+    const sourceAbsolute = resolveRelativeMdPath(knowledgeRoot, normalizedFrom);
+    if (!sourceAbsolute || !fs.existsSync(sourceAbsolute)) {
+        throw new Error(`page not found: ${pagePath}`);
+    }
+    const parentPath = parentRelativePath(normalizedFrom);
+    const destRelative = joinRelativePath(parentPath, `${baseName}.md`);
+    const destAbsolute = resolveRelativeMdPath(knowledgeRoot, destRelative);
+    if (!destAbsolute) {
+        throw new Error('path escapes docs/');
+    }
+    if (destAbsolute === sourceAbsolute) {
+        throw new Error('new name matches current name');
+    }
+    if (fs.existsSync(destAbsolute)) {
+        throw new Error(`already exists: ${destRelative}`);
+    }
+    const previousSlug = readPageSlug(sourceAbsolute);
+    const inboundWarnings = collectInboundWarnings(index, previousSlug);
+    fs.renameSync(sourceAbsolute, destAbsolute);
+    const { newSlug } = rewritePageFrontmatter(destAbsolute, destRelative);
+    let cascadeUpdated = [];
+    if (newSlug !== previousSlug) {
+        cascadeUpdated = toRelativePaths(knowledgeRoot, cascadeSlugRename(knowledgeRoot, previousSlug, newSlug, {
+            excludeAbsolutePath: destAbsolute,
+        }));
+    }
+    index.refresh();
+    return {
+        relativePath: normalizeRelativePath(destRelative),
+        absolutePath: destAbsolute,
+        slug: newSlug,
+        previousSlug,
+        slugChanged: newSlug !== previousSlug,
+        inboundWarnings: previousSlug !== newSlug ? inboundWarnings : [],
+        cascadeUpdated,
+    };
+}
+function listMarkdownFilesRecursive(absoluteDir) {
+    const files = [];
+    if (!fs.existsSync(absoluteDir)) {
+        return files;
+    }
+    for (const entry of fs.readdirSync(absoluteDir, { withFileTypes: true })) {
+        if (entry.name === '.repo-mind' || entry.name === '.worktrees') {
+            continue;
+        }
+        const fullPath = path.join(absoluteDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...listMarkdownFilesRecursive(fullPath));
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function mergeInboundWarnings(lists) {
+    const seen = new Set();
+    const merged = [];
+    for (const list of lists) {
+        for (const item of list) {
+            if (seen.has(item.slug)) {
+                continue;
+            }
+            seen.add(item.slug);
+            merged.push(item);
+        }
+    }
+    return merged;
+}
+export function deletePageFile(index, pagePath) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    const normalized = normalizeRelativePath(pagePath);
+    const absolutePath = resolveRelativeMdPath(knowledgeRoot, normalized);
+    if (!absolutePath || !fs.existsSync(absolutePath)) {
+        throw new Error(`page not found: ${pagePath}`);
+    }
+    const slug = readPageSlug(absolutePath);
+    const inboundWarnings = collectInboundWarnings(index, slug);
+    const cascadeUpdated = toRelativePaths(knowledgeRoot, cascadeSlugDelete(knowledgeRoot, slug, { excludeAbsolutePaths: [absolutePath] }));
+    fs.unlinkSync(absolutePath);
+    index.refresh();
+    return {
+        relativePath: normalized,
+        slug,
+        inboundWarnings,
+        cascadeUpdated,
+    };
+}
+export function deleteFolder(index, folderPath) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        throw new Error('no docs/ directory found');
+    }
+    const normalized = normalizeRelativePath(folderPath);
+    if (!normalized) {
+        throw new Error('cannot delete docs root');
+    }
+    const absolutePath = resolveUnderKnowledgeRoot(knowledgeRoot, normalized);
+    if (!absolutePath || !fs.existsSync(absolutePath)) {
+        throw new Error(`folder not found: ${folderPath}`);
+    }
+    if (!fs.statSync(absolutePath).isDirectory()) {
+        throw new Error(`not a folder: ${folderPath}`);
+    }
+    const markdownFiles = listMarkdownFilesRecursive(absolutePath);
+    const deletedSlugs = markdownFiles.map((filePath) => readPageSlug(filePath));
+    const inboundWarnings = mergeInboundWarnings(deletedSlugs.map((slug) => collectInboundWarnings(index, slug)));
+    const cascadeUpdated = new Set();
+    for (const deletedSlug of deletedSlugs) {
+        for (const updatedPath of cascadeSlugDelete(knowledgeRoot, deletedSlug, {
+            excludeAbsolutePaths: markdownFiles,
+        })) {
+            cascadeUpdated.add(updatedPath);
+        }
+    }
+    fs.rmSync(absolutePath, { recursive: true, force: true });
+    index.refresh();
+    return {
+        relativePath: normalized,
+        deletedSlugs,
+        inboundWarnings,
+        cascadeUpdated: toRelativePaths(knowledgeRoot, [...cascadeUpdated]),
+    };
+}

package/dist/ui/fs-tree.d.ts

@@ -0,0 +1,28 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { LinkEdge } from '../index/link-index.js';
+export interface TreePageNode {
+    kind: 'page';
+    name: string;
+    relativePath: string;
+    slug: string;
+    title: string;
+    status: string;
+    type: string;
+    contentKind: 'markdown' | 'yaml' | 'json';
+}
+export interface TreeFolderNode {
+    kind: 'folder';
+    name: string;
+    relativePath: string;
+    emoji: string | null;
+    /** Slug of README.md index page for this folder. */
+    indexPageSlug: string | null;
+    children: TreeNode[];
+}
+export type TreeNode = TreePageNode | TreeFolderNode;
+export declare function readmeIndexRelativePath(folderRelativePath: string): string;
+/** Human label for domain folders at `docs/{domain}/`; otherwise basename. */
+export declare function folderDisplayName(relativePath: string): string;
+export declare function buildDocsTree(index: DocIndex): TreeFolderNode | null;
+export declare function findTreePageSlug(node: TreeFolderNode, relativePath: string): string | null;
+export declare function collectParentOfEdges(tree: TreeFolderNode | null): LinkEdge[];

package/dist/ui/fs-tree.js

@@ -0,0 +1,148 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isKnowledgeFileName } from '../index/knowledge-file.js';
+import { DOC_DOMAINS, DOMAIN_LABELS } from '../index/types.js';
+import { catalogEmoji, readCatalogMeta } from './catalog-meta.js';
+import { joinRelativePath, normalizeRelativePath } from './safe-path.js';
+const IGNORED_DIRS = new Set(['.repo-mind', '.worktrees']);
+function knowledgeFileDisplayName(fileName) {
+    return fileName.replace(/\.(md|ya?ml|json)$/i, '');
+}
+function listDirEntries(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return [];
+    }
+    return fs
+        .readdirSync(dirPath, { withFileTypes: true })
+        .filter((entry) => !entry.name.startsWith('.'))
+        .map((entry) => ({ name: entry.name, isDirectory: entry.isDirectory() }));
+}
+export function readmeIndexRelativePath(folderRelativePath) {
+    const base = normalizeRelativePath(folderRelativePath);
+    return base ? `${base}/README.md` : 'README.md';
+}
+function isDocDomain(name) {
+    return DOC_DOMAINS.includes(name);
+}
+/** Human label for domain folders at `docs/{domain}/`; otherwise basename. */
+export function folderDisplayName(relativePath) {
+    if (!relativePath) {
+        return 'Knowledge';
+    }
+    const segments = normalizeRelativePath(relativePath).split('/').filter(Boolean);
+    if (segments.length === 1 && isDocDomain(segments[0])) {
+        return DOMAIN_LABELS[segments[0]];
+    }
+    return path.basename(relativePath);
+}
+function buildFolder(relativePath, absPath, ctx) {
+    const entries = listDirEntries(absPath);
+    const children = [];
+    const readmeRel = readmeIndexRelativePath(relativePath);
+    let indexPageSlug = null;
+    const readmeDoc = ctx.docsByRelative.get(readmeRel);
+    if (readmeDoc) {
+        indexPageSlug = readmeDoc.slug;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.isDirectory) {
+            if (IGNORED_DIRS.has(entry.name)) {
+                continue;
+            }
+            const childRel = joinRelativePath(relativePath, entry.name);
+            children.push(buildFolder(childRel, path.join(absPath, entry.name), ctx));
+            continue;
+        }
+        if (!isKnowledgeFileName(entry.name)) {
+            continue;
+        }
+        const fileRel = joinRelativePath(relativePath, entry.name);
+        if (fileRel === readmeRel && indexPageSlug) {
+            continue;
+        }
+        const doc = ctx.docsByRelative.get(fileRel);
+        if (!doc) {
+            continue;
+        }
+        children.push({
+            kind: 'page',
+            name: knowledgeFileDisplayName(entry.name),
+            relativePath: fileRel,
+            slug: doc.slug,
+            title: doc.title,
+            status: doc.status,
+            type: doc.type,
+            contentKind: doc.contentKind,
+        });
+    }
+    return {
+        kind: 'folder',
+        name: folderDisplayName(relativePath),
+        relativePath,
+        emoji: catalogEmoji(ctx.meta, relativePath),
+        indexPageSlug,
+        children,
+    };
+}
+export function buildDocsTree(index) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return null;
+    }
+    const docsByRelative = new Map();
+    for (const doc of index.refresh()) {
+        docsByRelative.set(doc.relativePath, {
+            slug: doc.slug,
+            title: doc.title,
+            status: doc.status,
+            type: doc.type,
+            contentKind: doc.contentKind,
+        });
+    }
+    const ctx = {
+        docsByRelative,
+        meta: readCatalogMeta(knowledgeRoot),
+    };
+    return buildFolder('', knowledgeRoot, ctx);
+}
+export function findTreePageSlug(node, relativePath) {
+    const normalized = normalizeRelativePath(relativePath);
+    for (const child of node.children) {
+        if (child.kind === 'page' && child.relativePath === normalized) {
+            return child.slug;
+        }
+        if (child.kind === 'folder') {
+            const found = findTreePageSlug(child, normalized);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}
+export function collectParentOfEdges(tree) {
+    if (!tree) {
+        return [];
+    }
+    const edges = [];
+    function walk(folder) {
+        if (folder.indexPageSlug) {
+            for (const child of folder.children ?? []) {
+                if (child.kind === 'page' && child.slug !== folder.indexPageSlug) {
+                    edges.push({
+                        from: folder.indexPageSlug,
+                        to: child.slug,
+                        kind: 'parent_of',
+                    });
+                }
+            }
+        }
+        for (const child of folder.children ?? []) {
+            if (child.kind === 'folder') {
+                walk(child);
+            }
+        }
+    }
+    walk(tree);
+    return edges;
+}

package/dist/ui/graph-all.d.ts

@@ -0,0 +1,5 @@
+import type { DocIndex } from '../index/doc-index.js';
+import { type ExploreGraphResult } from '../tools/explore-graph.js';
+export declare const ALL_GRAPH_SLUG = "__all__";
+export declare const MAX_ALL_GRAPH_NODES = 200;
+export declare function exploreGraphAll(index: DocIndex): ExploreGraphResult;

package/dist/ui/graph-all.js

@@ -0,0 +1,50 @@
+import { buildLinkIndexForDocs } from '../tools/explore-graph.js';
+export const ALL_GRAPH_SLUG = '__all__';
+export const MAX_ALL_GRAPH_NODES = 200;
+function edgesForLimitedSlugs(linkIndex, limitedSlugs) {
+    const edgeKeys = new Set();
+    const edges = [];
+    for (const edge of linkIndex.edges) {
+        if (!limitedSlugs.has(edge.from) || !limitedSlugs.has(edge.to)) {
+            continue;
+        }
+        const key = `${edge.from}\0${edge.to}`;
+        if (edgeKeys.has(key)) {
+            continue;
+        }
+        edgeKeys.add(key);
+        edges.push({ from: edge.from, to: edge.to });
+    }
+    return edges;
+}
+export function exploreGraphAll(index) {
+    const empty = {
+        nodes: [],
+        edges: [],
+        maxDepthReached: 0,
+        truncated: false,
+        broken_links: [],
+    };
+    if (!index.getKnowledgeRoot()) {
+        return empty;
+    }
+    const docs = index.refresh();
+    const linkIndex = buildLinkIndexForDocs(index);
+    let truncated = false;
+    const limitedDocs = docs.length > MAX_ALL_GRAPH_NODES ? docs.slice(0, MAX_ALL_GRAPH_NODES) : docs;
+    if (docs.length > MAX_ALL_GRAPH_NODES) {
+        truncated = true;
+    }
+    const limitedSlugs = new Set(limitedDocs.map((doc) => doc.slug));
+    return {
+        nodes: limitedDocs.map((doc) => ({
+            slug: doc.slug,
+            type: doc.type,
+            title: doc.title,
+        })),
+        edges: edgesForLimitedSlugs(linkIndex, limitedSlugs),
+        maxDepthReached: 0,
+        truncated,
+        broken_links: [...linkIndex.brokenTargets],
+    };
+}

package/dist/ui/link-cascade.d.ts

@@ -0,0 +1,9 @@
+/** Rewrites inbound wikilinks and related frontmatter after a slug rename. */
+export declare function cascadeSlugRename(knowledgeRoot: string, fromSlug: string, toSlug: string, options?: {
+    excludeAbsolutePath?: string;
+}): string[];
+/** Removes inbound references to a deleted slug. */
+export declare function cascadeSlugDelete(knowledgeRoot: string, deletedSlug: string, options?: {
+    excludeAbsolutePaths?: string[];
+}): string[];
+export declare function toRelativePaths(knowledgeRoot: string, absolutePaths: string[]): string[];

package/dist/ui/link-cascade.js

@@ -0,0 +1,113 @@
+import fs from 'node:fs';
+import matter from 'gray-matter';
+import { listMarkdownFiles } from '../index/doc-index.js';
+const WIKILINK_PATTERN = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+function normalizeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === 'string');
+}
+function replaceWikilinksInBody(body, fromSlug, toSlug) {
+    return body.replace(WIKILINK_PATTERN, (full, display, slugPart) => {
+        const target = (slugPart ?? display).trim();
+        if (target !== fromSlug) {
+            return full;
+        }
+        const label = display.trim();
+        if (slugPart) {
+            return `[[${label}|${toSlug}]]`;
+        }
+        if (label === fromSlug) {
+            return `[[${toSlug}]]`;
+        }
+        return `[[${label}|${toSlug}]]`;
+    });
+}
+function removeWikilinksInBody(body, slug) {
+    return body.replace(WIKILINK_PATTERN, (full, display, slugPart) => {
+        const target = (slugPart ?? display).trim();
+        if (target !== slug) {
+            return full;
+        }
+        const label = display.trim();
+        return label || slug;
+    });
+}
+function replaceInRelated(related, fromSlug, toSlug) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of related) {
+        const next = entry === fromSlug ? toSlug : entry;
+        if (seen.has(next)) {
+            continue;
+        }
+        seen.add(next);
+        result.push(next);
+    }
+    return result;
+}
+function removeFromRelated(related, slug) {
+    return related.filter((entry) => entry !== slug);
+}
+function updateMarkdownFile(absolutePath, mutate) {
+    const raw = fs.readFileSync(absolutePath, 'utf8');
+    const parsed = matter(raw);
+    const data = parsed.data;
+    const related = normalizeStringArray(data.related);
+    const next = mutate(parsed.content, related);
+    const bodyChanged = next.body !== parsed.content;
+    const relatedChanged = next.related.length !== related.length || next.related.some((slug, index) => slug !== related[index]);
+    if (!bodyChanged && !relatedChanged) {
+        return false;
+    }
+    fs.writeFileSync(absolutePath, matter.stringify(next.body, {
+        ...data,
+        related: next.related,
+    }), 'utf8');
+    return true;
+}
+/** Rewrites inbound wikilinks and related frontmatter after a slug rename. */
+export function cascadeSlugRename(knowledgeRoot, fromSlug, toSlug, options = {}) {
+    if (fromSlug === toSlug) {
+        return [];
+    }
+    const updated = [];
+    for (const absolutePath of listMarkdownFiles(knowledgeRoot)) {
+        if (options.excludeAbsolutePath && absolutePath === options.excludeAbsolutePath) {
+            continue;
+        }
+        const changed = updateMarkdownFile(absolutePath, (body, related) => ({
+            body: replaceWikilinksInBody(body, fromSlug, toSlug),
+            related: replaceInRelated(related, fromSlug, toSlug),
+        }));
+        if (changed) {
+            updated.push(absolutePath);
+        }
+    }
+    return updated;
+}
+/** Removes inbound references to a deleted slug. */
+export function cascadeSlugDelete(knowledgeRoot, deletedSlug, options = {}) {
+    const excluded = new Set(options.excludeAbsolutePaths ?? []);
+    const updated = [];
+    for (const absolutePath of listMarkdownFiles(knowledgeRoot)) {
+        if (excluded.has(absolutePath)) {
+            continue;
+        }
+        const changed = updateMarkdownFile(absolutePath, (body, related) => ({
+            body: removeWikilinksInBody(body, deletedSlug),
+            related: removeFromRelated(related, deletedSlug),
+        }));
+        if (changed) {
+            updated.push(absolutePath);
+        }
+    }
+    return updated;
+}
+export function toRelativePaths(knowledgeRoot, absolutePaths) {
+    const rootWithSep = knowledgeRoot.endsWith('/') ? knowledgeRoot : `${knowledgeRoot}/`;
+    return absolutePaths.map((absolutePath) => absolutePath.startsWith(rootWithSep)
+        ? absolutePath.slice(rootWithSep.length).replace(/\\/g, '/')
+        : absolutePath);
+}

package/dist/ui/parse-multipart.d.ts

@@ -0,0 +1,12 @@
+export interface MultipartFilePart {
+    fieldName: string;
+    fileName: string;
+    mimeType: string;
+    data: Buffer;
+}
+export interface ParsedMultipart {
+    fields: Map<string, string>;
+    files: Map<string, MultipartFilePart>;
+}
+/** Minimal multipart/form-data parser for single-file uploads. */
+export declare function parseMultipartFormData(body: Buffer, contentType: string): ParsedMultipart;