@andespindola/brainlink 0.1.0-beta.99 → 1.0.0

package/dist/application/graph-view-state.js

@@ -0,0 +1,66 @@
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+const stateVersion = 1;
+const graphViewStatePath = (vaultPath) => join(vaultPath, '.brainlink', 'graph-view-state.json');
+const stateKey = (input) => [input.signature, input.agentId ?? 'all-agents', input.context ?? 'all-contexts'].join(':');
+const emptyPersistedState = () => ({
+    version: stateVersion,
+    states: {}
+});
+const readPersistedState = async (vaultPath) => {
+    try {
+        const parsed = JSON.parse(await readFile(graphViewStatePath(vaultPath), 'utf8'));
+        return parsed.version === stateVersion && parsed.states && typeof parsed.states === 'object' ? parsed : emptyPersistedState();
+    }
+    catch {
+        return emptyPersistedState();
+    }
+};
+const writePersistedState = async (vaultPath, state) => {
+    const target = graphViewStatePath(vaultPath);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(state)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
+const normalizePositions = (positions) => positions.flatMap((position) => {
+    const id = typeof position.id === 'string' ? position.id.trim() : '';
+    const x = Number(position.x);
+    const y = Number(position.y);
+    return id && Number.isFinite(x) && Number.isFinite(y) ? [{ id, x, y }] : [];
+});
+export const getGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const state = persisted.states[stateKey(input)];
+    return state ?? {
+        ...input,
+        positions: []
+    };
+};
+export const saveGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const nextState = {
+        ...input,
+        positions: normalizePositions(input.positions)
+    };
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states: {
+            ...persisted.states,
+            [stateKey(input)]: nextState
+        }
+    });
+    return nextState;
+};
+export const deleteGraphViewState = async (vaultPath, input) => {
+    const persisted = await readPersistedState(vaultPath);
+    const { [stateKey(input)]: _removed, ...states } = persisted.states;
+    await writePersistedState(vaultPath, {
+        version: stateVersion,
+        states
+    });
+    return {
+        ...input,
+        positions: []
+    };
+};

package/dist/application/import-legacy-sqlite.js

@@ -3,7 +3,7 @@ import { access } from 'node:fs/promises';
 import { basename, extname, join, relative, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
-import { extractTags, extractWikiLinks } from '../domain/markdown.js';
+import { extractTags } from '../domain/markdown.js';
 import { sanitizeAgentId, sharedAgentId } from '../domain/agents.js';
 import { ensureVault, listVaultFiles, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
 import { getBrainlinkHomePath } from '../infrastructure/paths.js';
@@ -17,9 +17,6 @@ const agentColumnCandidates = ['agent', 'agent_id', 'namespace', 'scope'];
 const tagColumnCandidates = ['tags', 'tag_list', 'keywords'];
 const createdColumnCandidates = ['created_at', 'createdat', 'created', 'ctime'];
 const updatedColumnCandidates = ['updated_at', 'updatedat', 'updated', 'mtime'];
-const systemHubTitle = 'Memory Hub';
-const systemRootTitle = 'Knowledge Root';
-const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '').toLowerCase();
 const slugify = (title) => title
     .normalize('NFKD')
     .replace(/[\u0300-\u036f]/g, '')
@@ -203,31 +200,6 @@ const reserveUniquePath = (agentId, title, reserved) => {
     }
     throw new Error(`Could not allocate unique path for imported note: ${title}`);
 };
