@andespindola/brainlink 0.1.0-beta.13 → 0.1.0-beta.130

package/dist/domain/context.js

@@ -1,13 +1,50 @@
+import { middleOutIndices } from './middle-out.js';
+const maxSectionsPerDocument = 3;
+const byScore = (left, right) => right.score - left.score || left.title.localeCompare(right.title);
+const byOrdinal = (left, right) => (left.chunkOrdinal ?? Number.MAX_SAFE_INTEGER) - (right.chunkOrdinal ?? Number.MAX_SAFE_INTEGER);
+const middleOutDocumentResults = (results) => {
+    if (results.length <= 1) {
+        return results;
+    }
+    const sortedByOrdinal = [...results].sort(byOrdinal);
+    const pivotChunkId = [...results].sort(byScore)[0]?.chunkId;
+    const pivotIndex = sortedByOrdinal.findIndex((result) => result.chunkId === pivotChunkId);
+    if (pivotIndex < 0) {
+        return [...results].sort(byScore);
+    }
+    return middleOutIndices(sortedByOrdinal.length, pivotIndex).map((index) => sortedByOrdinal[index]);
+};
 export const selectContextSections = (results, maxTokens) => {
-    const selected = results.reduce((state, result) => {
-        const tokenCost = Math.ceil(result.content.length / 4);
-        if (state.usedTokens + tokenCost > maxTokens || state.seenDocuments.has(result.documentId)) {
-            return state;
+    const grouped = results.reduce((state, result) => {
+        const current = state.get(result.documentId) ?? [];
+        state.set(result.documentId, [...current, result]);
+        return state;
+    }, new Map());
+    const documentOrder = Array.from(results.reduce((state, result) => {
+        if (!state.has(result.documentId)) {
+            state.set(result.documentId, result.score);
         }
-        return {
-            usedTokens: state.usedTokens + tokenCost,
-            sections: [
-                ...state.sections,
+        return state;
+    }, new Map()).entries())
+        .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+        .map(([documentId]) => documentId);
+    const selected = documentOrder.reduce((state, documentId) => {
+        const ordered = middleOutDocumentResults(grouped.get(documentId) ?? []);
+        let usedTokens = state.usedTokens;
+        let sections = state.sections;
+        let seenChunks = state.seenChunks;
+        for (let index = 0; index < ordered.length && index < maxSectionsPerDocument; index += 1) {
+            const result = ordered[index];
+            if (seenChunks.has(result.chunkId)) {
+                continue;
+            }
+            const tokenCost = Math.ceil(result.content.length / 4);
+            if (usedTokens + tokenCost > maxTokens) {
+                break;
+            }
+            usedTokens += tokenCost;
+            sections = [
+                ...sections,
                 {
                     title: result.title,
                     path: result.path,
@@ -16,13 +53,18 @@ export const selectContextSections = (results, maxTokens) => {
                     searchMode: result.searchMode,
                     tags: result.tags
                 }
-            ],
-            seenDocuments: new Set([...state.seenDocuments, result.documentId])
+            ];
+            seenChunks = new Set([...seenChunks, result.chunkId]);
+        }
+        return {
+            usedTokens,
+            sections,
+            seenChunks
         };
     }, {
         usedTokens: 0,
         sections: [],
-        seenDocuments: new Set()
+        seenChunks: new Set()
     });
     return selected.sections;
 };
@@ -34,6 +76,7 @@ export const formatContextPackage = (query, sections) => {
         section.tags.length > 0 ? `Tags: ${section.tags.map((tag) => `#${tag}`).join(' ')}` : null,
         `Score: ${section.score.toFixed(3)}`,
         `Mode: ${section.searchMode}`,
+        section.volatile ? `Volatile: true${section.expiresAt ? `, expires ${section.expiresAt}` : ''}` : null,
         '',
         section.content
     ]

package/dist/domain/graph-layout.js

@@ -1,3 +1,4 @@
+const hierarchyGroupNodeLimit = 1000;
 const groupLabels = {
     '00-maps': 'maps',
     '10-agent-memory': 'agent-memory',
@@ -20,6 +21,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 +64,44 @@ 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 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) => {
@@ -128,13 +168,17 @@ 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 petalSpreadForSegmentSize = (size) => {
+    const safeSize = Math.max(size, 1);
+    return 180 + Math.log2(safeSize + 1) * 6;
+};
 const createSegmentNodes = (segments, degrees, segmentCount) => ([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;
+    const petalSpread = petalSpreadForSegmentSize(sortedNodes.length);
     return sortedNodes.map((node, index) => {
         const localAngle = index * 2.399963 + jitter(node.title, 0.42);
         const localRadius = Math.sqrt(index + 1) * petalSpread;
@@ -149,6 +193,136 @@ const createSegmentNodes = (segments, degrees, segmentCount) => ([segment, nodes
     });
 };
 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;
@@ -246,9 +420,13 @@ export const createCauliflowerGraphLayout = (graph) => {
     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 primaryHubId = selectPrimaryHubId(graph.nodes, degrees);
+    const centeredNodes = centerLayoutByNode(nodes, primaryHubId);
+    const groups = createGraphLayoutHierarchy(centeredNodes, graph.edges, degrees);
     return {
-        nodes,
-        edges: graph.edges
+        nodes: centeredNodes,
+        edges: graph.edges,
+        ...(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

@@ -18,6 +18,9 @@ const priorityBoosts = {
     high: 3,
     critical: 6
 };
+const graphLinkLimit = 4;
+export const graphLinkModelVersion = 2;
+const hubLinkTitlePattern = /\b(?:memory\s*hub|knowledge\s*root|moc|map)\b/i;
 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],
@@ -31,6 +34,7 @@ const priorityPatterns = [
 const normalizeTitle = (title) => title.trim().replace(/\.md$/i, '');
 const unique = (values) => Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
 const maxPriority = (left, right) => priorityRanks[left] >= priorityRanks[right] ? left : right;
+const isHubLinkTitle = (title) => hubLinkTitlePattern.test(title);
 const parseFrontmatter = (content) => {
     const match = content.match(frontmatterPattern);
     if (!match) {
@@ -100,6 +104,22 @@ 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) => {
+    const sorted = [...links].sort(compareGraphLinks);
+    const structuralLinks = sorted.filter((link) => isHubLinkTitle(link.title) && !['high', 'critical'].includes(link.priority));
+    const directLinks = sorted.filter((link) => !structuralLinks.includes(link));
+    const selected = (directLinks.length > 0 ? directLinks : sorted).slice(0, graphLinkLimit);
+    return selected.length > 0 ? selected : structuralLinks.slice(0, graphLinkLimit);
+};
 const extractTitle = (filePath, content, frontmatter) => {
     if (frontmatter.title) {
         return normalizeTitle(frontmatter.title);
@@ -191,16 +211,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(extractWikiLinkWeights(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;
+};

package/dist/infrastructure/config.js

@@ -15,6 +15,13 @@ export const defaultBrainlinkConfig = {
     embeddingProvider: 'local',
     defaultSearchMode: 'hybrid',
     chunkSize: 1200,
+    searchPack: {
+        rowChunkSize: 5_000,
+        compressionLevel: 5,
+        useDictionary: true,
+        guardrailMinSavingsPercent: 8,
+        guardrailMaxLatencyRegressionPercent: 5
+    },
     agentProfiles: {}
 };
 const configFilenames = ['brainlink.config.json', '.brainlink.json'];
@@ -37,6 +44,36 @@ const sanitizeEmbeddingProvider = (value) => typeof value === 'string' && embedd
 export const sanitizeSearchMode = (value, fallback = defaultBrainlinkConfig.defaultSearchMode) => typeof value === 'string' && searchModes.has(value) ? value : fallback;
 const sanitizeAllowedVaults = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.trim().length > 0) : [];
 const sanitizePositiveNumber = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+const sanitizeIntegerInRange = (value, fallback, minimum, maximum) => {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    const rounded = Math.round(value);
+    if (rounded < minimum) {
+        return minimum;
+    }
+    if (rounded > maximum) {
+        return maximum;
+    }
+    return rounded;
+};
+const sanitizeSearchPackConfig = (value) => {
+    const fallback = defaultBrainlinkConfig.searchPack;
+    if (!isRecord(value)) {
+        return fallback;
+    }
+    return {
+        rowChunkSize: sanitizeIntegerInRange(value.rowChunkSize, fallback.rowChunkSize, 100, 100_000),
+        compressionLevel: sanitizeIntegerInRange(value.compressionLevel, fallback.compressionLevel, 0, 11),
+        useDictionary: typeof value.useDictionary === 'boolean' ? value.useDictionary : fallback.useDictionary,
+        guardrailMinSavingsPercent: typeof value.guardrailMinSavingsPercent === 'number' && Number.isFinite(value.guardrailMinSavingsPercent)
+            ? Math.max(0, Math.min(95, value.guardrailMinSavingsPercent))
+            : fallback.guardrailMinSavingsPercent,
+        guardrailMaxLatencyRegressionPercent: typeof value.guardrailMaxLatencyRegressionPercent === 'number' && Number.isFinite(value.guardrailMaxLatencyRegressionPercent)
+            ? Math.max(0, Math.min(300, value.guardrailMaxLatencyRegressionPercent))
+            : fallback.guardrailMaxLatencyRegressionPercent
+    };
+};
 const sanitizeAgentProfile = (value) => {
     if (!isRecord(value)) {
         return null;
@@ -130,6 +167,7 @@ const sanitizeConfig = (value) => ({
         : defaultBrainlinkConfig.defaultContextTokens,
     allowedVaults: [...sanitizeAllowedVaults(value.allowedVaults), ...readAllowedVaultsFromEnv()],
     chunkSize: typeof value.chunkSize === 'number' && value.chunkSize > 0 ? value.chunkSize : defaultBrainlinkConfig.chunkSize,
+    searchPack: sanitizeSearchPackConfig(value.searchPack),
     embeddingProvider: sanitizeEmbeddingProvider(value.embeddingProvider),
     defaultSearchMode: sanitizeSearchMode(value.defaultSearchMode),
     agentProfiles: sanitizeAgentProfiles(value.agentProfiles)