@andespindola/brainlink 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/application/frontend/client-worker-js.js

@@ -0,0 +1,66 @@
+export const createClientWorkerJs = () => `const normalize = value => String(value || '')
+  .normalize('NFKD')
+  .replace(/\\p{Diacritic}/gu, '')
+  .toLowerCase()
+
+let nodeIndex = []
+
+const toNodeIndex = nodes =>
+  (Array.isArray(nodes) ? nodes : [])
+    .map(node => {
+      const id = typeof node.id === 'string' ? node.id : ''
+      if (!id) {
+        return null
+      }
+      const title = normalize(node.title)
+      const path = normalize(node.path)
+      const tags = Array.isArray(node.tags) ? node.tags.map(tag => normalize(tag)) : []
+      return {
+        id,
+        text: [title, path, ...tags].join(' ')
+      }
+    })
+    .filter(Boolean)
+
+const scoreText = (text, query) => {
+  if (!query) return 0
+  if (!text.includes(query)) return 0
+  if (text.startsWith(query)) return 4
+  return 1
+}
+
+const filterIds = (query, limit) => {
+  const normalizedQuery = normalize(query).trim()
+  if (!normalizedQuery) {
+    return []
+  }
+  const rows = []
+  for (let index = 0; index < nodeIndex.length; index += 1) {
+    const row = nodeIndex[index]
+    const score = scoreText(row.text, normalizedQuery)
+    if (score > 0) {
+      rows.push({ id: row.id, score })
+    }
+  }
+  rows.sort((left, right) => right.score - left.score || left.id.localeCompare(right.id))
+  return rows.slice(0, Math.max(1, Number.isFinite(limit) ? limit : rows.length)).map(row => row.id)
+}
+
+self.onmessage = event => {
+  const payload = event.data
+  if (!payload || typeof payload !== 'object') {
+    return
+  }
+  if (payload.type === 'load-nodes') {
+    nodeIndex = toNodeIndex(payload.nodes)
+    return
+  }
+  if (payload.type === 'filter') {
+    const token = payload.token
+    const ids = filterIds(payload.query, payload.limit)
+    self.postMessage({ type: 'filter-result', token, ids })
+  }
+}
+
+self.postMessage({ type: 'ready' })
+`;

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

@@ -1,12 +1,31 @@
 import { createHash } from 'node:crypto';
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { createCauliflowerGraphLayout } from '../domain/graph-layout.js';
+import { indexStoragePath } from '../infrastructure/file-index.js';
 import { getGraphSummary } from './get-graph-summary.js';
+const graphLayoutVersion = 2;
 const graphLayoutCache = new Map();
