@andespindola/brainlink 0.1.0-beta.16 → 0.1.0-beta.161

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

@@ -0,0 +1,33 @@
+import { getGraphLayout } from './get-graph-layout.js';
+export const getGraphContexts = async (vaultPath, agentId) => {
+    const { layout } = await getGraphLayout(vaultPath, { agentId });
+    const nodeIdsByContext = new Map();
+    const contextByNodeId = new Map();
+    layout.nodes.forEach((node) => {
+        const title = node.segment || node.group || 'root';
+        const nodeIds = nodeIdsByContext.get(title) ?? new Set();
+        nodeIds.add(node.id);
+        nodeIdsByContext.set(title, nodeIds);
+        contextByNodeId.set(node.id, title);
+    });
+    const edgeCountByContext = new Map();
+    layout.edges.forEach((edge) => {
+        if (!edge.target) {
+            return;
+        }
+        const sourceContext = contextByNodeId.get(edge.source);
+        const targetContext = contextByNodeId.get(edge.target);
+        if (!sourceContext || sourceContext !== targetContext) {
+            return;
+        }
+        edgeCountByContext.set(sourceContext, (edgeCountByContext.get(sourceContext) ?? 0) + 1);
+    });
+    return Array.from(nodeIdsByContext.entries())
+        .map(([title, nodeIds]) => ({
+        id: title,
+        title,
+        nodeCount: nodeIds.size,
+        edgeCount: edgeCountByContext.get(title) ?? 0
+    }))
+        .sort((left, right) => right.nodeCount - left.nodeCount || left.title.localeCompare(right.title));
+};

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

@@ -1,9 +1,34 @@
 import { createHash } from 'node:crypto';
-import { stat } from 'node:fs/promises';
+import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { addVisualContextEdges } from '../domain/graph-contexts.js';
 import { createCauliflowerGraphLayout } from '../domain/graph-layout.js';
 import { indexStoragePath } from '../infrastructure/file-index.js';
 import { getGraphSummary } from './get-graph-summary.js';
+const graphLayoutVersion = 9;
 const graphLayoutCache = new Map();
