@andespindola/brainlink 0.1.0-beta.47 → 0.1.0-beta.49

package/README.md

@@ -82,8 +82,9 @@ Legacy `.jsonl.gz` packs are upgraded to `.blpk` automatically on first search/c
 - Local HTTP API.
 - Realtime graph UI with agent selector and colored knowledge groups.
 - Graph renderer optimized for large datasets with viewport-driven node culling and edge lookup by visible nodes.
-- Large graph layout API automatically uses compact payload encoding and edge-cap transmission to reduce initial client load on very large vaults.
+- Large graph layout API automatically uses compact payload encoding with link-coverage-aware edge selection to reduce initial client load without hiding major relationships.
 - Zoomed-out graph LOD now clusters dense regions and progressively expands nodes as zoom increases.
+- Graph reset starts in macro "galaxy" overview mode and progressively reveals nearby nodes as zoom increases, including smaller vaults.
 - Graph filtering runs in a dedicated browser worker to keep the UI thread responsive during heavy datasets.
 - Edge rendering budgets adapt to zoom level to prevent frame spikes on large graph panoramas.
 

package/dist/application/frontend/client-js.js

@@ -2,11 +2,14 @@ export const createClientJs = () => `const canvas = document.getElementById('gra
 const ctx = canvas.getContext('2d')
 const largeGraphNodeThreshold = 4000
 const massiveGraphNodeThreshold = 20000
-const largeGraphEdgeRenderLimit = 16000
+const largeGraphEdgeRenderLimit = 120000
 const renderNodeBudget = 900
 const renderEdgeBudget = 2400
 const clusterActivationNodeThreshold = 600
 const clusterZoomThreshold = 0.18
+const macroGalaxyZoomThreshold = 0.012
+const massiveAutoFitMacroScale = 0.006
+const defaultMacroScale = 0.006
 const clusterCellPixelSize = 64
 const minNodePixelRadius = 2.3
 const viewportPaddingPx = 280
@@ -45,6 +48,8 @@ const state = {
   visibleNodeSpatial: { cellSize: 220, minX: 0, minY: 0, maxX: 0, maxY: 0, buckets: new Map() },
   visibleEdgeByNode: new Map(),
   overviewClusters: [],
+  macroCenter: { x: 0, y: 0 },
+  macroRepresentative: null,
   filterWorker: null,
   filterReady: false,
   lastHoverHitAt: 0
@@ -245,6 +250,26 @@ const filteredNodes = () => {
   return withPersistentHubNodes(localFilteredNodes(query))
 }
 
+const resolveMacroRepresentative = (nodes) => {
+  if (nodes.length === 0) {
+    return null
+  }
+
+  let best = nodes[0]
+  let bestDegree = state.nodeDegrees.get(best.id) ?? 0
+
+  for (let index = 1; index < nodes.length; index += 1) {
+    const node = nodes[index]
+    const degree = state.nodeDegrees.get(node.id) ?? 0
+    if (degree > bestDegree) {
+      best = node
+      bestDegree = degree
+    }
+  }
+
+  return best
+}
+
 const recomputeVisibility = () => {
   const nodes = filteredNodes()
   const ids = new Set(nodes.map(node => node.id))
@@ -260,6 +285,14 @@ const recomputeVisibility = () => {
   state.visibleNodeSpatial = createSpatialIndex(nodes)
   state.visibleEdgeByNode = createVisibleEdgeLookup(limitedEdges)
   state.overviewClusters = nodes.length > massiveGraphNodeThreshold ? buildOverviewClusters(nodes) : []
+  const bounds = graphBounds(nodes)
+  state.macroCenter = bounds
+    ? {
+      x: (bounds.minX + bounds.maxX) / 2,
+      y: (bounds.minY + bounds.maxY) / 2
+    }
+    : { x: 0, y: 0 }
+  state.macroRepresentative = resolveMacroRepresentative(nodes)
   markRenderDirty()
 }
 
@@ -577,7 +610,7 @@ const autoFitScaleRangeByNodeCount = nodeCount => {
   return { min: 0.0008, max: 0.24 }
 }
 
-const fitView = (options = { useFiltered: true }) => {
+const fitView = (options = { useFiltered: true, macro: false }) => {
   const rect = canvas.getBoundingClientRect()
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
@@ -607,7 +640,13 @@ const fitView = (options = { useFiltered: true }) => {
   const fitScale = Math.min(scaleX, scaleY)
   const biasedScale = clampScale(fitScale * fitScaleBiasByNodeCount(nodes.length))
   const scaleRange = autoFitScaleRangeByNodeCount(nodes.length)
-  const scale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
+  const baselineScale = clampScale(Math.min(scaleRange.max, Math.max(scaleRange.min, biasedScale)))
+  const macroScale = nodes.length > massiveGraphNodeThreshold ? massiveAutoFitMacroScale : defaultMacroScale
+  const scale = options.macro && nodes.length > 1
+    ? clampScale(Math.min(baselineScale, macroScale))
+    : nodes.length > massiveGraphNodeThreshold
+      ? clampScale(Math.min(baselineScale, massiveAutoFitMacroScale))
+      : baselineScale
   const centerX = (bounds.minX + bounds.maxX) / 2
   const centerY = (bounds.minY + bounds.maxY) / 2
 
@@ -621,7 +660,7 @@ const fitView = (options = { useFiltered: true }) => {
   markRenderDirty()
 }
 
-const resetView = () => fitView({ useFiltered: false })
+const resetView = () => fitView({ useFiltered: false, macro: true })
 
 const createLayout = graph => {
   const nodeRows = Array.isArray(graph.nodes) ? graph.nodes : []
@@ -970,6 +1009,32 @@ const computeRenderVisibility = () => {
   state.lastViewportKey = viewportKey
   state.renderVisibilityDirty = false
 
+  const shouldRenderMacroGalaxy =
+    state.transform.scale <= macroGalaxyZoomThreshold && state.visibleNodes.length > 1
+
+  if (shouldRenderMacroGalaxy) {
+    const viewportNodes = viewportNodesFromSpatialIndex(viewport)
+    const sourceNodes = viewportNodes.length > 0 ? viewportNodes : state.visibleNodes
+    const representative = state.macroRepresentative ?? sourceNodes[0] ?? null
+    if (representative) {
+      state.renderClusters = [
+        {
+          id: 'macro-galaxy',
+          x: state.macroCenter.x,
+          y: state.macroCenter.y,
+          count: sourceNodes.length,
+          representative
+        }
+      ]
+      state.renderNodes = [representative]
+    } else {
+      state.renderClusters = []
+      state.renderNodes = []
+    }
+    state.renderEdges = []
+    return
+  }
+
   if (state.visibleNodes.length <= 2000) {
     state.renderNodes = state.visibleNodes
     state.renderClusters = []
@@ -1167,19 +1232,22 @@ const render = now => {
   if (state.renderClusters.length > 0) {
     const safeScale = Math.max(state.transform.scale, 0.0001)
     state.renderClusters.forEach(cluster => {
-      const radiusPx = Math.max(8, Math.min(28, 8 + Math.log2(cluster.count + 1) * 3))
+      const isMacro = cluster.id === 'macro-galaxy'
+      const radiusPx = isMacro
+        ? 10
+        : Math.max(8, Math.min(28, 8 + Math.log2(cluster.count + 1) * 3))
       const radius = radiusPx / safeScale
-      const haloRadius = (radiusPx + 4) / safeScale
+      const haloRadius = (radiusPx + (isMacro ? 8 : 4)) / safeScale
       ctx.beginPath()
       ctx.arc(cluster.x, cluster.y, haloRadius, 0, Math.PI * 2)
-      ctx.fillStyle = graphTheme.nodeHalo
+      ctx.fillStyle = isMacro ? 'rgba(243, 247, 251, 0.28)' : graphTheme.nodeHalo
       ctx.fill()
       ctx.beginPath()
       ctx.arc(cluster.x, cluster.y, radius, 0, Math.PI * 2)
-      ctx.fillStyle = graphTheme.node
+      ctx.fillStyle = isMacro ? '#f3f7fb' : graphTheme.node
       ctx.fill()
       ctx.lineWidth = 1.4 / safeScale
-      ctx.strokeStyle = graphTheme.nodeStroke
+      ctx.strokeStyle = isMacro ? '#ffffff' : graphTheme.nodeStroke
       ctx.stroke()
       // Keep cluster markers minimal and faster to draw on large graphs.
     })
@@ -1267,6 +1335,8 @@ const fetchNodeDetails = async node => {
   return detail
 }
 
+const wait = async (milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds))
+
 const openContentDialog = async node => {
   if (!node) return
   elements.contentTitle.textContent = node.title || 'Loading...'
@@ -1282,19 +1352,32 @@ const openContentDialog = async node => {
     elements.contentDialog.showModal()
   }
 
+  const applyDetailToDialog = detail => {
+    elements.contentTitle.textContent = detail.title
+    elements.contentPath.textContent = detail.path
+    elements.contentTags.innerHTML = detail.tags.length
+      ? detail.tags.map(tag => '<span>#' + escapeHtml(tag) + '</span>').join('')
+      : '<span>No tags</span>'
+    elements.contentBody.textContent = detail.content
+  }
+
   try {
     const detailedNode = await fetchNodeDetails(node)
     if (state.selected?.id !== node.id) {
       return
     }
-    elements.contentTitle.textContent = detailedNode.title
-    elements.contentPath.textContent = detailedNode.path
-    elements.contentTags.innerHTML = detailedNode.tags.length
-      ? detailedNode.tags.map(tag => '<span>#' + escapeHtml(tag) + '</span>').join('')
-      : '<span>No tags</span>'
-    elements.contentBody.textContent = detailedNode.content
+    applyDetailToDialog(detailedNode)
   } catch {
-    elements.contentBody.textContent = 'Unable to load note content.'
+    try {
+      await wait(120)
+      const retriedNode = await fetchNodeDetails(node)
+      if (state.selected?.id !== node.id) {
+        return
+      }
+      applyDetailToDialog(retriedNode)
+    } catch {
+      elements.contentBody.textContent = 'Unable to load note content.'
+    }
   }
 }
 

package/dist/application/server/routes.js

@@ -63,22 +63,62 @@ const compactGraphLayoutEdgeLimitFor = (nodeCount) => {
         return 30_000;
     return compactGraphLayoutEdgeLimit;
 };
+const edgeWeight = (weight) => Number.isFinite(weight) ? Number(weight) : 1;
+const edgeKey = (source, target, priority) => `${source}|${target}|${priority}`;
+const selectCompactEdges = (layout, limit) => {
+    const resolvedEdges = layout.edges.filter((edge) => typeof edge.target === 'string' && edge.target.length > 0);
+    if (resolvedEdges.length <= limit) {
+        return resolvedEdges;
+    }
+    const bestEdgeByEndpoint = new Map();
+    for (let index = 0; index < resolvedEdges.length; index += 1) {
+        const edge = resolvedEdges[index];
+        const endpoints = [edge.source, edge.target];
+        for (let endpointIndex = 0; endpointIndex < endpoints.length; endpointIndex += 1) {
+            const endpoint = endpoints[endpointIndex];
+            const previous = bestEdgeByEndpoint.get(endpoint);
+            if (!previous || edgeWeight(edge.weight) > edgeWeight(previous.weight)) {
+                bestEdgeByEndpoint.set(endpoint, edge);
+            }
+        }
+    }
+    const selected = new Map();
+    for (const edge of bestEdgeByEndpoint.values()) {
+        selected.set(edgeKey(edge.source, edge.target, edge.priority), edge);
+    }
+    if (selected.size > limit) {
+        return Array.from(selected.values())
+            .sort((left, right) => edgeWeight(right.weight) - edgeWeight(left.weight))
+            .slice(0, limit);
+    }
+    const byWeight = [...resolvedEdges].sort((left, right) => edgeWeight(right.weight) - edgeWeight(left.weight));
+    for (let index = 0; index < byWeight.length; index += 1) {
+        if (selected.size >= limit) {
+            break;
+        }
+        const edge = byWeight[index];
+        const key = edgeKey(edge.source, edge.target, edge.priority);
+        if (!selected.has(key)) {
+            selected.set(key, edge);
+        }
+    }
+    return Array.from(selected.values());
+};
 const stripLayoutContent = (layout) => ({
     ...layout,
     nodes: layout.nodes.map(({ content, ...node }) => node)
 });
 const compactLayoutPayload = (layout) => {
     const edgeLimit = compactGraphLayoutEdgeLimitFor(layout.nodes.length);
+    const compactEdges = selectCompactEdges(layout, edgeLimit);
     const compactNodes = layout.nodes.map((node) => [node.id, node.title, node.x, node.y, node.group, node.segment]);
-    const compactEdges = [...layout.edges]
-        .sort((left, right) => (right.weight ?? 1) - (left.weight ?? 1))
-        .slice(0, edgeLimit)
+    const compactEdgeRows = compactEdges
         .map((edge) => [edge.source, edge.target, edge.weight, edge.priority]);
     return {
         compact: true,
         layout: {
             nodes: compactNodes,
-            edges: compactEdges
+            edges: compactEdgeRows
         },
         totals: {
             nodes: layout.nodes.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andespindola/brainlink",
-  "version": "0.1.0-beta.47",
+  "version": "0.1.0-beta.49",
   "description": "Local-first knowledge memory for agents with Markdown, backlinks, indexing and context retrieval.",
   "type": "module",
   "license": "MIT",