-const ensureSystemNote = async (vaultPath, reserved, created, agentId, title, content, dryRun) => {
-    const filename = noteRelativePath(agentId, slugify(title));
-    if (reserved.has(filename)) {
-        return;
-    }
-    reserved.add(filename);
-    created.add(filename);
-    if (dryRun) {
-        return;
-    }
-    await writeMarkdownFile(vaultPath, filename, buildNote(title, content, agentId));
-};
-const applyConnectivityRule = async (vaultPath, reserved, created, title, content, agentId, dryRun) => {
-    const links = extractWikiLinks(content).filter((link) => normalizeTitle(link) !== normalizeTitle(title));
-    if (links.length > 0) {
-        return content.trim();
-    }
-    const normalized = normalizeTitle(title);
-    if (normalized === normalizeTitle(systemHubTitle)) {
-        await ensureSystemNote(vaultPath, reserved, created, agentId, systemRootTitle, `Entry point for agent memory. [[${systemHubTitle}]] #memory #root`, dryRun);
-        return `${content.trim()}\n\nRelated: [[${systemRootTitle}]]`;
-    }
-    await ensureSystemNote(vaultPath, reserved, created, agentId, systemHubTitle, 'Central memory index for this agent namespace. #memory #hub', dryRun);
-    return `${content.trim()}\n\nRelated: [[${systemHubTitle}]]`;
-};
 const importRowsFromMapping = async (vaultPath, dbPath, mapping, options, reserved) => {
     const limit = Number.isFinite(options.limit) && (options.limit ?? 0) > 0 ? Math.floor(options.limit ?? 0) : undefined;
     const sql = [
@@ -243,7 +215,6 @@ const importRowsFromMapping = async (vaultPath, dbPath, mapping, options, reserv
         ...(limit ? [`LIMIT ${limit}`] : [])
     ].join(' ');
     const rows = await runSqliteQuery(dbPath, sql);
-    const createdSystemNotes = new Set();
     const importedFiles = [];
     let imported = 0;
     let skipped = 0;
@@ -256,8 +227,7 @@ const importRowsFromMapping = async (vaultPath, dbPath, mapping, options, reserv
         const agentId = sanitizeAgentId(options.agentOverride || row.agent || sharedAgentId);
         const filename = reserveUniquePath(agentId, row.title, reserved);
         const mergedContent = appendMissingTags(row.content, row.tags);
-        const connectedContent = await applyConnectivityRule(vaultPath, reserved, createdSystemNotes, row.title, mergedContent, agentId, options.dryRun === true);
-        const note = buildNote(row.title, connectedContent, agentId);
+        const note = buildNote(row.title, mergedContent.trim(), agentId);
         if (options.dryRun !== true) {
             await writeMarkdownFile(vaultPath, filename, note);
         }
@@ -268,7 +238,7 @@ const importRowsFromMapping = async (vaultPath, dbPath, mapping, options, reserv
         rowsRead: rows.length,
         imported,
         skipped,
-        createdSystemNotes: createdSystemNotes.size,
+        createdSystemNotes: 0,
         importedFiles
     };
 };

package/dist/application/index-vault.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { createIndexedDocument, parseMarkdownDocument } from '../domain/markdown.js';
+import { createIndexedDocument, graphLinkModelVersion, parseMarkdownDocument } from '../domain/markdown.js';
 import { sharedAgentId } from '../domain/agents.js';
 import { createEmbeddingProvider } from '../domain/embeddings.js';
 import { loadBrainlinkConfig } from '../infrastructure/config.js';
@@ -85,8 +85,8 @@ const readChangedDocuments = async (absoluteVaultPath, changedSummaries) => {
     })));
     return new Map(parsed.map((document) => [document.path, document]));
 };
-export const indexVault = async (vaultPath) => {
-    return indexVaultWithOptions(vaultPath, {});
+export const indexVault = async (vaultPath, options = {}) => {
+    return indexVaultWithOptions(vaultPath, options);
 };
 export const indexVaultWithOptions = async (vaultPath, options) => {
     const startedAt = process.hrtime.bigint();
@@ -113,6 +113,7 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         markdownFiles: summaries.length,
         hasPreviousState: previousState != null
     });