+const safeCacheSegment = (value, fallback) => value?.replace(/[^a-zA-Z0-9_-]/g, '_') || fallback;
+const graphLayoutStoragePath = (vaultPath, options) => {
+    const agent = safeCacheSegment(options.agentId, 'all');
+    const context = safeCacheSegment(options.context, 'all-contexts');
+    return join(vaultPath, '.brainlink', `graph-layout-${agent}-${context}.json`);
+};
+const readPersistedLayout = async (vaultPath, databaseSignature, options) => {
+    try {
+        const parsed = JSON.parse(await readFile(graphLayoutStoragePath(vaultPath, options), 'utf8'));
+        return parsed.databaseSignature === databaseSignature && parsed.layoutVersion === graphLayoutVersion ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+};
+const writePersistedLayout = async (vaultPath, options, cached) => {
+    const target = graphLayoutStoragePath(vaultPath, options);
+    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(indexStoragePath(vaultPath));
@@ -22,20 +47,49 @@ const createGraphSignature = (graph) => {
         .update(`${graph.nodes.length}:${nodesSignature}|${graph.edges.length}:${edgesSignature}`)
         .digest('hex');
 };
-export const getGraphLayout = async (vaultPath, agentId) => {
+const createLayout = (graph) => {
+    const rawLayout = createCauliflowerGraphLayout(graph);
+    return {
+        ...rawLayout,
+        nodes: rawLayout.nodes.map((node) => ({ ...node, content: '' }))
+    };
+};
+const filterGraphByContext = (graph, context) => {
+    const baseLayout = createCauliflowerGraphLayout(graph);
+    const selectedNodeIds = new Set(baseLayout.nodes
+        .filter((node) => node.segment === context)
+        .map((node) => node.id));
+    return {
+        nodes: graph.nodes.filter((node) => selectedNodeIds.has(node.id)),
+        edges: graph.edges.filter((edge) => selectedNodeIds.has(edge.source) && Boolean(edge.target && selectedNodeIds.has(edge.target)))
+    };
+};
+export const getGraphLayout = async (vaultPath, optionsOrAgentId) => {
+    const options = typeof optionsOrAgentId === 'string' ? { agentId: optionsOrAgentId } : optionsOrAgentId ?? {};
     const databaseSignature = await readDatabaseSignature(vaultPath);
-    const cacheKey = `${vaultPath}:${agentId ?? ''}`;
+    const cacheKey = `${vaultPath}:${options.agentId ?? ''}:${options.context ?? ''}`;
     const cached = graphLayoutCache.get(cacheKey);
-    if (cached?.databaseSignature === databaseSignature) {
+    if (cached?.databaseSignature === databaseSignature && cached.layoutVersion === graphLayoutVersion) {
         return {
             signature: cached.signature,
             layout: cached.layout
         };
     }
-    const graph = await getGraphSummary(vaultPath, agentId);
-    const signature = createGraphSignature(graph);
-    const layout = createCauliflowerGraphLayout(graph);
-    graphLayoutCache.set(cacheKey, { databaseSignature, signature, layout });
+    const persisted = await readPersistedLayout(vaultPath, databaseSignature, options);
+    if (persisted) {
+        graphLayoutCache.set(cacheKey, persisted);
+        return {
+            signature: persisted.signature,
+            layout: persisted.layout
+        };
+    }
+    const graph = addVisualContextEdges(await getGraphSummary(vaultPath, options.agentId));
+    const scopedGraph = options.context ? filterGraphByContext(graph, options.context) : graph;
+    const signature = createGraphSignature(scopedGraph);
+    const layout = createLayout(scopedGraph);
+    const nextCache = { layoutVersion: graphLayoutVersion, databaseSignature, signature, layout };
+    graphLayoutCache.set(cacheKey, nextCache);
+    await writePersistedLayout(vaultPath, options, nextCache);
     return {
         signature,
         layout

package/dist/application/get-graph-stream-chunk.js

@@ -0,0 +1,326 @@
+import { getGraphLayout } from './get-graph-layout.js';
+const layoutCacheBySignature = new Map();
+const maxLayoutCacheEntries = 6;
+const farScaleThreshold = 0.22;
+const midScaleThreshold = 0.78;
+const viewportPaddingFactor = 0.18;
+const maxNearEdgePerNode = 24;
+const maxMidEdgePerNode = 12;
+const maxFarEdgePerCluster = 8;
+const inViewport = (item, input, padding) => {
+    const radius = item.radius ?? 24;
+    const paddedX = input.x - padding;
+    const paddedY = input.y - padding;
+    const paddedWidth = input.width + padding * 2;
+    const paddedHeight = input.height + padding * 2;
+    return (item.x + radius >= paddedX &&
+        item.x - radius <= paddedX + paddedWidth &&
+        item.y + radius >= paddedY &&
+        item.y - radius <= paddedY + paddedHeight);
+};
+const nodeDistanceToCenter = (item, input) => {
+    const cx = input.x + input.width / 2;
+    const cy = input.y + input.height / 2;
+    return Math.hypot(item.x - cx, item.y - cy);
+};
+const rankNodeRelevance = (node, input, degrees) => {
+    const degree = degrees.get(node.id) ?? 0;
+    const centerDistance = nodeDistanceToCenter(node, input);
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerScore = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    const degreeScore = Math.log1p(Math.max(0, degree));
+    const tagScore = Math.min(node.tags.length, 6) * 0.18;
+    return degreeScore * 1.1 + centerScore * 1.3 + tagScore;
+};
+const rankGroupRelevance = (group, input) => {
+    const centerDistance = nodeDistanceToCenter(group, input);
+    const viewportRadius = Math.max(input.width, input.height) / 2;
+    const centerScore = 1 - Math.min(1, centerDistance / Math.max(viewportRadius, 1));
+    const massScore = Math.log1p(group.nodeIds.length + group.childGroupIds.length * 2);
+    const edgeScore = Math.log1p(group.externalEdges.length + group.internalEdges.length);
+    return centerScore * 1.3 + massScore + edgeScore * 0.5;
+};
+const edgePriorityScore = (priority) => {
+    if (priority === 'critical')
+        return 4;
+    if (priority === 'high')
+        return 3;
+    if (priority === 'normal')
+        return 2;
+    return 1;
+};
+const edgeRank = (edge) => edge.weight * 1.35 + edgePriorityScore(edge.priority);
+const createLayoutCache = (signature, nodes, edges, groups) => {
+    const nodeById = new Map(nodes.map((node) => [node.id, node]));
+    const groupById = new Map(groups.map((group) => [group.id, group]));
+    const degrees = new Map();
+    const adjacencyByNodeId = new Map();
+    const rankedAdjacencyByNodeId = new Map();
+    for (let index = 0; index < edges.length; index += 1) {
+        const edge = edges[index];
+        degrees.set(edge.source, (degrees.get(edge.source) ?? 0) + edge.weight);
+        const sourceAdjacency = adjacencyByNodeId.get(edge.source) ?? [];
+        sourceAdjacency.push(index);
+        adjacencyByNodeId.set(edge.source, sourceAdjacency);
+        if (!edge.target) {
+            continue;
+        }
+        degrees.set(edge.target, (degrees.get(edge.target) ?? 0) + edge.weight);
+        const targetAdjacency = adjacencyByNodeId.get(edge.target) ?? [];
+        targetAdjacency.push(index);
+        adjacencyByNodeId.set(edge.target, targetAdjacency);
+    }
+    for (const [nodeId, adjacency] of adjacencyByNodeId.entries()) {
+        rankedAdjacencyByNodeId.set(nodeId, [...adjacency].sort((leftIndex, rightIndex) => edgeRank(edges[rightIndex]) - edgeRank(edges[leftIndex])));
+    }
+    return {
+        signature,
+        degrees,
+        nodeById,
+        groupById,
+        adjacencyByNodeId,
+        rankedAdjacencyByNodeId
+    };
+};
+const getOrCreateLayoutCache = (signature, nodes, edges, groups) => {
+    const cached = layoutCacheBySignature.get(signature);
+    if (cached) {
+        return cached;
+    }
+    const next = createLayoutCache(signature, nodes, edges, groups);
+    layoutCacheBySignature.set(signature, next);
+    while (layoutCacheBySignature.size > maxLayoutCacheEntries) {
+        const oldest = layoutCacheBySignature.keys().next().value;
+        if (!oldest)
+            break;
+        layoutCacheBySignature.delete(oldest);
+    }
+    return next;
+};
+const selectTopByRelevance = (items, relevanceById, budget) => [...items]
+    .sort((left, right) => {
+    const relevanceDelta = (relevanceById.get(right.id) ?? 0) - (relevanceById.get(left.id) ?? 0);
+    if (relevanceDelta !== 0)
+        return relevanceDelta;
+    return left.id.localeCompare(right.id);
+})
+    .slice(0, Math.max(1, budget));
+const selectNearNodes = (nodes, cache, input) => {
+    const padding = Math.max(input.width, input.height) * viewportPaddingFactor;
+    const candidateNodes = nodes.length <= input.nodeBudget
+        ? nodes
+        : nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < candidateNodes.length; index += 1) {
+        const node = candidateNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees));
+    }
+    const selected = selectTopByRelevance(candidateNodes, relevance, input.nodeBudget);
+    return selected.map((node) => [
+        node.id,
+        node.title,
+        node.x,
+        node.y,
+        node.group,
+        node.segment,
+        'node',
+        relevance.get(node.id) ?? 0
+    ]);
+};
+const selectMidNodes = (nodes, cache, input) => {
+    const padding = Math.max(input.width, input.height) * (viewportPaddingFactor + 0.08);
+    const candidateNodes = nodes.length <= input.nodeBudget
+        ? nodes
+        : nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < candidateNodes.length; index += 1) {
+        const node = candidateNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees) * 1.1);
+    }
+    const selected = selectTopByRelevance(candidateNodes, relevance, input.nodeBudget);
+    return selected.map((node) => [
+        node.id,
+        node.title,
+        node.x,
+        node.y,
+        node.group,
+        node.segment,
+        'node',
+        relevance.get(node.id) ?? 0
+    ]);
+};
+const selectFarClusters = (nodes, input, nodeBudget) => {
+    const roots = createSegmentClusters(nodes);
+    const relevance = new Map();
+    for (let index = 0; index < roots.length; index += 1) {
+        const group = roots[index];
+        relevance.set(group.id, rankGroupRelevance(group, input));
+    }
+    const selected = selectTopByRelevance(roots, relevance, nodeBudget);
+    return selected.map((group) => [
+        `cluster:${group.id}`,
+        group.title,
+        group.x,
+        group.y,
+        group.group,
+        group.segment,
+        'cluster',
+        relevance.get(group.id) ?? 0
+    ]);
+};
+const createSegmentClusters = (nodes) => {
+    const nodesBySegment = new Map();
+    nodes.forEach((node) => {
+        const bucket = nodesBySegment.get(node.segment) ?? [];
+        bucket.push(node);
+        nodesBySegment.set(node.segment, bucket);
+    });
+    return Array.from(nodesBySegment.entries()).map(([segment, segmentNodes]) => {
+        const center = segmentNodes.reduce((state, node) => ({
+            x: state.x + node.x,
+            y: state.y + node.y
+        }), { x: 0, y: 0 });
+        const x = center.x / Math.max(segmentNodes.length, 1);
+        const y = center.y / Math.max(segmentNodes.length, 1);
+        const radius = segmentNodes.reduce((largest, node) => Math.max(largest, Math.hypot(node.x - x, node.y - y)), 80);
+        return {
+            id: `segment:${segment}`,
+            level: 0,
+            parentId: null,
+            title: segment,
+            segment,
+            group: segmentNodes[0]?.group ?? segment,
+            x,
+            y,
+            radius: Math.max(radius + 96, 160),
+            nodeIds: segmentNodes.map((node) => node.id),
+            childGroupIds: [],
+            internalEdges: [],
+            externalEdges: []
+        };
+    });
+};
+const collectEdgesForNodes = (allEdges, cache, nodeRows, edgeBudget, maxEdgesPerNode) => {
+    const isClusterMode = nodeRows.length > 0 && nodeRows[0]?.[6] === 'cluster';
+    if (isClusterMode) {
+        const clusterSegments = new Set(nodeRows.map((row) => row[5]));
+        const clusterEdges = new Map();
+        for (let index = 0; index < allEdges.length; index += 1) {
+            const edge = allEdges[index];
+            if (!edge.target)
+                continue;
+            const sourceNode = cache.nodeById.get(edge.source);
+            const targetNode = cache.nodeById.get(edge.target);
+            if (!sourceNode || !targetNode)
+                continue;
+            const sourceCluster = sourceNode.segment;
+            const targetCluster = targetNode.segment;
+            if (!clusterSegments.has(sourceCluster) || !clusterSegments.has(targetCluster) || sourceCluster === targetCluster)
+                continue;
+            const key = sourceCluster < targetCluster ? `${sourceCluster}|${targetCluster}` : `${targetCluster}|${sourceCluster}`;
+            const current = clusterEdges.get(key);
+            if (!current || edgeRank(edge) > edgeRank(current)) {
+                clusterEdges.set(key, edge);
+            }
+        }
+        return [...clusterEdges.values()]
+            .sort((left, right) => edgeRank(right) - edgeRank(left))
+            .slice(0, Math.max(1, edgeBudget))
+            .map((edge) => [
+            `cluster:segment:${cache.nodeById.get(edge.source)?.segment ?? ''}`,
+            `cluster:segment:${cache.nodeById.get(edge.target ?? '')?.segment ?? ''}`,
+            edge.weight,
+            edge.priority
+        ])
+            .filter((edge) => edge[0] !== edge[1] && edge[0] !== 'cluster:segment:' && edge[1] !== 'cluster:segment:');
+    }
+    const nodeIds = new Set(nodeRows.map((row) => row[0]));
+    const collected = new Map();
+    for (const nodeId of nodeIds) {
+        const adjacency = cache.rankedAdjacencyByNodeId.get(nodeId);
+        if (!adjacency || adjacency.length === 0) {
+            continue;
+        }
+        let perNodeCount = 0;
+        for (let index = 0; index < adjacency.length; index += 1) {
+            if (perNodeCount >= maxEdgesPerNode) {
+                break;
+            }
+            const edge = allEdges[adjacency[index]];
+            if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
+                continue;
+            }
+            const key = edge.source < edge.target ? `${edge.source}|${edge.target}` : `${edge.target}|${edge.source}`;
+            const current = collected.get(key);
+            if (!current || edgeRank(edge) > edgeRank(current)) {
+                collected.set(key, edge);
+            }
+            perNodeCount += 1;
+        }
+    }
+    return [...collected.values()]
+        .sort((left, right) => edgeRank(right) - edgeRank(left))
+        .slice(0, Math.max(1, edgeBudget))
+        .map((edge) => [edge.source, edge.target ?? '', edge.weight, edge.priority])
+        .filter((edge) => edge[1].length > 0);
+};
+const normalizeBudget = (value, fallback, min, max) => {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    const rounded = Math.round(value);
+    if (rounded < min)
+        return min;
+    if (rounded > max)
+        return max;
+    return rounded;
+};
+export const getGraphStreamChunk = async (vaultPath, input) => {
+    const nodeBudget = normalizeBudget(input.nodeBudget, 1800, 80, 12_000);
+    const edgeBudget = normalizeBudget(input.edgeBudget, 5000, 120, 60_000);
+    const { signature, layout } = await getGraphLayout(vaultPath, {
+        agentId: input.agentId,
+        context: input.context
+    });
+    const groups = layout.groups ?? [];
+    const cache = getOrCreateLayoutCache(signature, layout.nodes, layout.edges, groups);
+    if (layout.nodes.length === 0) {
+        return {
+            signature,
+            mode: 'near',
+            nodes: [],
+            edges: [],
+            totals: {
+                nodes: 0,
+                edges: 0
+            }
+        };
+    }
+    const mode = input.scale < farScaleThreshold
+        ? 'far'
+        : input.scale < midScaleThreshold
+            ? 'mid'
+            : 'near';
+    const nodes = mode === 'far'
+        ? selectFarClusters(layout.nodes, input, nodeBudget)
+        : mode === 'mid'
+            ? selectMidNodes(layout.nodes, cache, {
+                ...input,
+                nodeBudget
+            })
+            : selectNearNodes(layout.nodes, cache, {
+                ...input,
+                nodeBudget
+            });
+    const edges = collectEdgesForNodes(layout.edges, cache, nodes, edgeBudget, mode === 'near' ? maxNearEdgePerNode : mode === 'mid' ? maxMidEdgePerNode : maxFarEdgePerCluster);
+    return {
+        signature,
+        mode,
+        nodes,
+        edges,
+        totals: {
+            nodes: layout.nodes.length,
+            edges: layout.edges.length
+        }
+    };
+};