npm - @andespindola/brainlink - Versions diffs - 0.1.0-beta.61 → 0.1.0-beta.63 - Mend

@andespindola/brainlink 0.1.0-beta.61 → 0.1.0-beta.63

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/application/frontend/client-html.js +1 -1
package/dist/application/frontend/client-js.js +148 -19
package/package.json +1 -1

package/dist/application/frontend/client-html.js CHANGED Viewed

@@ -38,7 +38,7 @@ export const createClientHtml = () => `<!doctype html>
             <div class="toolbar" aria-label="Graph controls">
               <button id="zoomIn" type="button" title="Zoom in">+</button>
               <button id="zoomOut" type="button" title="Zoom out">-</button>
-              <button id="fit" type="button" title="Fit visible nodes">◎</button>
+              <button id="fit" type="button" title="Focus central hub">◎</button>
               <button id="reset" type="button" title="Reset view">⌂</button>
             </div>
           </div>

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

@@ -23,6 +23,8 @@ const meshEdgeScaleThreshold = 0.09
 const meshEdgeMinBudget = 140
 const meshEdgeMaxBudget = 1400
 const layeredCoreScaleThreshold = 0.55
+const dragNeighborhoodMaxAffected = 180
+const dragSettleRounds = 3
 const state = {
   graph: { nodes: [], edges: [] },
   nodes: [],
@@ -569,13 +571,12 @@ const nodeBudgetForScale = (scale) => {
 }
 const layerWindowForScale = (scale) => {
-  if (scale < 0.08) return { inner: 0.78, outer: 1 }
-  if (scale < 0.14) return { inner: 0.62, outer: 0.9 }
-  if (scale < 0.24) return { inner: 0.46, outer: 0.74 }
-  if (scale < 0.36) return { inner: 0.3, outer: 0.58 }
-  if (scale < layeredCoreScaleThreshold) return { inner: 0.16, outer: 0.42 }
-  if (scale < 0.9) return { inner: 0.06, outer: 0.26 }
-  return { inner: 0, outer: 0.14 }
+  const normalized = Math.max(0, Math.min(1, (scale - 0.06) / 0.94))
+  const outer = Math.max(0.14, 1 - normalized * 0.86)
+  const band = Math.max(0.14, 0.26 - normalized * 0.12)
+  const inner = Math.max(0, outer - band)
+  return { inner, outer }
 }
 const selectLayeredNodesForScale = (sourceNodes) => {
@@ -1141,6 +1142,27 @@ const fitView = (options = { useFiltered: true, macro: false, preferHubCenter: t
 const resetView = () => fitView({ useFiltered: false, macro: true, preferHubCenter: true })
+const focusPrimaryHub = () => {
+  const hub = state.primaryHub
+  if (!hub) {
+    fitView({ useFiltered: true, macro: false, preferHubCenter: true })
+    return
+  }
+  const rect = canvas.getBoundingClientRect()
+  const width = Math.max(rect.width, 320)
+  const height = Math.max(rect.height, 320)
+  const targetScale = clampScale(Math.max(0.78, state.transform.scale))
+  state.transform = {
+    x: clampTransformCoordinate(width / 2 - hub.x * targetScale),
+    y: clampTransformCoordinate(height / 2 - hub.y * targetScale),
+    scale: targetScale
+  }
+  state.offscreenFrameCount = 0
+  markRenderDirty()
+}
 const createLayout = graph => {
   const nodeRows = Array.isArray(graph.nodes) ? graph.nodes : []
   const edgeRows = Array.isArray(graph.edges) ? graph.edges : []
@@ -1354,6 +1376,104 @@ const worldPoint = event => {
   }
 }
+const connectedNodeIdsFor = (nodeId) => {
+  const edges = state.visibleEdgeByNode.get(nodeId) ?? []
+  const ids = new Set()
+  for (let index = 0; index < edges.length; index += 1) {
+    const edge = edges[index]
+    if (!edge.target) continue
+    if (edge.source === nodeId) {
+      ids.add(edge.target)
+    } else if (edge.target === nodeId) {
+      ids.add(edge.source)
+    }
+  }
+  return ids
+}
+const applyDragNeighborhoodAdjustment = (dragNode, deltaX, deltaY) => {
+  if (!dragNode) return
+  if (!Number.isFinite(deltaX) || !Number.isFinite(deltaY)) return
+  if (Math.abs(deltaX) + Math.abs(deltaY) <= 0.001) return
+  const scale = Math.max(state.transform.scale, 0.0001)
+  const influenceRadius = Math.max(220, Math.min(920, 440 / scale))
+  const influenceRadiusSquared = influenceRadius * influenceRadius
+  const connectedIds = connectedNodeIdsFor(dragNode.id)
+  const candidates = state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes
+  let adjusted = 0
+  for (let index = 0; index < candidates.length && adjusted < dragNeighborhoodMaxAffected; index += 1) {
+    const node = candidates[index]
+    if (node.id === dragNode.id) continue
+    const isConnected = connectedIds.has(node.id)
+    const dx = node.x - dragNode.x
+    const dy = node.y - dragNode.y
+    const distanceSquared = dx * dx + dy * dy
+    const withinRadius = distanceSquared <= influenceRadiusSquared
+    if (!isConnected && !withinRadius) continue
+    const distance = Math.max(Math.sqrt(distanceSquared), 0.0001)
+    const proximity = withinRadius ? 1 - (distance / influenceRadius) : 0
+    const coupledStrength = isConnected ? 0.28 : 0.12
+    const influence = Math.min(0.46, coupledStrength + proximity * 0.34)
+    node.x += deltaX * influence
+    node.y += deltaY * influence
+    node.vx = (Number.isFinite(node.vx) ? node.vx : 0) + deltaX * influence * 0.06
+    node.vy = (Number.isFinite(node.vy) ? node.vy : 0) + deltaY * influence * 0.06
+    adjusted += 1
+  }
+}
+const settleNeighborhoodAroundNode = (dragNode) => {
+  if (!dragNode) return
+  const scale = Math.max(state.transform.scale, 0.0001)
+  const settleRadius = Math.max(240, Math.min(980, 520 / scale))
+  const settleRadiusSquared = settleRadius * settleRadius
+  const connectedIds = connectedNodeIdsFor(dragNode.id)
+  const candidates = (state.renderNodes.length > 0 ? state.renderNodes : state.visibleNodes)
+    .filter((node) => {
+      if (node.id === dragNode.id) return true
+      const dx = node.x - dragNode.x
+      const dy = node.y - dragNode.y
+      const distanceSquared = dx * dx + dy * dy
+      return connectedIds.has(node.id) || distanceSquared <= settleRadiusSquared
+    })
+    .slice(0, dragNeighborhoodMaxAffected)
+  if (candidates.length <= 1) return
+  for (let round = 0; round < dragSettleRounds; round += 1) {
+    for (let leftIndex = 0; leftIndex < candidates.length; leftIndex += 1) {
+      const left = candidates[leftIndex]
+      for (let rightIndex = leftIndex + 1; rightIndex < candidates.length; rightIndex += 1) {
+        const right = candidates[rightIndex]
+        const dx = right.x - left.x
+        const dy = right.y - left.y
+        const distance = Math.max(Math.hypot(dx, dy), 0.001)
+        const minDistance = baseNodeRadius(left) + baseNodeRadius(right) + 10
+        if (distance >= minDistance) continue
+        const push = (minDistance - distance) * 0.36
+        const ux = dx / distance
+        const uy = dy / distance
+        if (left.id !== dragNode.id) {
+          left.x -= ux * push
+          left.y -= uy * push
+        }
+        if (right.id !== dragNode.id) {
+          right.x += ux * push
+          right.y += uy * push
+        }
+      }
+    }
+  }
+}
 const hitNode = point => {
   computeRenderVisibility()
   if (state.renderClusters.length > 0) {
@@ -1920,8 +2040,8 @@ const wheelZoomFactor = event => {
     return 1
   }
-  const baseStep = Math.max(0.06, Math.min(0.45, absoluteDelta / 480))
-  const adjustedStep = baseStep * (isModifierZoom ? 1.4 : 1)
+  const baseStep = Math.max(0.03, Math.min(0.2, absoluteDelta / 680))
+  const adjustedStep = baseStep * (isModifierZoom ? 1.24 : 1)
   return event.deltaY < 0 ? 1 + adjustedStep : 1 / (1 + adjustedStep)
 }
@@ -1968,15 +2088,15 @@ const bindEvents = () => {
   })
   elements.zoomIn.addEventListener('click', () => {
     const rect = canvas.getBoundingClientRect()
-    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.3)
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.14)
   })
   elements.zoomOut.addEventListener('click', () => {
     const rect = canvas.getBoundingClientRect()
-    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.77)
+    zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.88)
   })
   if (elements.fit) {
     elements.fit.addEventListener('click', () => {
-      fitView({ useFiltered: true })
+      focusPrimaryHub()
     })
   }
   elements.reset.addEventListener('click', () => {
@@ -1996,7 +2116,7 @@ const bindEvents = () => {
     const rect = canvas.getBoundingClientRect()
     const cursorX = event.clientX - rect.left
     const cursorY = event.clientY - rect.top
-    zoomAtPoint(cursorX, cursorY, 1.25)
+    zoomAtPoint(cursorX, cursorY, 1.12)
   })
   canvas.addEventListener('pointerdown', event => {
     const point = worldPoint(event)
@@ -2030,8 +2150,12 @@ const bindEvents = () => {
     state.pointer.y = event.clientY
     state.pointer.moved = state.pointer.moved || Math.abs(dx) + Math.abs(dy) > 3
     if (state.pointer.dragNode) {
-      state.pointer.dragNode.x = point.x
-      state.pointer.dragNode.y = point.y
+      const dragNode = state.pointer.dragNode
+      const previousX = dragNode.x
+      const previousY = dragNode.y
+      dragNode.x = point.x
+      dragNode.y = point.y
+      applyDragNeighborhoodAdjustment(dragNode, dragNode.x - previousX, dragNode.y - previousY)
       markRenderDirty()
       return
     }
@@ -2043,8 +2167,13 @@ const bindEvents = () => {
     markRenderDirty()
   })
   canvas.addEventListener('pointerup', event => {
-    if (state.pointer.dragNode && !state.pointer.moved) selectNode(state.pointer.dragNode, { openContent: true })
-    if (!state.pointer.dragNode && !state.pointer.moved) selectNode(state.hovered, { openContent: true })
+    const draggedNode = state.pointer.dragNode
+    if (draggedNode && state.pointer.moved) {
+      settleNeighborhoodAroundNode(draggedNode)
+      markRenderDirty()
+    }
+    if (draggedNode && !state.pointer.moved) selectNode(draggedNode, { openContent: true })
+    if (!draggedNode && !state.pointer.moved) selectNode(state.hovered, { openContent: true })
     state.pointer = { x: 0, y: 0, down: false, dragNode: null, moved: false }
     canvas.releasePointerCapture(event.pointerId)
   })
@@ -2061,14 +2190,14 @@ const bindEvents = () => {
     if (event.key === '+' || event.key === '=') {
       event.preventDefault()
       const rect = canvas.getBoundingClientRect()
-      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.25)
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 1.12)
       return
     }
     if (event.key === '-' || event.key === '_') {
       event.preventDefault()
       const rect = canvas.getBoundingClientRect()
-      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.8)
+      zoomAtPoint(Math.max(rect.width, 320) / 2, Math.max(rect.height, 320) / 2, 0.89)
       return
     }

package/package.json CHANGED Viewed

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