@andespindola/brainlink 0.1.0-beta.99 → 1.0.0

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

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

@@ -0,0 +1,246 @@
+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, {
+        agentId: input.agentId,
+        context: input.context
+    });
+    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
+        }
+    };
+};