@andespindola/brainlink 1.0.5 → 1.0.6

package/dist/domain/graph-layout.js

@@ -1,625 +1,4 @@
-import { inferExplicitVisualGraphContext } from './graph-contexts.js';
-const hierarchyGroupNodeLimit = 1000;
-const groupLabels = {
-    '00-maps': 'maps',
-    '10-agent-memory': 'agent-memory',
-    '20-concepts': 'concepts',
-    '30-architecture': 'architecture',
-    '40-agents': 'agents',
-    '50-retrieval': 'retrieval',
-    '60-operations': 'operations',
-    '70-evaluation': 'evaluation',
-    '80-sessions': 'sessions',
-    '90-security': 'security',
-    root: 'root'
-};
-const segmentAngles = {
-    Brainlink: -1.58,
-    Architecture: -0.74,
-    Agents: -0.05,
-    Retrieval: 0.68,
-    Operations: 1.34,
-    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;
-    return (normalized - 0.5) * range;
-};
-const pathSegments = (path) => path.split('/').filter(Boolean);
-const groupKey = (node) => {
-    const segments = pathSegments(node.path);
-    if (segments[0] === 'agents') {
-        return segments[2] ?? 'root';
-    }
-    return segments[0] ?? 'root';
-};
-const groupLabel = (key) => groupLabels[key] ?? key;
-const incrementDegreeBy = (degrees, id, amount) => {
-    degrees.set(id, (degrees.get(id) ?? 0) + amount);
-    return degrees;
-};
-const edgeDegreeWeight = (edge) => Math.max(1, Math.min(edge.weight, 8));
-const countDegrees = (edges) => edges.reduce((degrees, edge) => {
-    const weight = edgeDegreeWeight(edge);
-    return edge.target
-        ? incrementDegreeBy(incrementDegreeBy(degrees, edge.source, weight), edge.target, weight)
-        : incrementDegreeBy(degrees, edge.source, weight);
-}, new Map());
-const createAdjacency = (nodes, edges) => {
-    const nodeIds = new Set(nodes.map((node) => node.id));
-    const adjacency = new Map(nodes.map((node) => [node.id, new Set()]));
-    edges.forEach((edge) => {
-        if (!edge.target || !nodeIds.has(edge.source) || !nodeIds.has(edge.target)) {
-            return;
-        }
-        adjacency.get(edge.source)?.add(edge.target);
-        adjacency.get(edge.target)?.add(edge.source);
-    });
-    return new Map(Array.from(adjacency.entries(), ([id, neighbors]) => [id, Array.from(neighbors)]));
-};
-const byTitle = (left, right) => left.title.localeCompare(right.title);
-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) => {
-    const queue = [startId];
-    const component = [];
-    visited.add(startId);
-    for (let index = 0; index < queue.length; index += 1) {
-        const id = queue[index];
-        component.push(id);
-        (adjacency.get(id) ?? []).forEach((nextId) => {
-            if (!visited.has(nextId)) {
-                visited.add(nextId);
-                queue.push(nextId);
-            }
-        });
-    }
-    return component;
-};
-const connectedComponents = (nodes, adjacency) => {
-    const visited = new Set();
-    return [...nodes].sort(byTitle).reduce((components, node) => (visited.has(node.id) ? components : [...components, collectComponent(adjacency, node.id, visited)]), []);
-};
-const selectSegmentSeeds = (nodes, edges, degrees) => {
-    const adjacency = createAdjacency(nodes, edges);
-    const nodeById = new Map(nodes.map((node) => [node.id, node]));
-    return connectedComponents(nodes, adjacency).flatMap((component) => {
-        const componentNodes = component.map((id) => nodeById.get(id)).filter((node) => Boolean(node));
-        const naturalSeeds = componentNodes.filter(naturalSegmentSeed).sort(byDegreeThenTitle(degrees));
-        return naturalSeeds.length > 0 ? naturalSeeds : componentNodes.sort(byDegreeThenTitle(degrees)).slice(0, 1);
-    });
-};
-const assignSegments = (nodes, edges, degrees) => {
-    const adjacency = createAdjacency(nodes, edges);
-    const seeds = selectSegmentSeeds(nodes, edges, degrees);
-    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);
-        if (!segment) {
-            continue;
-        }
-        ;
-        (adjacency.get(id) ?? []).forEach((nextId) => {
-            if (!assignments.has(nextId)) {
-                assignments.set(nextId, segment);
-                queue.push(nextId);
-            }
-        });
-    }
-    return new Map(nodes.map((node) => [node.id, assignments.get(node.id) ?? groupLabel(groupKey(node))]));
-};
-const groupNodesBySegment = (nodes, segments) => {
-    const groups = new Map();
-    nodes.forEach((node) => {
-        const segment = segments.get(node.id) ?? groupLabel(groupKey(node));
-        const bucket = groups.get(segment);
-        if (bucket) {
-            bucket.push(node);
-            return;
-        }
-        groups.set(segment, [node]);
-    });
-    return new Map(groups);
-};
-const segmentAngle = (segment, index, count) => segmentAngles[segment] ?? (Math.PI * 2 * index) / Math.max(count, 1) - Math.PI / 2;
-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 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) * 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;
-    const distance = Math.max(Math.hypot(dx, dy), 0.001);
-    if (distance >= minDistance) {
-        return;
-    }
-    const push = (minDistance - distance) / 2;
-    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;
-    right.y += uy * push;
-};
-const buildCollisionGrid = (nodes, cellSize) => {
-    const grid = new Map();
-    nodes.forEach((node, index) => {
-        const x = Math.floor(node.x / cellSize);
-        const y = Math.floor(node.y / cellSize);
-        const key = `${x},${y}`;
-        const bucket = grid.get(key);
-        if (bucket) {
-            bucket.push(index);
-            return;
-        }
-        grid.set(key, [index]);
-    });
-    return grid;
-};
-const neighborCellKeys = (x, y) => [
-    `${x - 1},${y - 1}`,
-    `${x},${y - 1}`,
-    `${x + 1},${y - 1}`,
-    `${x - 1},${y}`,
-    `${x},${y}`,
-    `${x + 1},${y}`,
-    `${x - 1},${y + 1}`,
-    `${x},${y + 1}`,
-    `${x + 1},${y + 1}`
-];
-const resolveCollisionsSpatial = (nodes, minDistance) => {
-    const gridCellSize = minDistance * 1.05;
-    const grid = buildCollisionGrid(nodes, gridCellSize);
-    for (let index = 0; index < nodes.length; index += 1) {
-        const left = nodes[index];
-        const leftCellX = Math.floor(left.x / gridCellSize);
-        const leftCellY = Math.floor(left.y / gridCellSize);
-        neighborCellKeys(leftCellX, leftCellY).forEach((key) => {
-            const candidateIndices = grid.get(key) ?? [];
-            candidateIndices.forEach((candidateIndex) => {
-                if (candidateIndex <= index) {
-                    return;
-                }
-                resolveCollisionPair(left, nodes[candidateIndex], minDistance);
-            });
-        });
-    }
-};
-const resolveCollisionsBrute = (nodes, minDistance) => {
-    for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
-        const left = nodes[leftIndex];
-        for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
-            resolveCollisionPair(left, nodes[rightIndex], minDistance);
-        }
-    }
-};
-const relaxCollisions = (nodes, minDistance = 132, rounds = 32) => {
-    if (nodes.length <= 1) {
-        return nodes;
-    }
-    const effectiveRounds = nodes.length > 1000
-        ? Math.min(rounds, 12)
-        : nodes.length > 500
-            ? Math.min(rounds, 20)
-            : Math.min(rounds, 26);
-    const layoutNodes = nodes.map((node) => ({
-        ...node,
-        x: Number.isFinite(node.x) ? node.x : 0,
-        y: Number.isFinite(node.y) ? node.y : 0
-    }));
-    for (let round = 0; round < effectiveRounds; round += 1) {
-        if (nodes.length <= 250) {
-            resolveCollisionsBrute(layoutNodes, minDistance);
-        }
-        else {
-            resolveCollisionsSpatial(layoutNodes, minDistance);
-        }
-    }
-    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 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: 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);
+export { createGraphLayoutHierarchy } from './graph-layout/hierarchy.js';
+export { createStarGraphLayout } from './graph-layout/star-layout.js';
+export { createCauliflowerGraphLayout } from './graph-layout/cauliflower-layout.js';
+export { getMinimumLayoutDistance } from './graph-layout/metrics.js';

