@andespindola/brainlink 0.1.0-beta.131 → 0.1.0-beta.133

package/README.md

@@ -606,7 +606,7 @@ The graph UI shows:
 - graph rendering safeguards (batched canvas drawing across graph sizes, edge draw caps, lower redraw rate, zoom-aware interaction)
 - adaptive CPU safeguards for large graphs: idle frame pacing, throttled background physics updates and cached viewport dimensions to reduce redraw/layout overhead while preserving interaction responsiveness
 - WebGL node and edge acceleration when supported, falling back to Canvas 2D without changing graph behavior
-- large graph LOD keeps a recursive graph-of-graphs model: zoom-out fills the projected macro level toward 1000 lightweight group nodes with sparse strongest-link edges, zoom-in fits the framed node's full child-graph circumference with extra margin before expanding, groups with child groups open another graph level instead of jumping to leaf notes, and zoom-out restores sibling groups
+- large graph LOD keeps a recursive graph-of-graphs model: zoom-out fills the projected macro level toward 1000 lightweight group nodes with every aggregated link between visible groups, zoom-in grows the focused node into a local child graph anchored at the same point, once the child graph is framed the sibling groups stop rendering, groups with child groups open another graph level instead of jumping to leaf notes, and zoom-out restores sibling groups
 
 The server indexes before starting by default. Use `--no-index` to skip that step:
 

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

@@ -16,7 +16,11 @@ const hierarchyMicroEnterCoverage = 0.58
 const hierarchyMicroExitCoverage = 0.38
 const hierarchyMicroEnterScale = 0.18
 const hierarchyMicroExitScale = 0.12
-const hierarchyChildGraphFitMargin = 1.38
+const hierarchyFocusAcquireCoverage = 0.52
+const hierarchyFocusAcquireScale = 0.16
+const hierarchyChildRevealPower = 4
+const hierarchyFocusedOnlyProgress = 0.64
+const hierarchyChildGraphFitMargin = 1.28
 const minNodePixelRadius = 2.3
 const viewportPaddingPx = 280
 const worldCoordinateLimit = 5_000_000
