@andespindola/brainlink 0.1.0-alpha.0

package/dist/domain/graph-analysis.js

@@ -0,0 +1,48 @@
+export const getBrokenLinks = (graph) => {
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    return graph.edges
+        .filter((edge) => edge.target === null)
+        .map((edge) => {
+        const source = nodeById.get(edge.source);
+        return {
+            fromTitle: source?.title ?? edge.source,
+            fromPath: source?.path ?? '',
+            toTitle: edge.targetTitle
+        };
+    });
+};
+export const getOrphanNodes = (graph) => {
+    const linkedNodeIds = new Set(graph.edges.flatMap((edge) => (edge.target ? [edge.source, edge.target] : [edge.source])));
+    return graph.nodes
+        .filter((node) => !linkedNodeIds.has(node.id))
+        .map((node) => ({
+        title: node.title,
+        path: node.path,
+        tags: node.tags
+    }));
+};
+export const getVaultStats = (graph) => {
+    const brokenLinks = getBrokenLinks(graph);
+    const orphans = getOrphanNodes(graph);
+    const tags = Array.from(new Set(graph.nodes.flatMap((node) => node.tags))).sort((left, right) => left.localeCompare(right));
+    return {
+        documentCount: graph.nodes.length,
+        linkCount: graph.edges.length,
+        resolvedLinkCount: graph.edges.filter((edge) => edge.target !== null).length,
+        brokenLinkCount: brokenLinks.length,
+        orphanCount: orphans.length,
+        tagCount: tags.length,
+        tags
+    };
+};
+export const validateGraph = (graph) => {
+    const brokenLinks = getBrokenLinks(graph);
+    const orphans = getOrphanNodes(graph);
+    const stats = getVaultStats(graph);
+    return {
+        ok: brokenLinks.length === 0,
+        stats,
+        brokenLinks,
+        orphans
+    };
+};

package/dist/domain/graph-layout.js

