get-claudia 1.36.0 → 1.36.1

package/bin/index.js

@@ -412,13 +412,15 @@ async function main() {
     runGatewaySetup((gatewayOk) => maybeRunRelay(memoryInstalled, visualizerInstalled, gatewayOk));
   }
 
-  // Helper: auto-install visualizer after memory (if memory was installed), then chain to gateway
+  // Helper: auto-install visualizer after memory, then chain to gateway
+  // On upgrades, always attempt visualizer install even if memory step had issues,
+  // since the database likely already exists from a prior install.
   function maybeRunVisualizer(memoryInstalled) {
-    if (memoryInstalled) {
-      // Visualizer auto-installs when memory is installed (needs the database)
+    const memoryDbExists = existsSync(join(homedir(), '.claudia', 'memory'));
+    if (memoryInstalled || isUpgrade || memoryDbExists) {
       runVisualizerSetup((vizOk) => maybeRunGateway(memoryInstalled, vizOk));
     } else {
-      // Skip visualizer if no memory system
+      // Fresh install with no memory system -- skip visualizer
       maybeRunGateway(memoryInstalled, false);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.36.0",
+  "version": "1.36.1",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/visualizer-threejs/src/config.js

@@ -94,13 +94,13 @@ export const config = {
     curvature: 0.09,              // base curvature
     curvatureStrength: 0.1,       // additional curvature per strength
     tubeRadius: 0.15,             // base radius for normal links
-    highlightRadius: 1.3,         // multiplier for highlighted links
+    highlightRadius: 0.8,         // multiplier for highlighted links
     tubularSegments: 20,
     radialSegments: 6,
 
     // Opacity
     opacity: 0.27,
-    highlightOpacity: 0.65,
+    highlightOpacity: 0.45,
     historicalOpacity: 0.04,
 
     // Memory-entity lines
@@ -128,7 +128,7 @@ export const config = {
     speedVariance: 0.001,
     size: 2.5,
     opacity: 0.8,
-    highlightCount: 6,
+    highlightCount: 3,
     forwardCount: 2,
     strongCount: 1,
     strongThreshold: 0.6

package/visualizer-threejs/src/links.js

@@ -323,19 +323,22 @@ function bundleEdges(meshes, scene) {
 
   // 2. Iteratively attract nearby control points
   for (let iter = 0; iter < iterations; iter++) {
+    // Decreasing step size per iteration for convergence
+    const iterScale = 1 / (iter + 1);
+
     for (let ei = 0; ei < edgePoints.length; ei++) {
       const edgeA = edgePoints[ei];
 
       for (let pi = 1; pi <= numSegments; pi++) {
         const pointA = edgeA.points[pi];
 
-        // Endpoint stiffness: points near start/end resist more
+        // Endpoint stiffness: middle points move freely, endpoints resist
+        // At t=0.5 (middle): factor=1.0, at t=0 or t=1 (endpoints): factor=1-stiffness
         const tNorm = pi / (numSegments + 1);
-        const endpointFactor = 1 - stiffness * (1 - 4 * Math.pow(tNorm - 0.5, 2));
+        const endpointFactor = 1 - stiffness * 4 * Math.pow(tNorm - 0.5, 2);
 
         // Attract toward nearby control points from other edges
         let forceX = 0, forceY = 0, forceZ = 0;
-        let neighbors = 0;
 
         for (let ej = 0; ej < edgePoints.length; ej++) {
           if (ei === ej) continue;
@@ -349,21 +352,20 @@ function bundleEdges(meshes, scene) {
           const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
 
           if (dist < radius && dist > 0.01) {
-            // Attraction force: inverse distance, capped
-            const force = strength * Math.min(1, radius / (dist + 1));
+            // Attraction force: stronger for closer edges (inverse square falloff)
+            const t = dist / radius;
+            const force = strength * (1 - t * t);
             forceX += dx * force / dist;
             forceY += dy * force / dist;
             forceZ += dz * force / dist;
-            neighbors++;
           }
         }
 
-        if (neighbors > 0) {
-          const scale = endpointFactor / neighbors;
-          pointA.x += forceX * scale;
-          pointA.y += forceY * scale;
-          pointA.z += forceZ * scale;
-        }
+        // Apply accumulated force (not averaged -- more neighbors = stronger bundling)
+        const scale = endpointFactor * iterScale * 0.3;
+        pointA.x += forceX * scale;
+        pointA.y += forceY * scale;
+        pointA.z += forceZ * scale;
       }
     }
   }