@@ -647,7 +651,7 @@ const createVisibleEdgeLookup = edges => {
 
 const edgeBudgetForCurrentFrame = () => {
   const zoom = state.transform.scale
-  if (zoom < 0.12) return 380
+  if (zoom < 0.12) return state.groups.length > 0 ? 1200 : 380
   if (zoom < 0.18) return 900
   if (zoom < 0.28) return 1700
   if (zoom < 0.45) return 2800
@@ -1319,6 +1323,43 @@ const arrangeChildGraphNodes = (nodes, group, origin = group) => {
   return arranged
 }
 
+const arrangeChildGroupNodes = (groups, parentGroup, origin) => {
+  if (groups.length <= 1) {
+    return groups.map(group => ({
+      ...createGroupRenderNode(group),
+      x: origin.x,
+      y: origin.y
+    }))
+  }
+
+  const targetRadius = childGraphRenderRadius(parentGroup)
+  const centerGroup = groups
+    .map(group => ({
+      group,
+      score: Math.max(group.nodeIds.length, group.childGroupIds.length, 1)
+    }))
+    .sort((left, right) => right.score - left.score || left.group.title.localeCompare(right.group.title))[0]?.group
+  const outerGroups = groups
+    .filter(group => group.id !== centerGroup?.id)
+    .sort((left, right) => left.segment.localeCompare(right.segment) || left.title.localeCompare(right.title))
+  const goldenAngle = Math.PI * (3 - Math.sqrt(5))
+  const arranged = centerGroup
+    ? [{ ...createGroupRenderNode(centerGroup), x: origin.x, y: origin.y }]
+    : []
+
+  outerGroups.forEach((group, index) => {
+    const ringRadius = targetRadius * Math.sqrt((index + 1) / Math.max(outerGroups.length, 1))
+    const angle = index * goldenAngle
+    arranged.push({
+      ...createGroupRenderNode(group),
+      x: origin.x + Math.cos(angle) * ringRadius,
+      y: origin.y + Math.sin(angle) * ringRadius
+    })
+  })
+
+  return arranged
+}
+
 const interpolateNodeFromGroup = (node, origin, progress) => {
   return {
     ...node,
@@ -1364,7 +1405,7 @@ const hierarchyGroupsForScale = () => {
 const groupViewportCoverage = (group, viewport) => {
   const viewportWidth = Math.max(viewport.maxX - viewport.minX, 1)
   const viewportHeight = Math.max(viewport.maxY - viewport.minY, 1)
-  const viewportRadius = Math.max(viewportWidth, viewportHeight) / 2
+  const viewportRadius = Math.min(viewportWidth, viewportHeight) / 2
   const centerX = (viewport.minX + viewport.maxX) / 2
   const centerY = (viewport.minY + viewport.maxY) / 2
   const centerDistance = Math.hypot(group.x - centerX, group.y - centerY)
@@ -1422,6 +1463,16 @@ const updateHierarchyFocusGroup = (groups, viewport) => {
     ? groups.find(group => group.id === state.hierarchyFocusGroupId) ?? null
     : null
   const currentCoverage = current ? groupViewportCoverage(current, viewport) : 0
+  const hasActiveFocusedTransition =
+    Boolean(current) &&
+    state.zoomTransition.active &&
+    state.zoomTransition.source === 'group' &&
+    state.selected?.isGroupNode &&
+    state.selected.groupId === current.id
+
+  if (hasActiveFocusedTransition) {
+    return current
+  }
 
   if (
     current &&
@@ -1440,8 +1491,8 @@ const updateHierarchyFocusGroup = (groups, viewport) => {
 
   if (
     candidate &&
-    state.transform.scale >= hierarchyMicroEnterScale &&
-    candidate.coverage >= hierarchyMicroEnterCoverage
+    state.transform.scale >= hierarchyFocusAcquireScale &&
+    candidate.coverage >= hierarchyFocusAcquireCoverage
   ) {
     state.hierarchyFocusGroupId = candidate.group.id
     if (candidate.group.childGroupIds.length > 0 && state.hierarchyFocusStack.at(-1) !== candidate.group.id) {
@@ -1459,9 +1510,23 @@ const updateHierarchyFocusGroup = (groups, viewport) => {
 
 const hierarchyViewportProgress = (group, viewport) => {
   const coverage = groupViewportCoverage(group, viewport)
-  const coverageProgress = (coverage - hierarchyMicroExitCoverage) / (hierarchyMicroEnterCoverage - hierarchyMicroExitCoverage)
-  const scaleProgress = (state.transform.scale - hierarchyMicroExitScale) / (hierarchyMicroEnterScale - hierarchyMicroExitScale)
-  return smoothProgress(Math.min(coverageProgress, scaleProgress))
+  const coverageProgress = (coverage - hierarchyFocusAcquireCoverage) / (hierarchyMicroEnterCoverage - hierarchyFocusAcquireCoverage)
+  const scaleProgress = (state.transform.scale - hierarchyFocusAcquireScale) / (hierarchyMicroEnterScale - hierarchyFocusAcquireScale)
+  const viewportProgress = smoothProgress(Math.min(coverageProgress, scaleProgress))
+  const hasActiveFocusedTransition =
+    state.zoomTransition.active &&
+    state.zoomTransition.source === 'group' &&
+    state.selected?.isGroupNode &&
+    state.selected.groupId === group.id
+
+  if (!hasActiveFocusedTransition) {
+    return viewportProgress
+  }
+
+  const targetSpan = Math.max(state.zoomTransition.targetScale - hierarchyFocusAcquireScale, 0.0001)
+  const transitionScaleProgress = (state.transform.scale - hierarchyFocusAcquireScale) / targetSpan
+  const transitionProgress = Math.pow(Math.max(0, Math.min(1, transitionScaleProgress)), 2.8)
+  return Math.max(viewportProgress, transitionProgress)
 }
 
 const groupEdgesForRenderedGroups = (groupNodes) => {
@@ -1508,19 +1573,8 @@ const groupEdgesForRenderedGroups = (groupNodes) => {
     })
   }
 
-  const degreeCounts = new Map()
   return Array.from(selected.values())
     .sort((left, right) => edgeWeight(right) - edgeWeight(left) || left.source.localeCompare(right.source) || left.target.localeCompare(right.target))
-    .filter((edge) => {
-      const sourceCount = degreeCounts.get(edge.source) ?? 0
-      const targetCount = degreeCounts.get(edge.target) ?? 0
-      if (sourceCount >= 3 || targetCount >= 3) {
-        return false
-      }
-      degreeCounts.set(edge.source, sourceCount + 1)
-      degreeCounts.set(edge.target, targetCount + 1)
-      return true
-    })
     .slice(0, Math.min(hierarchyGroupEdgeLimit, edgeBudgetForCurrentFrame()))
 }
 
@@ -1547,25 +1601,22 @@ const computeHierarchyRenderVisibility = (viewport) => {
   const focusChildGroups = focus.childGroupIds
     .map(groupId => state.groupById.get(groupId))
     .filter(Boolean)
-  const childLimit = Math.max(90, Math.min(renderNodeBudget, Math.floor(renderNodeBudget * progress)))
+  const childRevealProgress = Math.pow(Math.max(0, Math.min(1, progress)), hierarchyChildRevealPower)
+  const childLimit = Math.min(renderNodeBudget, Math.max(1, Math.floor(renderNodeBudget * childRevealProgress)))
   const focusRenderNode = groupNodes.find(node => node.groupId === focus.id) ?? createGroupRenderNode(focus)
   const arrangedChildren = focusChildGroups.length > 0
-    ? arrangeGraphLevelNodes(focusChildGroups, groupRenderRadius).map(group => ({
-        ...createGroupRenderNode(group),
-        x: focusRenderNode.x + group.x,
-        y: focusRenderNode.y + group.y
-      }))
+    ? arrangeChildGroupNodes(focusChildGroups, focus, focusRenderNode)
     : arrangeChildGraphNodes(rawChildNodes, focus, focusRenderNode)
   const childNodes = selectStableSampleNodes(arrangedChildren, childLimit)
     .map(node => interpolateNodeFromGroup(node, focusRenderNode, progress))
   const childIds = new Set(childNodes.map(node => node.id))
   const childById = new Map(childNodes.map(node => [node.id, node]))
-  const isMicroView = progress >= 0.72
+  const isMicroView = progress >= hierarchyFocusedOnlyProgress
   const visibleGroupNodes = isMicroView
     ? []
     : groupNodes.filter(node => node.groupId !== focus.id || progress < 0.92)
   const groupEdges = isMicroView ? [] : groupEdgesForRenderedGroups(visibleGroupNodes)
-  const childEdges = progress > 0.32
+  const childEdges = (isMicroView || progress > 0.02)
     ? focusChildGroups.length > 0
       ? groupEdgesForRenderedGroups(childNodes)
       : collectVisibleEdgesForNodes(childIds).map(edge => ({
@@ -2086,7 +2137,7 @@ const childGraphFitTransition = (node, group) => {
   const width = Math.max(rect.width, 320)
   const height = Math.max(rect.height, 320)
   const fitScale = childGraphFitScaleForGroup(group, width, height)
-  const nextScale = clampScale(Math.max(fitScale, state.transform.scale * 1.16, hierarchyMicroEnterScale * 1.04))
+  const nextScale = clampScale(Math.max(fitScale, state.transform.scale * 1.08, hierarchyMicroExitScale * 1.02))
 
   return {
     active: true,
@@ -2946,7 +2997,7 @@ const selectNode = (node, options = { openContent: false }) => {
       screenY: state.viewport.height / 2,
       worldX: node.x,
       worldY: node.y,
-      targetScale: clampScale(Math.max(state.transform.scale * 1.16, hierarchyMicroEnterScale * 1.04))
+      targetScale: clampScale(Math.max(state.transform.scale * 1.08, hierarchyMicroExitScale * 1.02))
     }
     state.lastZoomFocus = { x: node.x, y: node.y, at: performance.now() }
     state.hierarchyFocusGroupId = node.groupId

package/docs/AGENT_USAGE.md

@@ -607,7 +607,7 @@ Without `--vault`, the graph UI serves `$HOME/.brainlink/vault`.
 
 The frontend includes an agent selector that shows only the agent id. Selecting an agent calls the same read APIs with `agent=<agent-id>` and renders that namespace instead of merging every agent into one graph.
 
-Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on canvas zooms in at cursor position. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open on click in a modal (tags, outgoing links, backlinks and Markdown content). Vaults above 1000 notes also expose stable hierarchy groups that fill each visible graph level toward 1000 nodes while keeping every group capped at 1000 child nodes; zoom-out renders the macro level as a sparse strongest-link graph of group nodes, zoom-in fits the focused node's full child-graph circumference with extra margin before expanding, and groups with child groups open another graph level instead of jumping directly to leaf notes.
+Graph navigation controls include zoom in, zoom out, fit visible nodes and reset-to-fit-all nodes. Mouse wheel zoom (including `cmd+scroll` and `ctrl+scroll`) is anchored to the cursor. Keyboard shortcuts are `+` (zoom in), `-` (zoom out) and `0` (reset fit). Double-click on canvas zooms in at cursor position. Totals for notes, links and tags stay visible as floating metrics under the Brainlink title, and node details open on click in a modal (tags, outgoing links, backlinks and Markdown content). Vaults above 1000 notes also expose stable hierarchy groups that fill each visible graph level toward 1000 nodes while keeping every group capped at 1000 child nodes; zoom-out renders the macro level with every aggregated link between visible group nodes, zoom-in grows the focused node into a local child graph anchored at the same point, once the child graph is framed the sibling groups stop rendering, and groups with child groups open another graph level instead of jumping directly to leaf notes.
 During graph filtering, Brainlink keeps hub context nodes visible (`Memory Hub`/`MOC`/high-degree fallback) so filtered views still show relationship anchors.
 
 The command reindexes by default, then serves:

package/package.json

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