get-claudia 1.35.2 → 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.35.2",
+  "version": "1.36.1",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",

package/visualizer/lib/clusters.js

@@ -0,0 +1,159 @@
+/**
+ * DBSCAN clustering on 3D UMAP coordinates.
+ * Groups semantically similar nodes into clusters for convex hull visualization.
+ */
+
+let cachedClusters = null;
+let cacheTimestamp = 0;
+const CACHE_TTL = 60000; // 1 minute (same as UMAP)
+
+/**
+ * Compute DBSCAN clusters from 3D positions.
+ * @param {Object} positions - Map of nodeId -> { x, y, z }
+ * @param {Array} nodes - Graph nodes array
+ * @returns {Array} clusters - [{ id, label, memberIds, centroid }]
+ */
+export function computeClusters(positions, nodes, { eps = 30, minPts = 3 } = {}) {
+  if (cachedClusters && Date.now() - cacheTimestamp < CACHE_TTL) {
+    return cachedClusters;
+  }
+
+  // Only cluster nodes that have UMAP positions
+  const posEntries = [];
+  for (const node of nodes) {
+    const pos = positions[node.id];
+    if (pos) {
+      posEntries.push({ id: node.id, node, pos: [pos.x, pos.y, pos.z] });
+    }
+  }
+
+  if (posEntries.length < minPts) {
+    return [];
+  }
+
+  // DBSCAN
+  const labels = new Int32Array(posEntries.length).fill(-1); // -1 = unvisited
+  const NOISE = -2;
+  let clusterId = 0;
+
+  for (let i = 0; i < posEntries.length; i++) {
+    if (labels[i] !== -1) continue;
+
+    const neighbors = rangeQuery(posEntries, i, eps);
+    if (neighbors.length < minPts) {
+      labels[i] = NOISE;
+      continue;
+    }
+
+    labels[i] = clusterId;
+    const seed = [...neighbors];
+
+    for (let j = 0; j < seed.length; j++) {
+      const q = seed[j];
+      if (labels[q] === NOISE) labels[q] = clusterId;
+      if (labels[q] !== -1) continue;
+
+      labels[q] = clusterId;
+      const qNeighbors = rangeQuery(posEntries, q, eps);
+      if (qNeighbors.length >= minPts) {
+        for (const n of qNeighbors) {
+          if (!seed.includes(n)) seed.push(n);
+        }
+      }
+    }
+    clusterId++;
+  }
+
+  // Build cluster objects
+  const clusterMap = new Map();
+  for (let i = 0; i < posEntries.length; i++) {
+    const cid = labels[i];
+    if (cid < 0) continue;
+    if (!clusterMap.has(cid)) clusterMap.set(cid, []);
+    clusterMap.get(cid).push(posEntries[i]);
+  }
+
+  const clusters = [];
+  for (const [id, members] of clusterMap) {
+    if (members.length < minPts) continue;
+
+    const centroid = [0, 0, 0];
+    for (const m of members) {
+      centroid[0] += m.pos[0];
+      centroid[1] += m.pos[1];
+      centroid[2] += m.pos[2];
+    }
+    centroid[0] /= members.length;
+    centroid[1] /= members.length;
+    centroid[2] /= members.length;
+
+    clusters.push({
+      id,
+      label: generateClusterLabel(members.map(m => m.node)),
+      memberIds: members.map(m => m.id),
+      centroid
+    });
+  }
+
+  cachedClusters = clusters;
+  cacheTimestamp = Date.now();
+  return clusters;
+}
+
+/** Euclidean distance range query for DBSCAN */
+function rangeQuery(entries, idx, eps) {
+  const neighbors = [];
+  const p = entries[idx].pos;
+  const eps2 = eps * eps;
+
+  for (let i = 0; i < entries.length; i++) {
+    if (i === idx) continue;
+    const q = entries[i].pos;
+    const d2 = (p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2 + (p[2] - q[2]) ** 2;
+    if (d2 <= eps2) neighbors.push(i);
+  }
+  return neighbors;
+}
+
+/** Generate a label from cluster member nodes using most common entity type/name */
+function generateClusterLabel(nodes) {
+  // Count entity types
+  const typeCounts = {};
+  const entityNames = [];
+  for (const n of nodes) {
+    if (n.nodeType === 'entity') {
+      const t = n.entityType || 'unknown';
+      typeCounts[t] = (typeCounts[t] || 0) + 1;
+      entityNames.push(n.name);
+    }
+  }
+
+  // Most common entity type
+  let topType = null;
+  let topCount = 0;
+  for (const [type, count] of Object.entries(typeCounts)) {
+    if (count > topCount) { topType = type; topCount = count; }
+  }
+
+  // Use top entity names (by importance) for label
+  const importantNodes = nodes
+    .filter(n => n.nodeType === 'entity')
+    .sort((a, b) => (b.importance || 0) - (a.importance || 0))
+    .slice(0, 2);
+
+  if (importantNodes.length > 0) {
+    const names = importantNodes.map(n => n.name).join(', ');
+    return topType ? `${capitalize(topType)}: ${names}` : names;
+  }
+
+  return topType ? `${capitalize(topType)} cluster` : `Cluster`;
+}
+
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+export function invalidateClusterCache() {
+  cachedClusters = null;
+  cacheTimestamp = 0;
+}

package/visualizer/lib/graph.js

@@ -207,7 +207,49 @@ export function buildGraph({ includeHistorical = false } = {}) {
     timestamp: new Date().toISOString()
   };
 
-  return { nodes, links, meta };
+  // ── Deduplicate bidirectional relationship links ─────────
+  // If A→B and B→A both exist, merge into one link with bidirectional: true
+  const linkMap = new Map(); // canonical key -> link
+  const deduped = [];
+
+  for (const l of links) {
+    if (l.linkType !== 'relationship') {
+      deduped.push(l);
+      continue;
+    }
+    const a = l.source < l.target ? l.source : l.target;
+    const b = l.source < l.target ? l.target : l.source;
+    const key = `${a}_${b}`;
+
+    if (linkMap.has(key)) {
+      // Merge: keep stronger strength, combine labels, mark bidirectional
+      const existing = linkMap.get(key);
+      existing.bidirectional = true;
+      if (l.strength > existing.strength) {
+        existing.strength = l.strength;
+        existing.width = l.width;
+      }
+      // Combine labels if different
+      if (l.label && l.label !== existing.label) {
+        existing.label = `${existing.label} / ${l.label}`;
+      }
+    } else {
+      l.bidirectional = false;
+      linkMap.set(key, l);
+      deduped.push(l);
+    }
+  }
+
+  // Build existing link pairs set for pollination exclusion
+  const existingPairs = new Set();
+  for (const l of deduped) {
+    if (l.linkType === 'relationship') {
+      existingPairs.add(`${l.source}_${l.target}`);
+      existingPairs.add(`${l.target}_${l.source}`);
+    }
+  }
+
+  return { nodes, links: deduped, meta, existingPairs };
 }
 
 // ── Helpers ─────────────────────────────────────────────────