@@ -0,0 +1,187 @@
+const groupLabels = {
+    '00-maps': 'maps',
+    '10-agent-memory': 'agent-memory',
+    '20-concepts': 'concepts',
+    '30-architecture': 'architecture',
+    '40-agents': 'agents',
+    '50-retrieval': 'retrieval',
+    '60-operations': 'operations',
+    '70-evaluation': 'evaluation',
+    '80-sessions': 'sessions',
+    '90-security': 'security',
+    root: 'root'
+};
+const segmentAngles = {
+    Brainlink: -1.58,
+    Architecture: -0.74,
+    Agents: -0.05,
+    Retrieval: 0.68,
+    Operations: 1.34,
+    Evaluation: 2.08,
+    Security: 2.82
+};
+const hashText = (value) => Array.from(value).reduce((hash, char) => ((hash << 5) - hash + char.charCodeAt(0)) | 0, 0);
+const jitter = (value, range) => {
+    const normalized = Math.abs(hashText(value) % 1000) / 1000;
+    return (normalized - 0.5) * range;
+};
+const pathSegments = (path) => path.split('/').filter(Boolean);
+const groupKey = (node) => {
+    const segments = pathSegments(node.path);
+    if (segments[0] === 'agents') {
+        return segments[2] ?? 'root';
+    }
+    return segments[0] ?? 'root';
+};
+const groupLabel = (key) => groupLabels[key] ?? key;
+const incrementDegree = (degrees, id) => new Map([...degrees, [id, (degrees.get(id) ?? 0) + 1]]);
+const countDegrees = (edges) => edges.reduce((degrees, edge) => (edge.target ? incrementDegree(incrementDegree(degrees, edge.source), edge.target) : incrementDegree(degrees, edge.source)), new Map());
+const uniqueIds = (ids) => Array.from(new Set(ids));
+const createAdjacency = (nodes, edges) => {
+    const nodeIds = new Set(nodes.map((node) => node.id));
+    const emptyAdjacency = new Map(nodes.map((node) => [node.id, []]));
+    return edges.reduce((adjacency, edge) => {
+        if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+            return adjacency;
+        }
+        return new Map([
+            ...adjacency,
+            [edge.source, uniqueIds([...(adjacency.get(edge.source) ?? []), edge.target])],
+            [edge.target, uniqueIds([...(adjacency.get(edge.target) ?? []), edge.source])]
+        ]);
+    }, emptyAdjacency);
+};
+const byTitle = (left, right) => left.title.localeCompare(right.title);
+const byDegreeThenTitle = (degrees) => (left, right) => {
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? byTitle(left, right) : degreeDelta;
+};
+const naturalSegmentSeed = (node) => groupKey(node) === '00-maps' || /\b(moc|map)\b/i.test(node.title);
+const segmentName = (node) => node.title.replace(/^MOC\s+/i, '').replace(/\s+Memory Map$/i, '').trim() || node.title;
+const collectComponent = (adjacency, startId, visited) => {
+    const queue = [startId];
+    const component = [];
+    visited.add(startId);
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        component.push(id);
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!visited.has(nextId)) {
+                visited.add(nextId);
+                queue.push(nextId);
+            }
+        });
+    }
+    return component;
+};
+const connectedComponents = (nodes, adjacency) => {
+    const visited = new Set();
+    return [...nodes].sort(byTitle).reduce((components, node) => (visited.has(node.id) ? components : [...components, collectComponent(adjacency, node.id, visited)]), []);
+};
+const selectSegmentSeeds = (nodes, edges, degrees) => {
+    const adjacency = createAdjacency(nodes, edges);
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    return connectedComponents(nodes, adjacency).flatMap((component) => {
+        const componentNodes = component.map((id) => nodeById.get(id)).filter((node) => Boolean(node));
+        const naturalSeeds = componentNodes.filter(naturalSegmentSeed).sort(byDegreeThenTitle(degrees));
+        return naturalSeeds.length > 0 ? naturalSeeds : componentNodes.sort(byDegreeThenTitle(degrees)).slice(0, 1);
+    });
+};
+const assignSegments = (nodes, edges, degrees) => {
+    const adjacency = createAdjacency(nodes, edges);
+    const seeds = selectSegmentSeeds(nodes, edges, degrees);
+    const assignments = new Map(seeds.map((seed) => [seed.id, segmentName(seed)]));
+    const queue = seeds.map((seed) => seed.id);
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        const segment = assignments.get(id);
+        if (!segment) {
+            continue;
+        }
+        ;
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!assignments.has(nextId)) {
+                assignments.set(nextId, segment);
+                queue.push(nextId);
+            }
+        });
+    }
+    return new Map(nodes.map((node) => [node.id, assignments.get(node.id) ?? groupLabel(groupKey(node))]));
+};
+const groupNodesBySegment = (nodes, segments) => nodes.reduce((groups, node) => {
+    const segment = segments.get(node.id) ?? groupLabel(groupKey(node));
+    return new Map([...groups, [segment, [...(groups.get(segment) ?? []), node]]]);
+}, new Map());
+const segmentAngle = (segment, index, count) => segmentAngles[segment] ?? (Math.PI * 2 * index) / Math.max(count, 1) - Math.PI / 2;
+const createSegmentNodes = (segments, degrees, segmentCount) => ([segment, nodes], segmentIndex) => {
+    const sortedNodes = [...nodes].sort(byDegreeThenTitle(degrees));
+    const angle = segmentAngle(segment, segmentIndex, segmentCount);
+    const baseRadius = segmentCount === 1 ? 0 : 340 + Math.min(sortedNodes.length, 22) * 10;
+    const centerX = Math.cos(angle) * baseRadius;
+    const centerY = Math.sin(angle) * (baseRadius * 0.78);
+    const petalSpread = 40 + Math.sqrt(sortedNodes.length) * 14;
+    return sortedNodes.map((node, index) => {
+        const localAngle = index * 2.399963 + jitter(node.title, 0.42);
+        const localRadius = Math.sqrt(index + 1) * petalSpread;
+        const hubPull = segmentCount === 1 ? 0 : Math.min(degrees.get(node.id) ?? 0, 12) * 12;
+        return {
+            ...node,
+            group: groupLabel(groupKey(node)),
+            segment: segments.get(node.id) ?? segment,
+            x: centerX + Math.cos(localAngle) * localRadius - Math.cos(angle) * hubPull + jitter(node.id, 24),
+            y: centerY + Math.sin(localAngle) * localRadius * 0.78 - Math.sin(angle) * hubPull + jitter(node.path, 24)
+        };
+    });
+};
+const distanceBetween = (left, right) => Math.hypot(right.x - left.x, right.y - left.y);
+const separatePair = (minDistance, left, right) => {
+    const dx = right.x - left.x;
+    const dy = right.y - left.y;
+    const distance = Math.max(Math.hypot(dx, dy), 0.001);
+    if (distance >= minDistance) {
+        return [left, right];
+    }
+    const push = (minDistance - distance) / 2;
+    const ux = dx / distance;
+    const uy = dy / distance;
+    return [
+        {
+            ...left,
+            x: left.x - ux * push,
+            y: left.y - uy * push
+        },
+        {
+            ...right,
+            x: right.x + ux * push,
+            y: right.y + uy * push
+        }
+    ];
+};
+const relaxCollisions = (nodes, minDistance = 132, rounds = 32) => {
+    const relaxRound = (currentNodes) => currentNodes.reduce((resolvedNodes, node) => {
+        const resolved = resolvedNodes.reduce((state, previousNode) => {
+            const [nextPrevious, nextCurrent] = separatePair(minDistance, previousNode, state.current);
+            return {
+                previous: [...state.previous, nextPrevious],
+                current: nextCurrent
+            };
+        }, {
+            previous: [],
+            current: node
+        });
+        return [...resolved.previous, resolved.current];
+    }, []);
+    return Array.from({ length: rounds }).reduce((currentNodes) => relaxRound(currentNodes), nodes);
+};
+export const createCauliflowerGraphLayout = (graph) => {
+    const degrees = countDegrees(graph.edges);
+    const segments = assignSegments(graph.nodes, graph.edges, degrees);
+    const segmentGroups = Array.from(groupNodesBySegment(graph.nodes, segments).entries())
+        .sort(([left], [right]) => left.localeCompare(right));
+    const nodes = relaxCollisions(segmentGroups.flatMap(createSegmentNodes(segments, degrees, segmentGroups.length)));
+    return {
+        nodes,
+        edges: graph.edges
+    };
+};
+export const getMinimumLayoutDistance = (nodes) => nodes.reduce((minimumDistance, leftNode, leftIndex) => nodes.slice(leftIndex + 1).reduce((innerMinimum, rightNode) => Math.min(innerMinimum, distanceBetween(leftNode, rightNode)), minimumDistance), Number.POSITIVE_INFINITY);