package/dist/infrastructure/config.js

@@ -11,6 +11,8 @@ export const defaultBrainlinkConfig = {
     defaultAgent: undefined,
     autoIndexOnWrite: true,
     autoCanonicalContextLinks: true,
+    autoUpdateCheck: true,
+    updateCheckIntervalMs: 86_400_000,
     defaultSearchLimit: 8,
     defaultContextTokens: 1500,
     defaultContextStrategy: 'auto',
@@ -177,6 +179,10 @@ const sanitizeConfig = (value) => ({
     autoCanonicalContextLinks: typeof value.autoCanonicalContextLinks === 'boolean'
         ? value.autoCanonicalContextLinks
         : defaultBrainlinkConfig.autoCanonicalContextLinks,
+    autoUpdateCheck: typeof value.autoUpdateCheck === 'boolean' ? value.autoUpdateCheck : defaultBrainlinkConfig.autoUpdateCheck,
+    updateCheckIntervalMs: typeof value.updateCheckIntervalMs === 'number' && Number.isFinite(value.updateCheckIntervalMs) && value.updateCheckIntervalMs > 0
+        ? Math.floor(value.updateCheckIntervalMs)
+        : defaultBrainlinkConfig.updateCheckIntervalMs,
     defaultSearchLimit: typeof value.defaultSearchLimit === 'number' && value.defaultSearchLimit > 0
         ? value.defaultSearchLimit
         : defaultBrainlinkConfig.defaultSearchLimit,

package/dist/infrastructure/file-index.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { cosineSimilarity } from '../domain/embeddings.js';
+import { createEmbeddingBuckets, dotProduct } from '../domain/embeddings.js';
+import { selectSemanticCandidates } from './semantic-prefilter.js';
 const queryTokenPattern = /[\p{L}\p{N}_-]+/gu;
 const indexCacheMaxEntries = 16;
 const indexCache = new Map();
@@ -106,7 +107,7 @@ const textScore = (row, tokens) => {
         return score + titleHits * 5 + tagHits * 4 + pathHits * 2 + Math.min(contentHits, 6);
     }, 0);
 };
-const semanticScore = (row, queryEmbedding) => queryEmbedding.length > 0 && row.embedding.length > 0 ? cosineSimilarity(queryEmbedding, row.embedding) : 0;
+const semanticScore = (row, queryEmbedding) => queryEmbedding.length > 0 && row.embedding.length > 0 ? dotProduct(queryEmbedding, row.embedding) : 0;
 const toResult = (row, mode, text, semantic) => {
     const score = mode === 'fts' ? text : mode === 'semantic' ? semantic : text + semantic * 8;
     return {
@@ -206,12 +207,20 @@ export const openFileIndex = (vaultPath) => {
                         chunkOrdinal: chunk.ordinal,
                         content: chunk.content,
                         tags: document.tags,
-                        embedding: chunk.embedding
+                        embedding: chunk.embedding,
+                        buckets: chunk.buckets
                     }
                 ];
             });
             const tokens = tokenize(query);
-            const results = rows
+            // Pure-semantic scoring on a large vault can skip chunks that share no
+            // embedding bucket with the query. Hybrid/fts keep every row so lexical
+            // matches are never dropped; the prefilter also falls back to a full scan
+            // on small or partially-indexed vaults.
+            const scored = mode === 'semantic' && queryEmbedding.length > 0
+                ? selectSemanticCandidates(rows, createEmbeddingBuckets(queryEmbedding), limit)
+                : rows;
+            const results = scored
                 .map((row) => {
                 const text = textScore(row, tokens);
                 const semantic = semanticScore(row, queryEmbedding);