@andespindola/brainlink 0.1.0-beta.15 → 0.1.0-beta.150

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

@@ -0,0 +1,289 @@
+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 viewportNodes = nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < viewportNodes.length; index += 1) {
+        const node = viewportNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees));
+    }
+    const selected = selectTopByRelevance(viewportNodes, 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 viewportNodes = nodes.filter((node) => inViewport(node, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < viewportNodes.length; index += 1) {
+        const node = viewportNodes[index];
+        relevance.set(node.id, rankNodeRelevance(node, input, cache.degrees) * 1.1);
+    }
+    const selected = selectTopByRelevance(viewportNodes, 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 = (groups, input, nodeBudget) => {
+    const roots = groups.filter((group) => group.parentId === null);
+    const padding = Math.max(input.width, input.height) * 0.12;
+    const candidates = roots.filter((group) => inViewport(group, input, padding));
+    const relevance = new Map();
+    for (let index = 0; index < candidates.length; index += 1) {
+        const group = candidates[index];
+        relevance.set(group.id, rankGroupRelevance(group, input));
+    }
+    const selected = selectTopByRelevance(candidates, 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 collectEdgesForNodes = (allEdges, cache, nodeRows, edgeBudget, maxEdgesPerNode) => {
+    const isClusterMode = nodeRows.length > 0 && nodeRows[0]?.[6] === 'cluster';
+    if (isClusterMode) {
+        const clusterIds = new Set(nodeRows.map((row) => row[0].replace(/^cluster:/, '')));
+        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.group;
+            const targetCluster = targetNode.group;
+            if (!clusterIds.has(sourceCluster) || !clusterIds.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:${cache.nodeById.get(edge.source)?.group ?? ''}`,
+            `cluster:${cache.nodeById.get(edge.target ?? '')?.group ?? ''}`,
+            edge.weight,
+            edge.priority
+        ])
+            .filter((edge) => edge[0] !== edge[1] && edge[0] !== 'cluster:' && edge[1] !== 'cluster:');
+    }
+    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, input.agentId);
+    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' && groups.length > 0
+        ? selectFarClusters(groups, 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
+        }
+    };
+};

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
+        }
+    };
+};