+const graphLayoutStoragePath = (vaultPath, agentId) => join(vaultPath, '.brainlink', `graph-layout-${agentId?.replace(/[^a-zA-Z0-9_-]/g, '_') ?? 'all'}.json`);
+const readPersistedLayout = async (vaultPath, databaseSignature, agentId) => {
+    try {
+        const parsed = JSON.parse(await readFile(graphLayoutStoragePath(vaultPath, agentId), 'utf8'));
+        return parsed.databaseSignature === databaseSignature && parsed.layoutVersion === graphLayoutVersion ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const writePersistedLayout = async (vaultPath, agentId, cached) => {
+    const target = graphLayoutStoragePath(vaultPath, agentId);
+    const temp = `${target}.tmp`;
+    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(temp, `${JSON.stringify(cached)}\n`, { encoding: 'utf8', mode: 0o600 });
+    await rename(temp, target);
+};
 const readDatabaseSignature = async (vaultPath) => {
     try {
-        const info = await stat(join(vaultPath, '.brainlink', 'brainlink.db'));
+        const info = await stat(indexStoragePath(vaultPath));
         return `${Math.floor(info.mtimeMs)}:${info.size}`;
     }
     catch {
@@ -26,16 +45,30 @@ export const getGraphLayout = async (vaultPath, agentId) => {
     const databaseSignature = await readDatabaseSignature(vaultPath);
     const cacheKey = `${vaultPath}:${agentId ?? ''}`;
     const cached = graphLayoutCache.get(cacheKey);
-    if (cached?.databaseSignature === databaseSignature) {
+    if (cached?.databaseSignature === databaseSignature && cached.layoutVersion === graphLayoutVersion) {
         return {
             signature: cached.signature,
             layout: cached.layout
         };
     }
+    const persisted = await readPersistedLayout(vaultPath, databaseSignature, agentId);
+    if (persisted) {
+        graphLayoutCache.set(cacheKey, persisted);
+        return {
+            signature: persisted.signature,
+            layout: persisted.layout
+        };
+    }
     const graph = await getGraphSummary(vaultPath, agentId);
     const signature = createGraphSignature(graph);
-    const layout = createCauliflowerGraphLayout(graph);
-    graphLayoutCache.set(cacheKey, { databaseSignature, signature, layout });
+    const rawLayout = createCauliflowerGraphLayout(graph);
+    const layout = {
+        ...rawLayout,
+        nodes: rawLayout.nodes.map((node) => ({ ...node, content: '' }))
+    };
+    const nextCache = { layoutVersion: graphLayoutVersion, databaseSignature, signature, layout };
+    graphLayoutCache.set(cacheKey, nextCache);
+    await writePersistedLayout(vaultPath, agentId, nextCache);
     return {
         signature,
         layout

package/dist/application/get-graph-node.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 getGraphNode = async (vaultPath, id, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.getGraphNode(id, agentId);
+        return await index.getGraphNode(id, agentId);
     }
     finally {
         index.close();

package/dist/application/get-graph-summary.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 getGraphSummary = async (vaultPath, agentId) => {
     const absoluteVaultPath = await ensureVault(vaultPath);
-    const index = openSqliteIndex(absoluteVaultPath);
+    const index = openFileIndex(absoluteVaultPath);
     try {
-        return index.getGraphSummary(agentId);
+        return await index.getGraphSummary(agentId);
     }
     finally {
         index.close();

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

@@ -0,0 +1,243 @@
+import { getGraphLayout } from './get-graph-layout.js';
+const macroScale = 0.24;
+const microCoverage = 0.72;
+const nodeLimit = 1000;
+const edgeLimit = 1400;
+const groupEdgeLimit = 900;
+const inViewport = (item, input) => {
+    const radius = item.radius ?? 48;
+    return (item.x + radius >= input.x &&
+        item.x - radius <= input.x + input.width &&
+        item.y + radius >= input.y &&
+        item.y - radius <= input.y + input.height);
+};
+const groupCoverage = (group, input) => {
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerX = input.x + input.width / 2;
+    const centerY = input.y + input.height / 2;
+    const centerDistance = Math.hypot(group.x - centerX, group.y - centerY);
+    const fitCoverage = Math.min(1, childGraphRenderRadius(group) / Math.max(viewportRadius, 1));
+    const centerCoverage = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    return fitCoverage * 0.72 + centerCoverage * 0.28;
+};
+const childGraphRenderRadius = (group) => {
+    const childCount = Math.max(group.nodeIds.length, group.childGroupIds.length, 1);
+    return Math.max(420, Math.min(1800, Math.sqrt(childCount) * 24));
+};
+const groupRenderRadius = (group) => {
+    const childCount = Math.max(group.nodeIds.length, group.childGroupIds.length, 1);
+    return 10 + Math.min(Math.log2(childCount + 1) * 4.2, 22);
+};
+const arrangeGraphLevelGroups = (groups) => {
+    if (groups.length <= 1) {
+        return groups.map((group) => ({ ...group, radius: groupRenderRadius(group) }));
+    }
+    const centerGroup = groups
+        .map((group) => ({
+        group,
+        score: Math.max(group.nodeIds.length, group.childGroupIds.length, 1) + group.externalEdges.length
+    }))
+        .sort((left, right) => right.score - left.score || left.group.title.localeCompare(right.group.title))[0]?.group;
+    const outerGroups = groups
+        .filter((group) => group.id !== centerGroup?.id)
+        .sort((left, right) => left.segment.localeCompare(right.segment) || left.title.localeCompare(right.title));
+    const baseRadius = Math.max(520, Math.min(2200, Math.sqrt(groups.length) * 135));
+    const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+    const arranged = centerGroup
+        ? [{ ...centerGroup, x: 0, y: 0, radius: groupRenderRadius(centerGroup) }]
+        : [];
+    outerGroups.forEach((group, index) => {
+        const ringRadius = baseRadius * Math.sqrt((index + 1) / Math.max(outerGroups.length, 1));
+        const angle = index * goldenAngle;
+        arranged.push({
+            ...group,
+            x: Math.cos(angle) * ringRadius,
+            y: Math.sin(angle) * ringRadius,
+            radius: groupRenderRadius(group)
+        });
+    });
+    return arranged;
+};
+const distanceToViewportCenter = (item, input) => {
+    const centerX = input.x + input.width / 2;
+    const centerY = input.y + input.height / 2;
+    return Math.hypot(item.x - centerX, item.y - centerY);
+};
+const selectViewportItemsWithFill = (items, input, limit = nodeLimit) => {
+    const visible = items.filter((item) => inViewport(item, input));
+    if (visible.length >= limit) {
+        return visible.slice(0, limit);
+    }
+    const selectedIds = new Set(visible.map((item) => item.id));
+    const fill = items
+        .filter((item) => !selectedIds.has(item.id))
+        .sort((left, right) => distanceToViewportCenter(left, input) - distanceToViewportCenter(right, input) || left.id.localeCompare(right.id))
+        .slice(0, Math.max(0, limit - visible.length));
+    return visible.concat(fill);
+};
+const groupNode = (group) => [
+    `group:${group.id}`,
+    group.title,
+    group.x,
+    group.y,
+    group.group,
+    group.segment,
+    'group'
+];
+const realNode = (node) => [
+    node.id,
+    node.title,
+    node.x,
+    node.y,
+    node.group,
+    node.segment,
+    'node'
+];
+const descendants = (group, groupById) => group.nodeIds.length > 0
+    ? group.nodeIds
+    : group.childGroupIds.flatMap((childId) => {
+        const child = groupById.get(childId);
+        return child ? descendants(child, groupById) : [];
+    });
+const aggregateGroupEdges = (groups, edges, groupById) => {
+    const groupNodeByNodeId = new Map();
+    groups.forEach((group) => {
+        descendants(group, groupById).forEach((nodeId) => groupNodeByNodeId.set(nodeId, `group:${group.id}`));
+    });
+    const selected = new Map();
+    edges.forEach((edge) => {
+        if (!edge.target)
+            return;
+        const source = groupNodeByNodeId.get(edge.source);
+        const target = groupNodeByNodeId.get(edge.target);
+        if (!source || !target || source === target)
+            return;
+        const key = source < target ? `${source}|${target}` : `${target}|${source}`;
+        const current = selected.get(key);
+        if (current && current[2] >= edge.weight)
+            return;
+        selected.set(key, [source, target, edge.weight, edge.priority]);
+    });
+    const degreeCounts = new Map();
+    return Array.from(selected.values())
+        .sort((left, right) => right[2] - left[2] || left[0].localeCompare(right[0]) || left[1].localeCompare(right[1]))
+        .filter((edge) => {
+        const sourceCount = degreeCounts.get(edge[0]) ?? 0;
+        const targetCount = degreeCounts.get(edge[1]) ?? 0;
+        if (sourceCount >= 3 || targetCount >= 3) {
+            return false;
+        }
+        degreeCounts.set(edge[0], sourceCount + 1);
+        degreeCounts.set(edge[1], targetCount + 1);
+        return true;
+    })
+        .slice(0, groupEdgeLimit);
+};
+const realEdges = (edges, nodeIds) => edges
+    .filter((edge) => Boolean(edge.target && nodeIds.has(edge.source) && nodeIds.has(edge.target)))
+    .slice(0, edgeLimit)
+    .map((edge) => [edge.source, edge.target, edge.weight, edge.priority]);
+const degreeMap = (edges) => edges.reduce((degrees, edge) => {
+    degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edge.weight);
+    if (edge.target) {
+        degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edge.weight);
+    }
+    return degrees;
+}, new Map());
+const arrangeChildGraphNodes = (nodes, group, degrees) => {
+    if (nodes.length <= 1) {
+        return nodes.map((node) => ({ ...node, x: group.x, y: group.y }));
+    }
+    const centerNode = nodes
+        .map((node) => ({
+        node,
+        score: (degrees.get(node.id) ?? 0) + node.tags.length
+    }))
+        .sort((left, right) => right.score - left.score || left.node.title.localeCompare(right.node.title))[0]?.node;
+    const outerNodes = nodes
+        .filter((node) => node.id !== centerNode?.id)
+        .sort((left, right) => {
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    const targetRadius = childGraphRenderRadius(group);
+    const goldenAngle = Math.PI * (3 - Math.sqrt(5));
+    const arranged = centerNode
+        ? [{ ...centerNode, x: group.x, y: group.y }]
+        : [];
+    outerNodes.forEach((node, index) => {
+        const ringRadius = targetRadius * Math.sqrt((index + 1) / Math.max(outerNodes.length, 1));
+        const angle = index * goldenAngle;
+        arranged.push({
+            ...node,
+            x: group.x + Math.cos(angle) * ringRadius,
+            y: group.y + Math.sin(angle) * ringRadius
+        });
+    });
+    return arranged;
+};
+const limitEdges = (edges) => edges.slice(0, edgeLimit);
+export const getGraphView = async (vaultPath, input) => {
+    const { signature, layout } = await getGraphLayout(vaultPath, input.agentId);
+    const groups = layout.groups ?? [];
+    const degrees = degreeMap(layout.edges);
+    const groupById = new Map(groups.map((group) => [group.id, group]));
+    if (groups.length === 0) {
+        const nodes = layout.nodes.filter((node) => inViewport(node, input)).slice(0, nodeLimit);
+        const nodeIds = new Set(nodes.map((node) => node.id));
+        const viewNodes = nodes.map(realNode);
+        return {
+            signature,
+            mode: 'flat',
+            nodes: viewNodes,
+            edges: limitEdges(realEdges(layout.edges, nodeIds)),
+            totals: {
+                nodes: layout.nodes.length,
+                edges: layout.edges.length
+            }
+        };
+    }
+    const rootGroups = arrangeGraphLevelGroups(groups.filter((group) => group.parentId === null));
+    const leafGroups = arrangeGraphLevelGroups(groups.filter((group) => group.nodeIds.length > 0));
+    const visibleGroups = selectViewportItemsWithFill(rootGroups, input);
+    const focused = leafGroups
+        .filter((group) => group.nodeIds.length > 0 && inViewport(group, input))
+        .map((group) => ({ group, coverage: groupCoverage(group, input) }))
+        .sort((left, right) => right.coverage - left.coverage)[0];
+    if (focused && input.scale >= macroScale && focused.coverage >= microCoverage) {
+        const nodeIds = new Set(focused.group.nodeIds);
+        const arrangedNodes = arrangeChildGraphNodes(layout.nodes.filter((node) => nodeIds.has(node.id)), focused.group, degrees);
+        const nodesInViewport = arrangedNodes
+            .filter((node) => inViewport(node, input))
+            .slice(0, nodeLimit);
+        const nodes = nodesInViewport.length > 0
+            ? nodesInViewport
+            : arrangedNodes.slice(0, nodeLimit);
+        const visibleNodeIds = new Set(nodes.map((node) => node.id));
+        const viewNodes = nodes.map(realNode);
+        return {
+            signature,
+            mode: 'micro',
+            nodes: viewNodes,
+            edges: limitEdges(realEdges(layout.edges, visibleNodeIds)),
+            totals: {
+                nodes: layout.nodes.length,
+                edges: layout.edges.length
+            }
+        };
+    }
+    const groupsToRender = visibleGroups.slice(0, nodeLimit);
+    const viewNodes = groupsToRender.map(groupNode);
+    return {
+        signature,
+        mode: 'macro',
+        nodes: viewNodes,
+        edges: limitEdges(aggregateGroupEdges(groupsToRender, layout.edges, groupById)),
+        totals: {
+            nodes: layout.nodes.length,
+            edges: layout.edges.length
+        }
+    };
+};

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();