+    const fullReindex = options.full === true;
     const index = openFileIndex(absoluteVaultPath);
     try {
         const existingIndexedDocuments = await index.getIndexedDocuments();
@@ -120,9 +121,13 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         const currentSnapshot = toSnapshot(summaries);
         const currentSnapshotMap = createSnapshotMap(currentSnapshot);
         const previousSnapshotMap = createSnapshotMap(previousState?.files ?? []);
+        const graphLinkModelChanged = previousState != null &&
+            previousState.graphLinkModelVersion !== graphLinkModelVersion;
+        const fullSourceReindex = fullReindex || graphLinkModelChanged;
         const settingsChanged = previousState == null ||
             previousState.chunkSize !== config.chunkSize ||
-            previousState.embeddingProvider !== config.embeddingProvider;
+            previousState.embeddingProvider !== config.embeddingProvider ||
+            graphLinkModelChanged;
         const packSettingsChanged = previousState == null ||
             previousState.searchPackRowChunkSize !== config.searchPack.rowChunkSize ||
             previousState.searchPackCompressionLevel !== config.searchPack.compressionLevel ||
@@ -131,7 +136,8 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         for (let index = 0; index < summaries.length; index += 1) {
             const summary = summaries[index];
             const previous = previousSnapshotMap.get(summary.relativePath);
-            const changed = settingsChanged ||
+            const changed = fullSourceReindex ||
+                settingsChanged ||
                 previous == null ||
                 previous.mtimeMs !== summary.updatedAt.getTime() ||
                 previous.size !== summary.size ||
@@ -147,7 +153,8 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         if (changedPaths.size === 0 &&
             !hasDeletes &&
             existingIndexedDocuments.length === summaries.length &&
-            previousState != null) {
+            previousState != null &&
+            !fullReindex) {
             const result = {
                 ...toIndexResult(existingIndexedDocuments),
                 elapsedMs: elapsedMs(),
@@ -204,7 +211,6 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
             return needsRelink ? relinkIndexedDocument(existing, titleMaps) : existing;
         });
         emit('persist', 'start', 'Persisting index');
-        await index.reset();
         await index.saveDocuments(indexedDocuments);
         emit('persist', 'finish', 'Index persisted', {
             indexedDocuments: indexedDocuments.length
@@ -216,6 +222,8 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         const previousPendingPackChanges = previousState?.pendingPackChanges ?? 0;
         const pendingPackChanges = previousPendingPackChanges + changedCount;
         const shouldRebuildPacks = !existingPackManifest ||
+            fullReindex ||
+            graphLinkModelChanged ||
             settingsChanged ||
             packSettingsChanged ||
             hasDeletes ||
@@ -225,21 +233,25 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         let packResult;
         const packReason = !existingPackManifest
             ? 'Missing pack manifest'
-            : manifestRecovery.repaired
-                ? 'Pack manifest repaired from existing packs'
-                : settingsChanged
-                    ? 'Index settings changed'
-                    : packSettingsChanged
-                        ? 'Search pack settings changed'
-                        : hasDeletes
-                            ? 'Document deletions detected'
-                            : changedCount >= 400
-                                ? 'Changed file count threshold reached'
-                                : changeRatio >= 0.04
-                                    ? 'Change ratio threshold reached'
-                                    : pendingPackChanges >= 1200
-                                        ? 'Pending pack changes threshold reached'
-                                        : 'Pack rebuild skipped';
+            : fullReindex
+                ? 'Full reindex requested'
+                : graphLinkModelChanged
+                    ? 'Graph link model changed'
+                    : manifestRecovery.repaired
+                        ? 'Pack manifest repaired from existing packs'
+                        : settingsChanged
+                            ? 'Index settings changed'
+                            : packSettingsChanged
+                                ? 'Search pack settings changed'
+                                : hasDeletes
+                                    ? 'Document deletions detected'
+                                    : changedCount >= 400
+                                        ? 'Changed file count threshold reached'
+                                        : changeRatio >= 0.04
+                                            ? 'Change ratio threshold reached'
+                                            : pendingPackChanges >= 1200
+                                                ? 'Pending pack changes threshold reached'
+                                                : 'Pack rebuild skipped';
         if (shouldRebuildPacks) {
             emit('packs', 'start', 'Rebuilding compressed search packs', {
                 reason: packReason
@@ -271,6 +283,7 @@ export const indexVaultWithOptions = async (vaultPath, options) => {
         await writeIndexState(absoluteVaultPath, {
             chunkSize: config.chunkSize,
             embeddingProvider: config.embeddingProvider,
+            graphLinkModelVersion,
             searchPackRowChunkSize: config.searchPack.rowChunkSize,
             searchPackCompressionLevel: config.searchPack.compressionLevel,
             searchPackUseDictionary: config.searchPack.useDictionary,

package/dist/application/migrate-context-links.js

@@ -0,0 +1,79 @@
+import { readFile } from 'node:fs/promises';
+import { ensureVault, readMarkdownFileSummaries, writeMarkdownFile } from '../infrastructure/file-system-vault.js';
+import { extractContextLinkWeights, extractWikiLinkWeights, hasContextLinksSection, parseMarkdownDocument } from '../domain/markdown.js';
+const defaultContextLinkLimit = 5;
+const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '').toLowerCase();
+const formatPriority = (priority) => priority === 'normal' ? '' : ` priority: ${priority}`;
+const formatContextLinksSection = (links) => [
+    '## Context Links',
+    '',
+    ...links.map((link) => `- [[${link.title}]]${formatPriority(link.priority)}`)
+].join('\n');
+const appendContextLinksSection = (content, links) => `${content.trimEnd()}\n\n${formatContextLinksSection(links)}\n`;
+const selectContextLinkCandidates = (content, title, limit) => extractWikiLinkWeights(content)
+    .filter((link) => normalizeTitle(link.title) !== normalizeTitle(title))
+    .slice(0, limit)
+    .map((link) => ({
+    title: link.title,
+    priority: link.priority,
+    weight: link.weight
+}));
+export const migrateContextLinks = async (vaultPath, options = {}) => {
+    const absoluteVaultPath = await ensureVault(vaultPath);
+    const limit = Math.max(1, Math.floor(options.limit ?? defaultContextLinkLimit));
+    const summaries = await readMarkdownFileSummaries(absoluteVaultPath);
+    const entries = [];
+    for (const summary of summaries) {
+        const content = await readFile(summary.absolutePath, 'utf8');
+        const document = parseMarkdownDocument({
+            absolutePath: summary.absolutePath,
+            vaultPath: absoluteVaultPath,
+            content,
+            createdAt: summary.createdAt,
+            updatedAt: summary.updatedAt
+        });
+        if (options.agentId && document.agentId !== options.agentId) {
+            continue;
+        }
+        if (hasContextLinksSection(content)) {
+            entries.push({
+                path: summary.relativePath,
+                title: document.title,
+                changed: false,
+                reason: 'already-has-context-links',
+                links: extractContextLinkWeights(content)
+            });
+            continue;
+        }
+        const links = selectContextLinkCandidates(content, document.title, limit);
+        if (links.length === 0) {
+            entries.push({
+                path: summary.relativePath,
+                title: document.title,
+                changed: false,
+                reason: 'no-link-candidates',
+                links
+            });
+            continue;
+        }
+        if (!options.dryRun) {
+            await writeMarkdownFile(vaultPath, summary.relativePath, appendContextLinksSection(content, links));
+        }
+        entries.push({
+            path: summary.relativePath,
+            title: document.title,
+            changed: true,
+            reason: 'added-context-links',
+            links
+        });
+    }
+    const changed = entries.filter((entry) => entry.changed).length;
+    return {
+        dryRun: options.dryRun === true,
+        scanned: entries.length,
+        changed,
+        skipped: entries.length - changed,
+        limit,
+        entries
+    };
+};

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

@@ -1,10 +1,70 @@
+import { stat } from 'node:fs/promises';
 import { ensureVault } from '../infrastructure/file-system-vault.js';
-import { openFileIndex } from '../infrastructure/file-index.js';
-export const searchGraphNodeIds = async (vaultPath, query, limit, agentId) => {
+import { indexStoragePath, openFileIndex } from '../infrastructure/file-index.js';
+import { getGraphLayout } from './get-graph-layout.js';
+const graphSearchCacheTtlMs = 20_000;
+const graphSearchCacheMaxEntries = 120;
+const graphSearchCache = new Map();
+const readIndexSignature = async (vaultPath) => {
+    try {
+        const info = await stat(indexStoragePath(vaultPath));
+        return `${Math.floor(info.mtimeMs)}:${info.size}`;
+    }
+    catch {
+        return '0:0';
+    }
+};
+const cacheKey = (vaultPath, query, limit, agentId, context) => JSON.stringify({
+    vaultPath,
+    query: query.trim().toLowerCase(),
+    limit,
+    agentId: agentId?.trim().toLowerCase() ?? '*',
+    context: context?.trim().toLowerCase() ?? '*'
+});
+const readCached = (key, indexSignature) => {
+    const entry = graphSearchCache.get(key);
+    if (!entry) {
+        return undefined;
+    }
+    const fresh = Date.now() - entry.createdAt <= graphSearchCacheTtlMs && entry.indexSignature === indexSignature;
+    if (!fresh) {
+        graphSearchCache.delete(key);
+        return undefined;
+    }
+    return entry.nodeIds;
+};
+const writeCached = (key, entry) => {
+    graphSearchCache.set(key, entry);
+    if (graphSearchCache.size <= graphSearchCacheMaxEntries) {
+        return;
+    }
+    const overflow = graphSearchCache.size - graphSearchCacheMaxEntries;
+    Array.from(graphSearchCache.keys()).slice(0, overflow).forEach((cacheKey) => graphSearchCache.delete(cacheKey));
+};
+export const searchGraphNodeIds = async (vaultPath, query, limit, agentId, context) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
+    const indexSignature = await readIndexSignature(absoluteVaultPath);
+    const key = cacheKey(absoluteVaultPath, query, limit, agentId, context);
+    const cached = readCached(key, indexSignature);
+    if (cached) {
+        return cached;
+    }
+    const contextNodeIds = context
+        ? new Set((await getGraphLayout(absoluteVaultPath, { agentId, context })).layout.nodes.map((node) => node.id))
+        : new Set();
     const index = openFileIndex(absoluteVaultPath);
     try {
-        return await index.searchGraphNodeIds(query, limit, agentId);
+        const searchLimit = context ? Math.max(limit, 5000) : limit;
+        const foundNodeIds = await index.searchGraphNodeIds(query, searchLimit, agentId);
+        const nodeIds = context
+            ? foundNodeIds.filter((nodeId) => contextNodeIds.has(nodeId)).slice(0, limit)
+            : foundNodeIds;
+        writeCached(key, {
+            createdAt: Date.now(),
+            indexSignature,
+            nodeIds
+        });
+        return nodeIds;
     }
     finally {
         index.close();