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

package/dist/domain/graph-layout.js

@@ -1,3 +1,5 @@
+import { inferExplicitVisualGraphContext } from './graph-contexts.js';
+const hierarchyGroupNodeLimit = 1000;
 const groupLabels = {
     '00-maps': 'maps',
     '10-agent-memory': 'agent-memory',
@@ -20,6 +22,7 @@ const segmentAngles = {
     Evaluation: 2.08,
     Security: 2.82
 };
+const hubTitlePattern = /\b(memory\s*hub|knowledge\s*root|moc|map)\b/i;
 const hashText = (value) => Array.from(value).reduce((hash, char) => ((hash << 5) - hash + char.charCodeAt(0)) | 0, 0);
 const jitter = (value, range) => {
     const normalized = Math.abs(hashText(value) % 1000) / 1000;
@@ -62,6 +65,48 @@ const byDegreeThenTitle = (degrees) => (left, right) => {
     const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
     return degreeDelta === 0 ? byTitle(left, right) : degreeDelta;
 };
+const hubScore = (node) => {
+    const title = node.title.trim().toLowerCase();
+    if (title === 'memory hub')
+        return 5;
+    if (title === 'knowledge root')
+        return 4;
+    if (/\bmoc\b/i.test(node.title))
+        return 3;
+    return hubTitlePattern.test(node.title) ? 2 : 0;
+};
+const selectPrimaryHubId = (nodes, degrees) => {
+    const ranked = [...nodes]
+        .filter((node) => hubScore(node) > 0)
+        .sort((left, right) => {
+        const scoreDelta = hubScore(right) - hubScore(left);
+        if (scoreDelta !== 0)
+            return scoreDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    return ranked[0]?.id ?? null;
+};
+const selectHighestDegreeNodeId = (nodes, degrees) => [...nodes].sort((left, right) => {
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? left.title.localeCompare(right.title) : degreeDelta;
+})[0]?.id ?? null;
+const centerLayoutByNode = (nodes, nodeId) => {
+    if (!nodeId) {
+        return nodes;
+    }
+    const anchor = nodes.find((node) => node.id === nodeId);
+    if (!anchor) {
+        return nodes;
+    }
+    return nodes.map((node) => ({
+        ...node,
+        x: node.x - anchor.x,
+        y: node.y - anchor.y
+    }));
+};
 const naturalSegmentSeed = (node) => groupKey(node) === '00-maps' || /\b(moc|map)\b/i.test(node.title);
 const segmentName = (node) => node.title.replace(/^MOC\s+/i, '').replace(/\s+Memory Map$/i, '').trim() || node.title;
 const collectComponent = (adjacency, startId, visited) => {
@@ -96,8 +141,16 @@ const selectSegmentSeeds = (nodes, edges, degrees) => {
 const assignSegments = (nodes, edges, degrees) => {
     const adjacency = createAdjacency(nodes, edges);
     const seeds = selectSegmentSeeds(nodes, edges, degrees);
-    const assignments = new Map(seeds.map((seed) => [seed.id, segmentName(seed)]));
+    const assignments = new Map(nodes.flatMap((node) => {
+        const visualContext = inferExplicitVisualGraphContext(node);
+        return visualContext ? [[node.id, visualContext.title]] : [];
+    }));
     const queue = seeds.map((seed) => seed.id);
+    seeds.forEach((seed) => {
+        if (!assignments.has(seed.id)) {
+            assignments.set(seed.id, segmentName(seed));
+        }
+    });
     for (let index = 0; index < queue.length; index += 1) {
         const id = queue[index];
         const segment = assignments.get(id);
@@ -128,27 +181,245 @@ const groupNodesBySegment = (nodes, segments) => {
     return new Map(groups);
 };
 const segmentAngle = (segment, index, count) => segmentAngles[segment] ?? (Math.PI * 2 * index) / Math.max(count, 1) - Math.PI / 2;
-const createSegmentNodes = (segments, degrees, segmentCount) => ([segment, nodes], segmentIndex) => {
+const compareByStarOrder = (levels, degrees, segmentIndexByName, segments) => (left, right) => {
+    const levelDelta = (levels.get(left.id) ?? 1) - (levels.get(right.id) ?? 1);
+    if (levelDelta !== 0)
+        return levelDelta;
+    const leftSegment = segments.get(left.id) ?? groupLabel(groupKey(left));
+    const rightSegment = segments.get(right.id) ?? groupLabel(groupKey(right));
+    const segmentDelta = (segmentIndexByName.get(leftSegment) ?? 0) - (segmentIndexByName.get(rightSegment) ?? 0);
+    if (segmentDelta !== 0)
+        return segmentDelta;
+    const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+    return degreeDelta === 0 ? left.title.localeCompare(right.title) : degreeDelta;
+};
+const petalRadiusForSegmentSize = (size) => {
+    const safeSize = Math.max(size, 1);
+    return Math.max(260, Math.sqrt(safeSize) * 96);
+};
+const selectSegmentHub = (nodes, degrees, primaryHubId) => {
+    const primary = nodes.find((node) => node.id === primaryHubId);
+    if (primary) {
+        return primary;
+    }
+    return [...nodes].sort((left, right) => {
+        const hubDelta = hubScore(right) - hubScore(left);
+        if (hubDelta !== 0)
+            return hubDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    })[0] ?? null;
+};
+const segmentCenterRadius = (segments) => {
+    if (segments.length <= 1) {
+        return 0;
+    }
+    const circumference = segments.reduce((total, [, nodes]) => total + petalRadiusForSegmentSize(nodes.length) * 2 + 180, 0);
+    return Math.max(520, circumference / (Math.PI * 2));
+};
+const createCauliflowerSegmentNodes = (segments, degrees, rootHubId, segmentGroups) => ([segment, nodes], segmentIndex) => {
     const sortedNodes = [...nodes].sort(byDegreeThenTitle(degrees));
-    const angle = segmentAngle(segment, segmentIndex, segmentCount);
-    const baseRadius = segmentCount === 1 ? 0 : 340 + Math.min(sortedNodes.length, 22) * 10;
-    const centerX = Math.cos(angle) * baseRadius;
-    const centerY = Math.sin(angle) * (baseRadius * 0.78);
-    const petalSpread = 40 + Math.sqrt(sortedNodes.length) * 14;
-    return sortedNodes.map((node, index) => {
-        const localAngle = index * 2.399963 + jitter(node.title, 0.42);
-        const localRadius = Math.sqrt(index + 1) * petalSpread;
-        const hubPull = segmentCount === 1 ? 0 : Math.min(degrees.get(node.id) ?? 0, 12) * 12;
+    const segmentHub = selectSegmentHub(sortedNodes, degrees, rootHubId);
+    const angle = segmentAngle(segment, segmentIndex, segmentGroups.length);
+    const globalRadius = segmentCenterRadius(segmentGroups);
+    const petalRadius = petalRadiusForSegmentSize(sortedNodes.length);
+    const isPrimarySegment = Boolean(segmentHub && segmentHub.id === rootHubId);
+    const centerX = isPrimarySegment || globalRadius === 0 ? 0 : Math.cos(angle) * globalRadius;
+    const centerY = isPrimarySegment || globalRadius === 0 ? 0 : Math.sin(angle) * (globalRadius * 0.86);
+    const nonHubNodes = sortedNodes.filter((node) => node.id !== segmentHub?.id);
+    const hubNode = segmentHub
+        ? [{
+                ...segmentHub,
+                group: groupLabel(groupKey(segmentHub)),
+                segment: segments.get(segmentHub.id) ?? segment,
+                x: centerX,
+                y: centerY
+            }]
+        : [];
+    const petalNodes = nonHubNodes.map((node, index) => {
+        const localAngle = index * 2.399963 + jitter(node.title, 0.5);
+        const radialLayer = Math.sqrt(index + 1) / Math.sqrt(Math.max(nonHubNodes.length, 1));
+        const localRadius = 150 + radialLayer * petalRadius + jitter(node.id, 34);
+        const degreePull = Math.min(degrees.get(node.id) ?? 0, 16) * 8;
+        const radius = Math.max(126, localRadius - degreePull);
         return {
             ...node,
             group: groupLabel(groupKey(node)),
             segment: segments.get(node.id) ?? segment,
-            x: centerX + Math.cos(localAngle) * localRadius - Math.cos(angle) * hubPull + jitter(node.id, 24),
-            y: centerY + Math.sin(localAngle) * localRadius * 0.78 - Math.sin(angle) * hubPull + jitter(node.path, 24)
+            x: centerX + Math.cos(localAngle) * radius + jitter(node.title, 20),
+            y: centerY + Math.sin(localAngle) * radius * 0.84 + jitter(node.path, 20)
         };
     });
+    return [...hubNode, ...petalNodes];
+};
+const createVisualEdge = (source, target, weight, priority) => ({
+    source: source.id,
+    target: target.id,
+    targetTitle: target.title,
+    weight,
+    priority
+});
+const createCauliflowerVisualEdges = (segmentGroups, degrees, rootHubId) => {
+    const nodeById = new Map(segmentGroups.flatMap(([, nodes]) => nodes.map((node) => [node.id, node])));
+    const rootHub = rootHubId ? nodeById.get(rootHubId) ?? null : null;
+    const edges = new Map();
+    const addEdge = (edge) => {
+        if (!edge.target || edge.source === edge.target) {
+            return;
+        }
+        edges.set(`${edge.source}|${edge.target}`, edge);
+    };
+    segmentGroups.forEach(([, nodes]) => {
+        const segmentHub = selectSegmentHub(nodes, degrees, rootHubId);
+        const parent = segmentHub ?? rootHub;
+        if (!parent) {
+            return;
+        }
+        if (rootHub && parent.id !== rootHub.id) {
+            addEdge(createVisualEdge(rootHub, parent, 6, 'high'));
+        }
+        nodes.forEach((node) => {
+            if (node.id === parent.id || node.id === rootHub?.id) {
+                return;
+            }
+            addEdge(createVisualEdge(parent, node, 1, 'low'));
+        });
+    });
+    return Array.from(edges.values());
 };
 const distanceBetween = (left, right) => Math.hypot(right.x - left.x, right.y - left.y);
+const layoutBounds = (nodes) => {
+    if (nodes.length === 0) {
+        return { x: 0, y: 0, radius: 1 };
+    }
+    const bounds = nodes.reduce((current, node) => ({
+        minX: Math.min(current.minX, node.x),
+        maxX: Math.max(current.maxX, node.x),
+        minY: Math.min(current.minY, node.y),
+        maxY: Math.max(current.maxY, node.y)
+    }), {
+        minX: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        minY: Number.POSITIVE_INFINITY,
+        maxY: Number.NEGATIVE_INFINITY
+    });
+    const x = (bounds.minX + bounds.maxX) / 2;
+    const y = (bounds.minY + bounds.maxY) / 2;
+    const radius = nodes.reduce((largest, node) => Math.max(largest, Math.hypot(node.x - x, node.y - y)), 1);
+    return { x, y, radius: Math.max(radius + 72, 120) };
+};
+const edgeTouchesGroup = (edge, nodeIds) => nodeIds.has(edge.source) || Boolean(edge.target && nodeIds.has(edge.target));
+const edgeInsideGroup = (edge, nodeIds) => nodeIds.has(edge.source) && Boolean(edge.target && nodeIds.has(edge.target));
+const groupTitle = (segment, level, index, nodes) => nodes.length === 1
+    ? nodes[0]?.title ?? segment
+    : `${segment} ${level + 1}.${index + 1}`;
+const chunkNodes = (nodes, degrees, groupNodeLimit = hierarchyGroupNodeLimit) => {
+    const sortedNodes = [...nodes].sort((left, right) => {
+        const segmentDelta = left.segment.localeCompare(right.segment);
+        if (segmentDelta !== 0)
+            return segmentDelta;
+        const groupDelta = left.group.localeCompare(right.group);
+        if (groupDelta !== 0)
+            return groupDelta;
+        const degreeDelta = (degrees.get(right.id) ?? 0) - (degrees.get(left.id) ?? 0);
+        if (degreeDelta !== 0)
+            return degreeDelta;
+        return left.title.localeCompare(right.title);
+    });
+    const groupCountTarget = Math.min(groupNodeLimit, sortedNodes.length);
+    const chunkSize = sortedNodes.length <= groupNodeLimit * groupNodeLimit
+        ? Math.max(1, Math.ceil(sortedNodes.length / groupCountTarget))
+        : groupNodeLimit;
+    const chunks = [];
+    for (let index = 0; index < sortedNodes.length; index += chunkSize) {
+        chunks.push(sortedNodes.slice(index, index + chunkSize));
+    }
+    return chunks;
+};
+const groupEdges = (edges, nodeIds) => ({
+    internalEdges: edges.filter((edge) => edgeInsideGroup(edge, nodeIds)),
+    externalEdges: edges.filter((edge) => edgeTouchesGroup(edge, nodeIds) && !edgeInsideGroup(edge, nodeIds))
+});
+const groupBounds = (groups) => {
+    if (groups.length === 0) {
+        return { x: 0, y: 0, radius: 1 };
+    }
+    const nodes = groups.map((group) => ({
+        x: group.x,
+        y: group.y,
+        radius: group.radius
+    }));
+    const x = nodes.reduce((sum, node) => sum + node.x, 0) / nodes.length;
+    const y = nodes.reduce((sum, node) => sum + node.y, 0) / nodes.length;
+    const radius = nodes.reduce((largest, node) => Math.max(largest, Math.hypot(node.x - x, node.y - y) + node.radius), 1);
+    return { x, y, radius: Math.max(radius + 120, 180) };
+};
+const descendantNodeIds = (groups) => groups.flatMap((group) => group.nodeIds);
+const createParentGroups = (groups, edges, level, groupNodeLimit) => {
+    if (groups.length <= groupNodeLimit) {
+        return groups;
+    }
+    const parentGroups = [];
+    for (let index = 0; index < groups.length; index += groupNodeLimit) {
+        const chunk = groups.slice(index, index + groupNodeLimit);
+        const nodeIds = new Set(descendantNodeIds(chunk));
+        const bounds = groupBounds(chunk);
+        const segment = chunk[0]?.segment ?? 'root';
+        const group = chunk[0]?.group ?? 'root';
+        const groupIndex = index / groupNodeLimit;
+        const id = ['root', level, groupIndex, chunk[0]?.id ?? 'empty', chunk.length].join(':');
+        const edgeGroups = groupEdges(edges, nodeIds);
+        parentGroups.push({
+            id,
+            level,
+            parentId: null,
+            title: `${segment} ${level + 1}.${Math.floor(groupIndex) + 1}`,
+            segment,
+            group,
+            x: bounds.x,
+            y: bounds.y,
+            radius: bounds.radius,
+            nodeIds: [],
+            childGroupIds: chunk.map((child) => child.id),
+            internalEdges: edgeGroups.internalEdges,
+            externalEdges: edgeGroups.externalEdges
+        });
+    }
+    const relinkedChildren = groups.map((group) => {
+        const parent = parentGroups.find((candidate) => candidate.childGroupIds.includes(group.id));
+        return parent ? { ...group, parentId: parent.id } : group;
+    });
+    return [...createParentGroups(parentGroups, edges, level + 1, groupNodeLimit), ...relinkedChildren];
+};
+export const createGraphLayoutHierarchy = (nodes, edges, degrees, groupNodeLimit = hierarchyGroupNodeLimit) => {
+    if (nodes.length <= groupNodeLimit) {
+        return [];
+    }
+    const leafGroups = chunkNodes(nodes, degrees, groupNodeLimit).map((chunk, index) => {
+        const nodeIds = new Set(chunk.map((node) => node.id));
+        const bounds = layoutBounds(chunk);
+        const segment = chunk[0]?.segment ?? 'root';
+        const group = chunk[0]?.group ?? 'root';
+        const id = ['leaf', 0, index, chunk[0]?.id ?? 'empty', chunk.length].join(':');
+        return {
+            id,
+            level: 0,
+            parentId: null,
+            title: groupTitle(segment, 0, index, chunk),
+            segment,
+            group,
+            x: bounds.x,
+            y: bounds.y,
+            radius: bounds.radius,
+            nodeIds: chunk.map((node) => node.id),
+            childGroupIds: [],
+            ...groupEdges(edges, nodeIds)
+        };
+    });
+    return createParentGroups(leafGroups, edges, 1, groupNodeLimit);
+};
 const resolveCollisionPair = (left, right, minDistance) => {
     const dx = right.x - left.x;
     const dy = right.y - left.y;
@@ -157,8 +428,9 @@ const resolveCollisionPair = (left, right, minDistance) => {
         return;
     }
     const push = (minDistance - distance) / 2;
-    const ux = dx / distance;
-    const uy = dy / distance;
+    const fallbackAngle = Math.PI * 2 * (Math.abs(hashText(`${left.id}:${right.id}`) % 1000) / 1000);
+    const ux = Math.abs(dx) + Math.abs(dy) < 0.001 ? Math.cos(fallbackAngle) : dx / distance;
+    const uy = Math.abs(dx) + Math.abs(dy) < 0.001 ? Math.sin(fallbackAngle) : dy / distance;
     left.x -= ux * push;
     left.y -= uy * push;
     right.x += ux * push;
@@ -240,15 +512,114 @@ const relaxCollisions = (nodes, minDistance = 132, rounds = 32) => {
     }
     return layoutNodes;
 };
+const assignStarLevels = (nodes, edges, hubId) => {
+    if (!hubId) {
+        return new Map(nodes.map((node) => [node.id, 1]));
+    }
+    const adjacency = createAdjacency(nodes, edges);
+    const levels = new Map([[hubId, 0]]);
+    const queue = [hubId];
+    for (let index = 0; index < queue.length; index += 1) {
+        const id = queue[index];
+        const nextLevel = (levels.get(id) ?? 0) + 1;
+        (adjacency.get(id) ?? []).forEach((nextId) => {
+            if (!levels.has(nextId)) {
+                levels.set(nextId, nextLevel);
+                queue.push(nextId);
+            }
+        });
+    }
+    nodes.forEach((node) => {
+        if (!levels.has(node.id)) {
+            levels.set(node.id, 2);
+        }
+    });
+    return levels;
+};
+const createStarNodes = (nodes, segments, degrees, hubId, levels) => {
+    const segmentNames = Array.from(new Set(nodes.map((node) => segments.get(node.id) ?? groupLabel(groupKey(node)))))
+        .sort((left, right) => segmentAngle(left, 0, 1) - segmentAngle(right, 0, 1) || left.localeCompare(right));
+    const segmentIndexByName = new Map(segmentNames.map((segment, index) => [segment, index]));
+    const sortedNodes = [...nodes].sort(compareByStarOrder(levels, degrees, segmentIndexByName, segments));
+    const nodesByLevel = sortedNodes.reduce((state, node) => {
+        const level = node.id === hubId ? 0 : Math.max(1, levels.get(node.id) ?? 1);
+        const levelNodes = state.get(level) ?? [];
+        levelNodes.push(node);
+        state.set(level, levelNodes);
+        return state;
+    }, new Map());
+    return Array.from(nodesByLevel.entries())
+        .sort(([left], [right]) => left - right)
+        .flatMap(([level, levelNodes]) => {
+        if (level === 0) {
+            return levelNodes.map((node) => ({
+                ...node,
+                group: groupLabel(groupKey(node)),
+                segment: segments.get(node.id) ?? groupLabel(groupKey(node)),
+                x: 0,
+                y: 0
+            }));
+        }
+        const levelNodesBySegment = segmentNames
+            .map((segment) => ({
+            segment,
+            nodes: levelNodes.filter((node) => (segments.get(node.id) ?? groupLabel(groupKey(node))) === segment)
+        }))
+            .filter((group) => group.nodes.length > 0);
+        const totalNodes = levelNodesBySegment.reduce((total, group) => total + group.nodes.length, 0);
+        const baseRadius = Math.max(360 + (level - 1) * 460, (levelNodes.length * 156) / (Math.PI * 2));
+        let arcCursor = -Math.PI / 2;
+        return levelNodesBySegment.flatMap((group) => {
+            const arcSize = (Math.PI * 2 * group.nodes.length) / Math.max(totalNodes, 1);
+            const arcPadding = Math.min(0.22, arcSize * 0.18);
+            const arcStart = arcCursor + arcPadding;
+            const arcEnd = arcCursor + arcSize - arcPadding;
+            const usableArc = Math.max(0.001, arcEnd - arcStart);
+            const segmentRadius = Math.max(baseRadius, (group.nodes.length * 156) / usableArc);
+            arcCursor += arcSize;
+            return group.nodes.map((node, index) => {
+                const lane = index % 3 - 1;
+                const angle = arcStart + usableArc * ((index + 0.5) / Math.max(group.nodes.length, 1)) + jitter(node.title, 0.035);
+                const radialJitter = jitter(node.id, 34);
+                return {
+                    ...node,
+                    group: groupLabel(groupKey(node)),
+                    segment: group.segment,
+                    x: Math.cos(angle) * (segmentRadius + lane * 52 + radialJitter) + jitter(node.title, 16),
+                    y: Math.sin(angle) * (segmentRadius + lane * 52 + radialJitter) + jitter(node.path, 16)
+                };
+            });
+        });
+    });
+};
+export const createStarGraphLayout = (graph) => {
+    const degrees = countDegrees(graph.edges);
+    const hubId = selectPrimaryHubId(graph.nodes, degrees) ?? selectHighestDegreeNodeId(graph.nodes, degrees);
+    const segments = assignSegments(graph.nodes, graph.edges, degrees);
+    const levels = assignStarLevels(graph.nodes, graph.edges, hubId);
+    const nodes = relaxCollisions(createStarNodes(graph.nodes, segments, degrees, hubId, levels), 156, 22);
+    const centeredNodes = centerLayoutByNode(nodes, hubId);
+    const groups = createGraphLayoutHierarchy(centeredNodes, graph.edges, degrees);
+    return {
+        nodes: centeredNodes,
+        edges: graph.edges,
+        ...(groups.length > 0 ? { groups } : {})
+    };
+};
 export const createCauliflowerGraphLayout = (graph) => {
     const degrees = countDegrees(graph.edges);
     const segments = assignSegments(graph.nodes, graph.edges, degrees);
     const segmentGroups = Array.from(groupNodesBySegment(graph.nodes, segments).entries())
         .sort(([left], [right]) => left.localeCompare(right));
-    const nodes = relaxCollisions(segmentGroups.flatMap(createSegmentNodes(segments, degrees, segmentGroups.length)));
+    const rootHubId = selectPrimaryHubId(graph.nodes, degrees) ?? selectHighestDegreeNodeId(graph.nodes, degrees);
+    const nodes = relaxCollisions(segmentGroups.flatMap(createCauliflowerSegmentNodes(segments, degrees, rootHubId, segmentGroups)), 156, 28);
+    const centeredNodes = centerLayoutByNode(nodes, rootHubId);
+    const visualEdges = createCauliflowerVisualEdges(segmentGroups, degrees, rootHubId);
+    const groups = createGraphLayoutHierarchy(centeredNodes, visualEdges, degrees);
     return {
-        nodes,
-        edges: graph.edges
+        nodes: centeredNodes,
+        edges: visualEdges,
+        ...(groups.length > 0 ? { groups } : {})
     };
 };
 export const getMinimumLayoutDistance = (nodes) => nodes.reduce((minimumDistance, leftNode, leftIndex) => nodes.slice(leftIndex + 1).reduce((innerMinimum, rightNode) => Math.min(innerMinimum, distanceBetween(leftNode, rightNode)), minimumDistance), Number.POSITIVE_INFINITY);

package/dist/domain/markdown.js

@@ -6,6 +6,7 @@ const frontmatterPattern = /^---\n([\s\S]*?)\n---\n?/;
 const wikiLinkPattern = /\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]/g;
 const tagPattern = /(^|\s)#([A-Za-z0-9][A-Za-z0-9_-]*)/g;
 const headingPattern = /^#\s+(.+)$/m;
+const contextLinksHeadingPattern = /^(#{1,6})\s+(?:context\s+links?|links?\s+de\s+contexto)\b/i;
 const priorityRanks = {
     low: 0,
     normal: 1,
@@ -18,6 +19,7 @@ const priorityBoosts = {
     high: 3,
     critical: 6
 };
+export const graphLinkModelVersion = 4;
 const priorityPatterns = [
     ['critical', /\b(?:priority|prioridade|importance|importancia|importância)\s*[:=]\s*(?:critical|critica|crítica|urgent|urgente|p0)\b/i],
     ['critical', /#(?:critical|critica|crítica|urgent|urgente|p0)\b/i],
@@ -100,6 +102,47 @@ export const extractWikiLinkWeights = (content) => {
     }, new Map());
     return Array.from(weights.values());
 };
+const compareGraphLinks = (left, right) => {
+    const priorityDelta = priorityRanks[right.priority] - priorityRanks[left.priority];
+    if (priorityDelta !== 0)
+        return priorityDelta;
+    const weightDelta = right.weight - left.weight;
+    if (weightDelta !== 0)
+        return weightDelta;
+    return left.title.localeCompare(right.title);
+};
+export const selectGraphWikiLinkWeights = (links) => {
+    return [...links].sort(compareGraphLinks);
+};
+const contextLinkLines = (content) => {
+    const lines = visibleMarkdownLines(content);
+    const selected = [];
+    let insideContextLinks = false;
+    let headingDepth = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.content.trim();
+        if (line.fenced) {
+            continue;
+        }
+        const heading = trimmed.match(/^(#{1,6})\s+/);
+        const contextHeading = trimmed.match(contextLinksHeadingPattern);
+        if (contextHeading) {
+            insideContextLinks = true;
+            headingDepth = contextHeading[1].length;
+            continue;
+        }
+        if (insideContextLinks && heading && heading[1].length <= headingDepth) {
+            insideContextLinks = false;
+        }
+        if (insideContextLinks) {
+            selected.push(line.content);
+        }
+    }
+    return selected;
+};
+export const hasContextLinksSection = (content) => visibleMarkdownLines(content).some((line) => !line.fenced && contextLinksHeadingPattern.test(line.content.trim()));
+export const extractContextLinkWeights = (content) => selectGraphWikiLinkWeights(extractWikiLinkWeights(contextLinkLines(content).join('\n')));
 const extractTitle = (filePath, content, frontmatter) => {
     if (frontmatter.title) {
         return normalizeTitle(frontmatter.title);
@@ -184,6 +227,7 @@ export const parseMarkdownDocument = (input) => {
         content: input.content,
         tags: extractTags(input.content),
         links: extractWikiLinks(input.content),
+        contextLinks: extractContextLinkWeights(input.content).map((link) => link.title),
         frontmatter,
         createdAt: input.createdAt.toISOString(),
         updatedAt: input.updatedAt.toISOString()
@@ -191,16 +235,16 @@ export const parseMarkdownDocument = (input) => {
 };
 export const createIndexedDocument = (document, titleToDocumentId, maxChunkCharacters = 1200) => {
     const chunks = splitIntoChunks(document.id, document.content, maxChunkCharacters);
-    const linkWeights = new Map(extractWikiLinkWeights(document.content).map((link) => [link.title.toLowerCase(), link]));
-    const links = document.links
-        .map((toTitle) => ({
+    const graphLinkWeights = selectGraphWikiLinkWeights(extractContextLinkWeights(document.content).filter((link) => link.title.toLowerCase() !== document.title.toLowerCase()));
+    const linkWeights = new Map(graphLinkWeights.map((link) => [link.title.toLowerCase(), link]));
+    const links = graphLinkWeights
+        .map((link) => ({
         fromDocumentId: document.id,
-        toTitle,
-        toDocumentId: titleToDocumentId.get(toTitle.toLowerCase()) ?? null,
-        weight: linkWeights.get(toTitle.toLowerCase())?.weight ?? 1,
-        priority: linkWeights.get(toTitle.toLowerCase())?.priority ?? 'normal'
-    }))
-        .filter((link) => link.toDocumentId !== document.id);
+        toTitle: link.title,
+        toDocumentId: titleToDocumentId.get(link.title.toLowerCase()) ?? null,
+        weight: linkWeights.get(link.title.toLowerCase())?.weight ?? 1,
+        priority: linkWeights.get(link.title.toLowerCase())?.priority ?? 'normal'
+    }));
     return {
         document,
         chunks,

package/dist/domain/middle-out.js

@@ -0,0 +1,18 @@
+export const middleOutIndices = (size, pivotIndex) => {
+    if (!Number.isFinite(size) || size <= 0) {
+        return [];
+    }
+    const clampedPivot = Math.max(0, Math.min(Math.floor(pivotIndex), size - 1));
+    const indices = [clampedPivot];
+    for (let offset = 1; indices.length < size; offset += 1) {
+        const left = clampedPivot - offset;
+        const right = clampedPivot + offset;
+        if (left >= 0) {
+            indices.push(left);
+        }
+        if (right < size) {
+            indices.push(right);
+        }
+    }
+    return indices;
+};