@andespindola/brainlink 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/application/get-graph-layout.js

@@ -1,26 +1,41 @@
+import { createHash } from 'node:crypto';
+import { stat } from 'node:fs/promises';
 import { createCauliflowerGraphLayout } from '../domain/graph-layout.js';
-import { getGraph } from './get-graph.js';
+import { indexStoragePath } from '../infrastructure/file-index.js';
+import { getGraphSummary } from './get-graph-summary.js';
 const graphLayoutCache = new Map();
+const readDatabaseSignature = async (vaultPath) => {
+    try {
+        const info = await stat(indexStoragePath(vaultPath));
+        return `${Math.floor(info.mtimeMs)}:${info.size}`;
+    }
+    catch {
+        return '0:0';
+    }
+};
 const createGraphSignature = (graph) => {
     const nodesSignature = graph.nodes.map((node) => `${node.id}|${node.agentId}|${node.title}|${node.path}`).join('\n');
     const edgesSignature = graph.edges
         .map((edge) => `${edge.source}|${edge.target ?? ''}|${edge.targetTitle}|${edge.weight}|${edge.priority}`)
         .join('\n');
-    return `${graph.nodes.length}:${nodesSignature}|${graph.edges.length}:${edgesSignature}`;
+    return createHash('sha256')
+        .update(`${graph.nodes.length}:${nodesSignature}|${graph.edges.length}:${edgesSignature}`)
+        .digest('hex');
 };
 export const getGraphLayout = async (vaultPath, agentId) => {
-    const graph = await getGraph(vaultPath, agentId);
-    const signature = createGraphSignature(graph);
+    const databaseSignature = await readDatabaseSignature(vaultPath);
     const cacheKey = `${vaultPath}:${agentId ?? ''}`;
     const cached = graphLayoutCache.get(cacheKey);
-    if (cached?.signature === signature) {
+    if (cached?.databaseSignature === databaseSignature) {
         return {
-            signature,
+            signature: cached.signature,
             layout: cached.layout
         };
     }
+    const graph = await getGraphSummary(vaultPath, agentId);
+    const signature = createGraphSignature(graph);
     const layout = createCauliflowerGraphLayout(graph);
-    graphLayoutCache.set(cacheKey, { signature, layout });
+    graphLayoutCache.set(cacheKey, { databaseSignature, signature, layout });
     return {
         signature,
         layout

package/dist/application/get-graph-node.js

@@ -0,0 +1,12 @@
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
+export const getGraphNode = async (vaultPath, id, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const index = openFileIndex(absoluteVaultPath);
+    try {
+        return await index.getGraphNode(id, agentId);
+    }
+    finally {
+        index.close();
+    }
+};

package/dist/application/get-graph-summary.js

@@ -0,0 +1,12 @@
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
+export const getGraphSummary = async (vaultPath, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const index = openFileIndex(absoluteVaultPath);
+    try {
+        return await index.getGraphSummary(agentId);
+    }
+    finally {
+        index.close();
+    }
+};

package/dist/application/get-graph.js

@@ -1,10 +1,10 @@
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 export const getGraph = async (vaultPath, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.getGraph(agentId);
+        return await index.getGraph(agentId);
     }
     finally {
         index.close();

package/dist/application/index-vault.js

@@ -3,7 +3,8 @@ import { sharedAgentId } from '../domain/agents.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig } from '../infrastructure/config.js';
 import { ensureVault, readMarkdownFiles } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { buildSearchPacks } from '../infrastructure/search-packs.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 const toTitleKey = (title) => title.toLowerCase();
 const appendTitleEntry = (map, document) => {
     const key = toTitleKey(document.title);
@@ -59,10 +60,16 @@ export const indexVault = async (vaultPath) => {
     }));
     const titleMaps = createTitleMaps(documents);
     const indexedDocuments = await embedIndexedDocuments(documents.map((document) => createIndexedDocument(document, createScopedTitleResolver(document, titleMaps), config.chunkSize)), config.embeddingProvider);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        index.reset();
-        index.saveDocuments(indexedDocuments);
+        await index.reset();
+        await index.saveDocuments(indexedDocuments);
+        try {
+            await buildSearchPacks(absoluteVaultPath, indexedDocuments);
+        }
+        catch {
+            // Pack generation is best-effort. The JSON index remains the primary path.
+        }
         return {
             documentCount: indexedDocuments.length,
             chunkCount: indexedDocuments.reduce((total, document) => total + document.chunks.length, 0),

package/dist/application/list-agents.js

@@ -1,10 +1,10 @@
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 export const listAgents = async (vaultPath) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listAgents();
+        return await index.listAgents();
     }
     finally {
         index.close();

package/dist/application/list-links.js

@@ -1,10 +1,10 @@
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
 export const listLinks = async (vaultPath, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listLinks(agentId);
+        return await index.listLinks(agentId);
     }
     finally {
         index.close();
@@ -12,9 +12,9 @@ export const listLinks = async (vaultPath, agentId) => {
 };
 export const listBacklinks = async (vaultPath, title, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.listBacklinks(title, agentId);
+        return await index.listBacklinks(title, agentId);
     }
     finally {
         index.close();

package/dist/application/migrate-vault.js

@@ -0,0 +1,91 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, extname, isAbsolute, join, relative } from 'node:path';
+import { ensureVault, isBucketVaultPath, listVaultFiles, resolveVaultPath, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+const directoryMode = 0o700;
+const fileMode = 0o600;
+const isMarkdownPath = (path) => extname(path).toLowerCase() === '.md';
+const timestamp = () => new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, 'Z');
+const isPathInside = (parent, child) => {
+    const path = relative(parent, child);
+    return path === '' || (!path.startsWith('..') && !isAbsolute(path));
+};
+const conflictPath = (targetPath) => {
+    const extension = extname(targetPath);
+    const base = extension ? targetPath.slice(0, -extension.length) : targetPath;
+    return `${base}.conflict-${timestamp()}${extension}`;
+};
+const writePreservedFile = async (absolutePath, content) => {
+    await mkdir(dirname(absolutePath), { recursive: true, mode: directoryMode });
+    await writeFile(absolutePath, content, { mode: fileMode });
+    await chmod(absolutePath, fileMode);
+};
+const writeMigratedFile = async (targetVault, targetRoot, absolutePath, content) => {
+    if (isBucketVaultPath(targetVault)) {
+        await writeMarkdownFile(targetVault, relative(targetRoot, absolutePath), content.toString('utf8'));
+        return;
+    }
+    await writePreservedFile(absolutePath, content);
+};
+export const planVaultMigration = async (source, target) => {
+    const sourceFiles = (await listVaultFiles(source)).filter(isMarkdownPath);
+    return sourceFiles.reduce(async (statePromise, sourceFile) => {
+        const state = await statePromise;
+        const targetFile = join(target, relative(source, sourceFile));
+        if (!isPathInside(target, targetFile)) {
+            return state;
+        }
+        const sourceContent = await readFile(sourceFile);
+        try {
+            const targetContent = await readFile(targetFile);
+            if (sourceContent.equals(targetContent)) {
+                return [...state, { kind: 'unchanged', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+            }
+            return [...state, { kind: 'conflict', sourcePath: sourceFile, targetPath: conflictPath(targetFile), sourceContent }];
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !('code' in error) || error.code !== 'ENOENT') {
+                throw error;
+            }
+            return [...state, { kind: 'copy', sourcePath: sourceFile, targetPath: targetFile, sourceContent }];
+        }
+    }, Promise.resolve([]));
+};
+export const previewVaultMigration = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const migrateVaultContent = async (sourceVault, targetVault) => {
+    const source = await ensureVault(sourceVault);
+    const target = await ensureVault(targetVault);
+    if (source === target) {
+        return { source, target, copied: 0, unchanged: 0, conflicted: 0 };
+    }
+    const actions = await planVaultMigration(source, target);
+    for (const action of actions) {
+        if (action.kind === 'unchanged') {
+            continue;
+        }
+        await writeMigratedFile(targetVault, target, action.targetPath, action.sourceContent);
+    }
+    const copied = actions.filter((action) => action.kind === 'copy').length;
+    const unchanged = actions.filter((action) => action.kind === 'unchanged').length;
+    const conflicted = actions.filter((action) => action.kind === 'conflict').length;
+    return { source, target, copied, unchanged, conflicted };
+};
+export const shouldMigrateDefaultVault = async (sourceVault, targetVault) => {
+    const source = resolveVaultPath(sourceVault);
+    const target = resolveVaultPath(targetVault);
+    if (source === target) {
+        return false;
+    }
+    const [sourceFiles, targetFiles] = await Promise.all([listVaultFiles(source), listVaultFiles(target)]);
+    return sourceFiles.filter(isMarkdownPath).length > 0 && targetFiles.filter(isMarkdownPath).length === 0;
+};

package/dist/application/search-graph-node-ids.js

@@ -0,0 +1,12 @@
+import { ensureVault } from '../infrastructure/file-system-vault.js';
+import { openFileIndex } from '../infrastructure/file-index.js';
+export const searchGraphNodeIds = async (vaultPath, query, limit, agentId) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const index = openFileIndex(absoluteVaultPath);
+    try {
+        return await index.searchGraphNodeIds(query, limit, agentId);
+    }
+    finally {
+        index.close();
+    }
+};

package/dist/application/search-knowledge.js

@@ -1,19 +1,89 @@
+import { stat } from 'node:fs/promises';
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openSqliteIndex } from '../infrastructure/sqlite-index.js';
+import { ensurePrivatePacksFromLegacyIndex, searchInPacks } from '../infrastructure/search-packs.js';
+import { indexStoragePath, openFileIndex } from '../infrastructure/file-index.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig, sanitizeSearchMode } from '../infrastructure/config.js';
+const hybridCacheTtlMs = 30_000;
+const hybridCacheMaxEntries = 200;
+const hybridSearchCache = new Map();
+const readIndexMtimeMs = async (vaultPath) => {
+    try {
+        return (await stat(indexStoragePath(vaultPath))).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+};
+const toCacheKey = (vaultPath, query, limit, agentId) => JSON.stringify({
+    vaultPath,
+    query: query.trim().toLowerCase(),
+    limit,
+    agentId: agentId?.trim().toLowerCase() ?? '*'
+});
+const cacheGet = (key, indexMtimeMs) => {
+    const entry = hybridSearchCache.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    const fresh = Date.now() - entry.createdAt <= hybridCacheTtlMs && entry.indexMtimeMs === indexMtimeMs;
+    if (!fresh) {
+        hybridSearchCache.delete(key);
+        return undefined;
+    }
+    return entry.results;
+};
+const cacheSet = (entry) => {
+    hybridSearchCache.set(entry.key, entry);
+    if (hybridSearchCache.size <= hybridCacheMaxEntries) {
+        return;
+    }
+    const overflow = hybridSearchCache.size - hybridCacheMaxEntries;
+    const keys = Array.from(hybridSearchCache.keys()).slice(0, overflow);
+    keys.forEach((key) => hybridSearchCache.delete(key));
+};
 export const searchKnowledge = async (vaultPath, query, limit, agentId, mode) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
     const config = await loadBrainlinkConfig();
     const searchMode = sanitizeSearchMode(mode, config.defaultSearchMode);
+    await ensurePrivatePacksFromLegacyIndex(absoluteVaultPath);
+    const cacheKey = searchMode === 'hybrid' ? toCacheKey(absoluteVaultPath, query, limit, agentId) : undefined;
+    const indexMtimeMs = cacheKey ? await readIndexMtimeMs(absoluteVaultPath) : 0;
+    const cached = cacheKey ? cacheGet(cacheKey, indexMtimeMs) : undefined;
+    if (cached) {
+        return cached;
+    }
     const provider = createEmbeddingProvider(config.embeddingProvider);
     const shouldEmbedQuery = searchMode !== 'fts' && provider.name !== 'none';
     const queryEmbedding = shouldEmbedQuery ? (await provider.embed([query]))[0] ?? [] : [];
-    const index = openSqliteIndex(absoluteVaultPath);
     try {
-        return index.search(query, limit, agentId, searchMode, queryEmbedding);
+        const index = openFileIndex(absoluteVaultPath);
+        try {
+            const results = await index.search(query, limit, agentId, searchMode, queryEmbedding);
+            if (cacheKey) {
+                cacheSet({
+                    key: cacheKey,
+                    createdAt: Date.now(),
+                    indexMtimeMs,
+                    results
+                });
+            }
+            return results;
+        }
+        finally {
+            index.close();
+        }
     }
-    finally {
-        index.close();
+    catch {
+        const fallbackResults = await searchInPacks(absoluteVaultPath, query, limit, agentId);
+        if (cacheKey) {
+            cacheSet({
+                key: cacheKey,
+                createdAt: Date.now(),
+                indexMtimeMs,
+                results: fallbackResults
+            });
+        }
+        return fallbackResults;
     }
 };

package/dist/application/server/routes.js

@@ -1,9 +1,11 @@
 import { getBrokenLinksReport, getOrphansReport, getStats, validateVault } from '../analyze-vault.js';
 import { buildContextPackage } from '../build-context.js';
 import { getGraph } from '../get-graph.js';
+import { getGraphNode } from '../get-graph-node.js';
 import { getGraphLayout } from '../get-graph-layout.js';
 import { listAgents } from '../list-agents.js';
 import { listBacklinks, listLinks } from '../list-links.js';
+import { searchGraphNodeIds } from '../search-graph-node-ids.js';
 import { searchKnowledge } from '../search-knowledge.js';
 import { loadBrainlinkConfig, sanitizeSearchMode } from '../../infrastructure/config.js';
 import { createClientCss } from '../frontend/client-css.js';
@@ -49,6 +51,10 @@ const sameEntityTag = (candidate, signature) => {
     return decodeEntityTag(candidate) === signature;
 };
 const readAgentQuery = (url) => url.searchParams.get('agent') ?? undefined;
+const stripLayoutContent = (layout) => ({
+    ...layout,
+    nodes: layout.nodes.map(({ content, ...node }) => node)
+});
 export const route = async (request, url, vaultPath) => {
     if (isReadMethod(request) && (url.pathname === '/' || url.pathname === '/index.html')) {
         return createResponse(createClientHtml(), 200, contentTypes['.html']);
@@ -67,7 +73,7 @@ export const route = async (request, url, vaultPath) => {
         const requestEtags = request.headers['if-none-match'];
         const notModified = sameEntityTag(requestEtags, signature);
         const etag = encodeEntityTag(signature);
-        const body = createJsonResponse({ signature, layout });
+        const body = createJsonResponse({ signature, layout: stripLayoutContent(layout) });
         const jsonResponse = createResponse(body, 200, contentTypes['.json']);
         const notModifiedResponse = createResponse('', 304, contentTypes['.json']);
         if (notModified) {
@@ -87,6 +93,26 @@ export const route = async (request, url, vaultPath) => {
             }
         };
     }
+    if (isReadMethod(request) && url.pathname === '/api/graph-node') {
+        const id = url.searchParams.get('id')?.trim() ?? '';
+        if (!id) {
+            return createResponse(createJsonResponse({ error: 'Missing id query parameter' }), 400, contentTypes['.json']);
+        }
+        const node = await getGraphNode(vaultPath, id, readAgentQuery(url));
+        if (!node) {
+            return createResponse(createJsonResponse({ error: 'Node not found' }), 404, contentTypes['.json']);
+        }
+        return createResponse(createJsonResponse({ node }), 200, contentTypes['.json']);
+    }
+    if (isReadMethod(request) && url.pathname === '/api/graph-filter') {
+        const query = url.searchParams.get('q')?.trim() ?? '';
+        const limit = parsePositiveInteger(url.searchParams.get('limit'), 1200);
+        if (!query) {
+            return createResponse(createJsonResponse({ query, nodeIds: [] }), 200, contentTypes['.json']);
+        }
+        const nodeIds = await searchGraphNodeIds(vaultPath, query, limit, readAgentQuery(url));
+        return createResponse(createJsonResponse({ query, nodeIds }), 200, contentTypes['.json']);
+    }
     if (isReadMethod(request) && url.pathname === '/api/agents') {
         return createResponse(createJsonResponse({ agents: await listAgents(vaultPath) }), 200, contentTypes['.json']);
     }

package/dist/benchmarks/large-vault.js

@@ -21,7 +21,7 @@ const readOptions = (args) => ({
 });
 const topics = [
     'authentication jwt token refresh policy',
-    'sqlite graph backlinks markdown vault indexing',
+    'graph backlinks markdown vault indexing',
     'frontend canvas layout graph interaction',
     'agent memory context retrieval summarization',
     'security local server vault path allowlist',