package/visualizer/lib/pollination.js

@@ -0,0 +1,101 @@
+/**
+ * Pollination — discover weak-but-plausible connections between distant nodes.
+ * Computes pairwise cosine similarity on entity embeddings, filters to
+ * the "interesting" range [0.3, 0.5], and excludes already-linked pairs.
+ */
+
+import { getDb } from './database.js';
+
+let cachedLinks = null;
+let cacheTimestamp = 0;
+const CACHE_TTL = 60000; // 1 minute
+
+/**
+ * Compute pollination links from entity embeddings.
+ * @param {Set} existingPairs - Set of "entityId-entityId" strings for already-linked pairs
+ * @returns {Array} [{ source, target, similarity }]
+ */
+export function computePollinationLinks(existingPairs) {
+  if (cachedLinks && Date.now() - cacheTimestamp < CACHE_TTL) {
+    return cachedLinks;
+  }
+
+  const db = getDb();
+  let embeddings;
+
+  try {
+    const rows = db.prepare('SELECT entity_id as id, embedding FROM entity_embeddings').all();
+    embeddings = rows.map(row => ({
+      id: row.id,
+      vec: blobToFloat32(row.embedding)
+    })).filter(r => r.vec !== null);
+  } catch {
+    return []; // Table might not exist
+  }
+
+  if (embeddings.length < 2) return [];
+
+  // Precompute norms
+  for (const e of embeddings) {
+    let sum = 0;
+    for (let i = 0; i < e.vec.length; i++) sum += e.vec[i] * e.vec[i];
+    e.norm = Math.sqrt(sum);
+  }
+
+  const links = [];
+  const SIM_LOW = 0.3;
+  const SIM_HIGH = 0.5;
+  const MAX_LINKS = 50;
+
+  for (let i = 0; i < embeddings.length; i++) {
+    for (let j = i + 1; j < embeddings.length; j++) {
+      const a = embeddings[i];
+      const b = embeddings[j];
+
+      // Skip already-linked pairs
+      const pairKey = `entity-${a.id}_entity-${b.id}`;
+      const pairKeyR = `entity-${b.id}_entity-${a.id}`;
+      if (existingPairs.has(pairKey) || existingPairs.has(pairKeyR)) continue;
+
+      // Cosine similarity
+      let dot = 0;
+      for (let k = 0; k < a.vec.length; k++) dot += a.vec[k] * b.vec[k];
+      const sim = a.norm > 0 && b.norm > 0 ? dot / (a.norm * b.norm) : 0;
+
+      if (sim >= SIM_LOW && sim <= SIM_HIGH) {
+        links.push({
+          source: `entity-${a.id}`,
+          target: `entity-${b.id}`,
+          similarity: Math.round(sim * 1000) / 1000
+        });
+      }
+    }
+  }
+
+  // Sort by similarity descending, take top N
+  links.sort((a, b) => b.similarity - a.similarity);
+  const result = links.slice(0, MAX_LINKS);
+
+  cachedLinks = result;
+  cacheTimestamp = Date.now();
+  return result;
+}
+
+function blobToFloat32(blob) {
+  if (!blob) return null;
+  try {
+    if (Buffer.isBuffer(blob)) {
+      const floats = new Float32Array(blob.buffer, blob.byteOffset, blob.length / 4);
+      return Array.from(floats);
+    }
+    if (typeof blob === 'string') return JSON.parse(blob);
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function invalidatePollinationCache() {
+  cachedLinks = null;
+  cacheTimestamp = 0;
+}

package/visualizer/server.js

@@ -15,6 +15,8 @@ import { dirname, join } from 'path';
 import { openDatabase, findDbPath, closeDatabase, getDb, listDatabases, getProjectHash } from './lib/database.js';
 import { buildGraph } from './lib/graph.js';
 import { getProjectedPositions } from './lib/projection.js';
+import { computeClusters } from './lib/clusters.js';
+import { computePollinationLinks } from './lib/pollination.js';
 import { createEventStream, stopPolling } from './lib/events.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -105,6 +107,29 @@ app.get('/api/graph', async (req, res) => {
       graph.meta.umapEnabled = false;
     }
 
+    // Compute clusters from UMAP positions
+    try {
+      const positions = {};
+      for (const node of graph.nodes) {
+        if (node.fx !== undefined) {
+          positions[node.id] = { x: node.fx, y: node.fy, z: node.fz };
+        }
+      }
+      graph.clusters = computeClusters(positions, graph.nodes);
+    } catch {
+      graph.clusters = [];
+    }
+
+    // Compute pollination links from entity embeddings
+    try {
+      graph.pollinationLinks = computePollinationLinks(graph.existingPairs || new Set());
+    } catch {
+      graph.pollinationLinks = [];
+    }
+
+    // Remove internal-only field before sending to client
+    delete graph.existingPairs;
+
     res.json(graph);
   } catch (err) {
     console.error('Graph error:', err);

package/visualizer-threejs/index.html

@@ -10,69 +10,99 @@
   <!-- Three.js container -->
   <div id="graph-container"></div>
 
+  <!-- Hover tooltip (follows cursor) -->
+  <div id="tooltip" class="hidden">
+    <div id="tooltip-name"></div>
+    <div id="tooltip-type"></div>
+    <div id="tooltip-meta"></div>
+  </div>
+
   <!-- Top HUD bar -->
   <div id="hud-bar">
-    <div id="hud-title">
+    <div id="hud-left">
       <img src="/assets/claudia-logo.png" alt="Claudia" class="hud-logo" />
-      <span>Claudia Brain</span>
+      <span class="hud-brand">Claudia Brain</span>
       <span id="activity-pulse" class="pulse"></span>
     </div>
     <div id="hud-stats">
-      <div class="stat"><span id="stat-entities">0</span> entities</div>
-      <div class="stat"><span id="stat-memories">0</span> memories</div>
-      <div class="stat"><span id="stat-patterns">0</span> patterns</div>
-      <div class="stat"><span id="stat-relationships">0</span> relationships</div>
+      <div class="stat"><span id="stat-entities">0</span><label>entities</label></div>
+      <div class="stat"><span id="stat-memories">0</span><label>memories</label></div>
+      <div class="stat"><span id="stat-patterns">0</span><label>patterns</label></div>
+      <div class="stat"><span id="stat-relationships">0</span><label>relationships</label></div>
     </div>
     <div id="hud-controls">
-      <a href="https://github.com/kbanc85/claudia" target="_blank" rel="noopener"
-         class="hud-github" title="View on GitHub">
-        <svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor">
-          <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
-        </svg>
-      </a>
       <div id="db-selector-container">
         <select id="db-selector" title="Select Database">
           <option value="">Loading...</option>
         </select>
       </div>
-      <span id="fps-counter">-- FPS</span>
-      <span id="engine-info">Three.js</span>
       <div id="settings-container">
         <button id="settings-btn" title="Quality Settings">&#x2699;</button>
         <div id="settings-panel" class="hidden">
           <div class="settings-title">Quality</div>
-          <label class="settings-option"><input type="radio" name="quality" value="low"><span>Low</span><span class="settings-desc">No bloom, no particles</span></label>
-          <label class="settings-option"><input type="radio" name="quality" value="medium"><span>Medium</span><span class="settings-desc">Bloom, particles</span></label>
+          <label class="settings-option"><input type="radio" name="quality" value="low"><span>Low</span><span class="settings-desc">No bloom</span></label>
+          <label class="settings-option"><input type="radio" name="quality" value="medium"><span>Medium</span><span class="settings-desc">Bloom + particles</span></label>
           <label class="settings-option"><input type="radio" name="quality" value="high" checked><span>High</span><span class="settings-desc">Full effects</span></label>
-          <label class="settings-option"><input type="radio" name="quality" value="ultra"><span>Ultra</span><span class="settings-desc">Full-res, max glow</span></label>
+          <label class="settings-option"><input type="radio" name="quality" value="ultra"><span>Ultra</span><span class="settings-desc">Max glow</span></label>
+          <div class="settings-divider"></div>
+          <div class="settings-title">Resolution</div>
+          <label class="settings-option"><input type="radio" name="resolution" value="0"><span>Auto</span><span class="settings-desc">Device default</span></label>
+          <label class="settings-option"><input type="radio" name="resolution" value="0.5"><span>0.5x</span><span class="settings-desc">Performance</span></label>
+          <label class="settings-option"><input type="radio" name="resolution" value="1"><span>1x</span><span class="settings-desc">Balanced</span></label>
+          <label class="settings-option"><input type="radio" name="resolution" value="1.5"><span>1.5x</span><span class="settings-desc">Crisp</span></label>
+          <label class="settings-option"><input type="radio" name="resolution" value="2" ><span>2x</span><span class="settings-desc">Retina</span></label>
+          <div class="settings-divider"></div>
+          <div class="settings-meta">
+            <span id="fps-counter">-- FPS</span>
+            <span id="engine-info">Three.js</span>
+            <a href="https://github.com/kbanc85/claudia" target="_blank" rel="noopener" class="hud-github" title="View on GitHub">
+              <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor">
+                <path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.23.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/>
+              </svg>
+            </a>
+          </div>
         </div>
       </div>
     </div>
   </div>
 
-  <!-- Left sidebar -->
-  <div id="sidebar">
+  <!-- Sidebar (collapsible overlay) -->
+  <div id="sidebar" class="collapsed">
+    <div id="sidebar-header">
+      <span class="sidebar-title">Filters</span>
+      <button id="sidebar-close" title="Close (S)">&times;</button>
+    </div>
     <div id="search-container">
-      <input type="text" id="search-input" placeholder="Search entities & memories..." autocomplete="off">
+      <input type="text" id="search-input" placeholder="Search... ( / )" autocomplete="off">
       <div id="search-results"></div>
     </div>
     <div id="filters">
-      <h3>Node Types</h3>
+      <h3>Entity Types</h3>
       <div id="type-filters"></div>
       <h3>Memory Types</h3>
       <div id="memory-filters"></div>
     </div>
-    <div id="legend"></div>
+    <div id="legend">
+      <h3>Shapes</h3>
+    </div>
   </div>
 
+  <!-- Sidebar toggle button (always visible) -->
+  <button id="sidebar-toggle" title="Filters (S)">
+    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+      <path d="M22 3H2l8 9.46V19l4 2v-8.54L22 3z"/>
+    </svg>
+  </button>
+
   <!-- Right detail panel (slides in on node click) -->
   <div id="detail-panel" class="hidden">
-    <button id="detail-close">&times;</button>
+    <button id="detail-close" title="Close (Esc)">&times;</button>
     <div id="detail-content"></div>
   </div>
 
   <!-- Bottom timeline -->
   <div id="timeline-container">
+    <div id="timeline-density"></div>
     <div id="timeline-bar">
       <input type="range" id="timeline-slider" min="0" max="100" value="100">
       <div id="timeline-labels">
@@ -85,7 +115,14 @@
       <button id="timeline-play" title="Play/Pause">&#9654;</button>
       <button id="timeline-speed" title="Speed">1x</button>
     </div>
-    <div id="timeline-density"></div>
+  </div>
+
+  <!-- Keyboard hints (shown briefly on first load) -->
+  <div id="keyboard-hints" class="hidden">
+    <div class="hint"><kbd>S</kbd> Filters</div>
+    <div class="hint"><kbd>/</kbd> Search</div>
+    <div class="hint"><kbd>H</kbd> Design</div>
+    <div class="hint"><kbd>Esc</kbd> Clear</div>
   </div>
 
   <script type="module" src="/src/main.js"></script>