package/dist/domain/ids.js

@@ -0,0 +1,2 @@
+import { createHash } from 'node:crypto';
+export const createStableId = (input) => createHash('sha256').update(input).digest('hex').slice(0, 24);

package/dist/domain/markdown.js

@@ -0,0 +1,100 @@
+import { basename, relative } from 'node:path';
+import { resolveAgentIdFromPath, sanitizeAgentId } from './agents.js';
+import { createStableId } from './ids.js';
+import { estimateTokenCount } from './tokens.js';
+const frontmatterPattern = /^---\n([\s\S]*?)\n---\n?/;
+const wikiLinkPattern = /\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
+const tagPattern = /(^|\s)#([A-Za-z0-9][A-Za-z0-9_-]*)/g;
+const headingPattern = /^#\s+(.+)$/m;
+const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '');
+const unique = (values) => Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+const parseFrontmatter = (content) => {
+    const match = content.match(frontmatterPattern);
+    if (!match) {
+        return {};
+    }
+    return match[1]
+        .split('\n')
+        .map((line) => line.match(/^([^:#]+):\s*(.+)$/))
+        .filter((match) => Boolean(match))
+        .reduce((frontmatter, match) => ({
+        ...frontmatter,
+        [match[1].trim()]: match[2].trim().replace(/^["']|["']$/g, '')
+    }), {});
+};
+const stripFrontmatter = (content) => content.replace(frontmatterPattern, '');
+const stripFencedCodeBlocks = (content) => content.replace(/```[\s\S]*?```/g, '').replace(/~~~[\s\S]*?~~~/g, '');
+const extractTitle = (filePath, content, frontmatter) => {
+    if (frontmatter.title) {
+        return normalizeTitle(frontmatter.title);
+    }
+    const heading = content.match(headingPattern);
+    if (heading) {
+        return normalizeTitle(heading[1]);
+    }
+    return normalizeTitle(basename(filePath));
+};
+export const extractWikiLinks = (content) => unique(Array.from(stripFencedCodeBlocks(content).matchAll(wikiLinkPattern), (match) => normalizeTitle(match[1])));
+export const extractTags = (content) => unique(Array.from(stripFencedCodeBlocks(content).matchAll(tagPattern), (match) => match[2]));
+const normalizeChunkContent = (content) => content
+    .split('\n')
+    .map((line) => line.trim())
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+export const splitIntoChunks = (documentId, content, maxCharacters = 1200) => {
+    const paragraphs = normalizeChunkContent(stripFrontmatter(content))
+        .split(/\n{2,}/)
+        .filter(Boolean);
+    const chunks = paragraphs.reduce((state, paragraph) => {
+        const lastChunk = state.at(-1);
+        if (!lastChunk) {
+            return [paragraph];
+        }
+        const merged = `${lastChunk}\n\n${paragraph}`;
+        if (merged.length <= maxCharacters) {
+            return [...state.slice(0, -1), merged];
+        }
+        return [...state, paragraph];
+    }, []);
+    return chunks.map((chunk, ordinal) => ({
+        id: createStableId(`${documentId}:${ordinal}:${chunk}`),
+        documentId,
+        ordinal,
+        content: chunk,
+        tokenCount: estimateTokenCount(chunk),
+        embeddingProvider: 'none',
+        embedding: []
+    }));
+};
+export const parseMarkdownDocument = (input) => {
+    const relativePath = relative(input.vaultPath, input.absolutePath);
+    const frontmatter = parseFrontmatter(input.content);
+    const title = extractTitle(input.absolutePath, input.content, frontmatter);
+    const agentId = frontmatter.agent ? sanitizeAgentId(frontmatter.agent) : resolveAgentIdFromPath(relativePath);
+    return {
+        id: createStableId(relativePath),
+        agentId,
+        title,
+        path: relativePath,
+        content: input.content,
+        tags: extractTags(input.content),
+        links: extractWikiLinks(input.content),
+        frontmatter,
+        createdAt: input.createdAt.toISOString(),
+        updatedAt: input.updatedAt.toISOString()
+    };
+};
+export const createIndexedDocument = (document, titleToDocumentId, maxChunkCharacters = 1200) => {
+    const chunks = splitIntoChunks(document.id, document.content, maxChunkCharacters);
+    const links = document.links.map((toTitle) => ({
+        fromDocumentId: document.id,
+        toTitle,
+        toDocumentId: titleToDocumentId.get(toTitle.toLowerCase()) ?? null
+    }));
+    return {
+        document,
+        chunks,
+        links
+    };
+};

package/dist/domain/note-safety.js

@@ -0,0 +1,54 @@
+const maxTitleLength = 160;
+const maxContentLength = 200_000;
+const sensitivePatterns = [
+    {
+        label: 'private key',
+        pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/
+    },
+    {
+        label: 'OpenAI API key',
+        pattern: /\bsk-[A-Za-z0-9_-]{20,}\b/
+    },
+    {
+        label: 'GitHub token',
+        pattern: /\b(?:ghp|gho|ghs|ghr|github_pat)_[A-Za-z0-9_]{20,}\b/
+    },
+    {
+        label: 'AWS access key',
+        pattern: /\bAKIA[0-9A-Z]{16}\b/
+    },
+    {
+        label: 'Slack token',
+        pattern: /\bxox[abprs]-[A-Za-z0-9-]{20,}\b/
+    },
+    {
+        label: 'JWT',
+        pattern: /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/
+    },
+    {
+        label: 'secret assignment',
+        pattern: /\b(?:api[_-]?key|secret|password|private[_-]?key|access[_-]?token|auth[_-]?token)\s*[:=]\s*["']?[A-Za-z0-9_./+=-]{12,}/i
+    }
+];
+export const findSensitiveContent = (value) => sensitivePatterns
+    .filter(({ pattern }) => pattern.test(value))
+    .map(({ label }) => ({ label }));
+export const validateNoteInput = (input) => {
+    if (!input.title.trim()) {
+        throw new Error('Note title cannot be empty.');
+    }
+    if (!input.content.trim()) {
+        throw new Error('Note content cannot be empty.');
+    }
+    if (input.title.length > maxTitleLength) {
+        throw new Error(`Note title is too long. Maximum length is ${maxTitleLength} characters.`);
+    }
+    if (input.content.length > maxContentLength) {
+        throw new Error(`Note content is too large. Maximum length is ${maxContentLength} characters.`);
+    }
+    const findings = findSensitiveContent(`${input.title}\n${input.content}`);
+    if (findings.length > 0 && !input.allowSensitive) {
+        const labels = Array.from(new Set(findings.map((finding) => finding.label))).join(', ');
+        throw new Error(`Sensitive memory blocked (${labels}). Remove secrets or pass --allow-sensitive intentionally.`);
+    }
+};

package/dist/domain/tokens.js

@@ -0,0 +1 @@
+export const estimateTokenCount = (content) => Math.ceil(content.trim().split(/\s+/).filter(Boolean).join(' ').length / 4);

package/dist/domain/types.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/config.js

@@ -0,0 +1,60 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+export const defaultBrainlinkConfig = {
+    vault: '.',
+    host: '127.0.0.1',
+    port: 4321,
+    allowedVaults: [],
+    defaultSearchLimit: 10,
+    defaultContextTokens: 2000,
+    embeddingProvider: 'local',
+    defaultSearchMode: 'hybrid',
+    chunkSize: 1200
+};
+const configFilenames = ['brainlink.config.json', '.brainlink.json'];
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const embeddingProviders = new Set(['none', 'local']);
+const searchModes = new Set(['fts', 'semantic', 'hybrid']);
+const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embeddingProviders.has(value) ? value : defaultBrainlinkConfig.embeddingProvider;
+export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
+const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
+const readAllowedVaultsFromEnv = () => (process.env.BRAINLINK_ALLOWED_VAULTS ?? '')
+    .split(',')
+    .map((value) => value.trim())
+    .filter(Boolean);
+const readJsonConfig = async (path) => {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+};
+const sanitizeConfig = (value) => ({
+    ...defaultBrainlinkConfig,
+    ...value,
+    port: typeof value.port === 'number' && value.port > 0 ? value.port : defaultBrainlinkConfig.port,
+    defaultSearchLimit: typeof value.defaultSearchLimit === 'number' && value.defaultSearchLimit > 0
+        ? value.defaultSearchLimit
+        : defaultBrainlinkConfig.defaultSearchLimit,
+    defaultContextTokens: typeof value.defaultContextTokens === 'number' && value.defaultContextTokens > 0
+        ? value.defaultContextTokens
+        : defaultBrainlinkConfig.defaultContextTokens,
+    allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
+    chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
+    embeddingProvider: sanitizeEmbeddingProvider(value.embeddingProvider),
+    defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode)
+});
+export const loadBrainlinkConfig = async (cwd = process.cwd()) => {
+    const configs = await Promise.all(configFilenames.map((filename) => readJsonConfig(resolve(cwd, filename))));
+    const merged = configs.reduce((state, config) => ({
+        ...state,
+        ...config
+    }), {});
+    return sanitizeConfig(merged);
+};

package/dist/infrastructure/file-system-vault.js

@@ -0,0 +1,62 @@
+import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative, resolve } from 'node:path';
+const excludedDirectories = new Set(['.brainlink', '.git', 'node_modules', 'dist']);
+const directoryMode = 0o700;
+const fileMode = 0o600;
+const walkMarkdownFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const nested = await Promise.all(entries.map(async (entry) => {
+        const absolutePath = join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return excludedDirectories.has(entry.name) ? [] : walkMarkdownFiles(absolutePath);
+        }
+        return entry.isFile() && extname(entry.name).toLowerCase() === '.md' ? [absolutePath] : [];
+    }));
+    return nested.flat();
+};
+export const resolveVaultPath = (vaultPath) => resolve(process.cwd(), vaultPath);
+const isPathInside = (parent, child) => {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+};
+const secureDirectory = async (path) => {
+    await mkdir(path, { recursive: true, mode: directoryMode });
+    await chmod(path, directoryMode);
+};
+export const assertVaultAllowed = (vaultPath, allowedVaults) => {
+    const absoluteVaultPath = resolveVaultPath(vaultPath);
+    const allowed = allowedVaults.map(resolveVaultPath);
+    if (allowed.length > 0 && !allowed.some((allowedPath) => isPathInside(allowedPath, absoluteVaultPath))) {
+        throw new Error(`Vault path is not allowed: ${absoluteVaultPath}. Configure BRAINLINK_ALLOWED_VAULTS or allowedVaults.`);
+    }
+    return absoluteVaultPath;
+};
+export const ensureVault = async (vaultPath) => {
+    const absoluteVaultPath = resolveVaultPath(vaultPath);
+    await secureDirectory(join(absoluteVaultPath, '.brainlink'));
+    return absoluteVaultPath;
+};
+export const readMarkdownFiles = async (vaultPath) => {
+    const absoluteVaultPath = resolveVaultPath(vaultPath);
+    const paths = await walkMarkdownFiles(absoluteVaultPath);
+    return Promise.all(paths.map(async (absolutePath) => {
+        const [content, stats] = await Promise.all([readFile(absolutePath, 'utf8'), stat(absolutePath)]);
+        return {
+            absolutePath,
+            content,
+            createdAt: stats.birthtime,
+            updatedAt: stats.mtime
+        };
+    }));
+};
+export const writeMarkdownFile = async (vaultPath, filename, content) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const absolutePath = resolve(absoluteVaultPath, filename.endsWith('.md') ? filename : `${filename}.md`);
+    if (!isPathInside(absoluteVaultPath, absolutePath)) {
+        throw new Error(`Refusing to write outside vault: ${absolutePath}`);
+    }
+    await secureDirectory(dirname(absolutePath));
+    await writeFile(absolutePath, content, { encoding: 'utf8', mode: fileMode });
+    await chmod(absolutePath, fileMode);
+    return absolutePath;
+};

package/dist/infrastructure/sqlite/document-writer.js

@@ -0,0 +1,50 @@
+import { createEmbeddingBuckets } from '../../domain/embeddings.js';
+export const createIndexWriter = (database) => ({
+    reset: () => {
+        database.exec(`
+      DELETE FROM embedding_buckets;
+      DELETE FROM chunks_fts;
+      DELETE FROM links;
+      DELETE FROM chunks;
+      DELETE FROM documents;
+    `);
+    },
+    saveDocuments: (documents) => {
+        const insertDocument = database.prepare(`
+      INSERT INTO documents (id, agent_id, title, path, content, tags_json, frontmatter_json, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertChunk = database.prepare(`
+      INSERT INTO chunks (id, document_id, ordinal, content, token_count, embedding_provider, embedding_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertChunkFts = database.prepare(`
+      INSERT INTO chunks_fts (chunk_id, document_id, agent_id, title, content)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        const insertEmbeddingBucket = database.prepare(`
+      INSERT OR IGNORE INTO embedding_buckets (bucket, chunk_id)
+      VALUES (?, ?)
+    `);
+        const insertLink = database.prepare(`
+      INSERT INTO links (from_document_id, to_title, to_document_id)
+      VALUES (?, ?, ?)
+    `);
+        const transaction = database.transaction(() => {
+            documents.forEach(({ document, chunks, links }) => {
+                insertDocument.run(document.id, document.agentId, document.title, document.path, document.content, JSON.stringify(document.tags), JSON.stringify(document.frontmatter), document.createdAt, document.updatedAt);
+                chunks.forEach((chunk) => {
+                    insertChunk.run(chunk.id, chunk.documentId, chunk.ordinal, chunk.content, chunk.tokenCount, chunk.embeddingProvider, JSON.stringify(chunk.embedding));
+                    insertChunkFts.run(chunk.id, chunk.documentId, document.agentId, document.title, chunk.content);
+                    createEmbeddingBuckets(chunk.embedding).forEach((bucket) => insertEmbeddingBucket.run(bucket, chunk.id));
+                });
+            });
+            documents.forEach(({ links }) => {
+                links.forEach((link) => {
+                    insertLink.run(link.fromDocumentId, link.toTitle, link.toDocumentId);
+                });
+            });
+        });
+        transaction();
+    }
+});