get-claudia 1.40.2 → 1.40.4

package/bin/index.js

@@ -178,6 +178,9 @@ async function main() {
   // Show what's new in this release
   showWhatsNew(isUpgrade);
 
+  // Install brain visualizer to ~/.claudia/visualizer/
+  installVisualizer();
+
   // Helper: seed demo database using spawn (safe, no shell injection)
   function seedDemoDatabase(targetPath, mcpPath, callback) {
     console.log(`\n${colors.cyan}Seeding demo database...${colors.reset}`);
@@ -466,6 +469,37 @@ ${cdStep}  ${colors.cyan}claude${colors.reset}
   }
 }
 
+function installVisualizer() {
+  const vizSrc = join(__dirname, '..', 'visualizer');
+  if (!existsSync(vizSrc)) return; // not bundled in this release
+
+  const vizDest = join(homedir(), '.claudia', 'visualizer');
+  try {
+    mkdirSync(vizDest, { recursive: true });
+    cpSync(vizSrc, vizDest, { recursive: true, force: true });
+    console.log(`${colors.green}✓${colors.reset} Brain visualizer installed at ~/.claudia/visualizer/`);
+
+    // Run npm install --production in background (non-blocking)
+    const npmCmd = isWindows ? 'npm.cmd' : 'npm';
+    const npmProc = spawn(npmCmd, ['install', '--production'], {
+      cwd: vizDest,
+      stdio: 'pipe',
+    });
+    npmProc.on('close', (code) => {
+      if (code !== 0) {
+        // Non-fatal: user can run npm install manually
+        process.stderr.write(`${colors.yellow}!${colors.reset} Visualizer npm install failed (run "npm install" in ~/.claudia/visualizer/ to fix)\n`);
+      }
+    });
+    npmProc.on('error', () => {
+      // npm not found or spawn failed — non-fatal
+    });
+  } catch (err) {
+    // Non-fatal: visualizer is optional
+    console.log(`${colors.dim}  Brain visualizer install skipped: ${err.message}${colors.reset}`);
+  }
+}
+
 function showWhatsNew(isUpgrade) {
   const c = colors.cyan;
   const y = colors.yellow;

package/memory-daemon/claudia_memory/mcp/server.py

@@ -1915,7 +1915,6 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 episode_id = arguments.get("episode_id")
                 svc = get_remember_service()
                 if episode_id is None:
-                    from datetime import datetime
                     episode_id = svc.db.insert("episodes", {
                         "started_at": datetime.utcnow().isoformat(),
                         "source": "claude_code",
@@ -1924,7 +1923,6 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
                 else:
                     episode = svc.db.get_one("episodes", where="id = ?", where_params=(episode_id,))
                     if not episode:
-                        from datetime import datetime
                         new_id = svc.db.insert("episodes", {
                             "started_at": datetime.utcnow().isoformat(),
                             "source": arguments.get("source", "claude_code"),
@@ -2724,7 +2722,6 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> CallToolResult:
 
             elif name == "memory.upcoming":
                 _coerce_int(arguments, "days")
-                from ..services.recall import recall_upcoming_deadlines
                 days = arguments.get("days", 14)
                 include_overdue = arguments.get("include_overdue", True)
                 results = recall_upcoming_deadlines(days, include_overdue=include_overdue)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.40.2",
+  "version": "1.40.4",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",
@@ -32,7 +32,8 @@
     "bin",
     "template-v2",
     "memory-daemon",
-    "assets"
+    "assets",
+    "visualizer"
   ],
   "engines": {
     "node": ">=18.0.0"

package/template-v2/.claude/skills/brain/SKILL.md

@@ -6,91 +6,39 @@ effort-level: medium
 
 # Brain
 
-Launch the Claudia Brain Visualizer, a real-time 3D visualization of my memory system showing entities, relationships, memories, patterns, and predictions as an interactive force-directed graph.
+Launch the Claudia Brain Visualizer, a real-time 3D cosmos visualization of my memory system showing entities, relationships, memories, and patterns as a swirling interactive force-directed graph.
 
 **Triggers:** `/brain`, "show me your brain", "visualize memory", "open the brain", "memory graph"
 
 ---
 
-## Prerequisites
+## Overview
 
-The visualizer requires:
-1. **Memory daemon** running on port 3848 (handles embeddings)
-2. **API server** running on port 3849 (serves graph data from database)
-3. **Vite dev server** running on port 5173/5174 (Three.js frontend)
-
-The API server must be started with `--project-dir` pointing to the current Claudia installation to access the correct per-project database.
+The visualizer is a single Express server (`server.js`) in `~/.claudia/visualizer/` that serves both the API (reads SQLite directly) and the pre-built 3D frontend from `dist/`. One process, one port (3849).
 
 ---
 
 ## Launch
 
-### Step 1: Identify the current project directory
-
-The project directory is the Claudia installation root (where `context/me.md` lives). This is needed for database isolation.
-
-```bash
-# The Claudia installation directory (where this command is being run from)
-PROJECT_DIR="$(pwd)"
-echo "PROJECT_DIR:$PROJECT_DIR"
-```
-
-### Step 2: Check if visualizer frontend is already running
-
-```bash
-if curl -s http://localhost:5173 > /dev/null 2>&1; then
-  echo "FRONTEND_RUNNING:5173"
-elif curl -s http://localhost:5174 > /dev/null 2>&1; then
-  echo "FRONTEND_RUNNING:5174"
-else
-  echo "FRONTEND_NOT_RUNNING"
-fi
-```
-
-### Step 3: Check if API server is running
+### Step 1: Check if already running
 
 ```bash
 if curl -s http://localhost:3849/health > /dev/null 2>&1; then
-  echo "API_RUNNING"
-else
-  echo "API_NOT_RUNNING"
-fi
-```
-
-### Step 4: Check if memory daemon is running
-
-```bash
-if curl -s http://localhost:3848/health > /dev/null 2>&1; then
-  echo "DAEMON_RUNNING"
+  echo "ALREADY_RUNNING"
 else
-  echo "DAEMON_NOT_RUNNING"
+  echo "NOT_RUNNING"
 fi
 ```
 
-### Step 5: Find the visualizer directories
+### Step 2: Find the visualizer directory
 
 ```bash
 VISUALIZER_DIR=""
-BACKEND_DIR=""
-
-# Find Three.js frontend
-for dir in \
-  "$HOME/.claudia/visualizer-threejs" \
-  "$(dirname "$(which get-claudia 2>/dev/null)")/../lib/node_modules/get-claudia/visualizer-threejs" \
-  "$(npm root -g 2>/dev/null)/get-claudia/visualizer-threejs"; do
-  if [ -d "$dir" ] && [ -f "$dir/package.json" ]; then
-    VISUALIZER_DIR="$dir"
-    break
-  fi
-done
-
-# Find API backend (in visualizer/ sibling directory)
 for dir in \
   "$HOME/.claudia/visualizer" \
-  "$(dirname "$(which get-claudia 2>/dev/null)")/../lib/node_modules/get-claudia/visualizer" \
   "$(npm root -g 2>/dev/null)/get-claudia/visualizer"; do
   if [ -d "$dir" ] && [ -f "$dir/server.js" ]; then
-    BACKEND_DIR="$dir"
+    VISUALIZER_DIR="$dir"
     break
   fi
 done
@@ -100,75 +48,39 @@ if [ -z "$VISUALIZER_DIR" ]; then
 else
   echo "VISUALIZER_FOUND:$VISUALIZER_DIR"
 fi
-
-if [ -z "$BACKEND_DIR" ]; then
-  echo "BACKEND_NOT_FOUND"
-else
-  echo "BACKEND_FOUND:$BACKEND_DIR"
-fi
 ```
 
-### Step 6: Start API backend if not running
-
-If **API_NOT_RUNNING** and **BACKEND_FOUND**:
+### Step 3: Start the server (if NOT_RUNNING and VISUALIZER_FOUND)
 
 ```bash
-cd "$BACKEND_DIR"
+PROJECT_DIR="$(pwd)"
+cd "$VISUALIZER_DIR"
 
 # Install deps if needed
 if [ ! -d "node_modules" ]; then
-  echo "Installing backend dependencies..."
-  npm install 2>&1
+  echo "Installing dependencies..."
+  npm install --production 2>&1
 fi
 
-# Start API server with project directory for database isolation
-nohup node server.js --project-dir "$PROJECT_DIR" > /tmp/claudia-brain-api.log 2>&1 &
-API_PID=$!
+# Start server with --open to auto-launch browser
+nohup node server.js --project-dir "$PROJECT_DIR" --open > /tmp/claudia-brain.log 2>&1 &
 sleep 2
 
-# Check if started successfully
+# Verify it started
 if curl -s http://localhost:3849/health > /dev/null 2>&1; then
-  echo "API_STARTED"
+  echo "STARTED"
 else
-  echo "API_FAILED"
-  tail -10 /tmp/claudia-brain-api.log
+  echo "FAILED"
+  tail -10 /tmp/claudia-brain.log
 fi
 ```
 
-### Step 7: Start frontend if not running
-
-If **FRONTEND_NOT_RUNNING** and **VISUALIZER_FOUND**:
-
-```bash
-cd "$VISUALIZER_DIR"
-
-# Install deps if needed
-if [ ! -d "node_modules" ]; then
-  echo "Installing frontend dependencies..."
-  npm install 2>&1
-fi
-
-# Start Vite dev server in background
-nohup npm run dev > /tmp/claudia-brain.log 2>&1 &
-BRAIN_PID=$!
-sleep 3
+### Step 4: Open browser (if ALREADY_RUNNING)
 
-# Check if started successfully
-if curl -s http://localhost:5173 > /dev/null 2>&1; then
-  echo "FRONTEND_STARTED:5173"
-elif curl -s http://localhost:5174 > /dev/null 2>&1; then
-  echo "FRONTEND_STARTED:5174"
-else
-  echo "FRONTEND_FAILED"
-  tail -20 /tmp/claudia-brain.log
-fi
-```
-
-### Step 8: Open in browser
+If the server was already running, just open the browser:
 
 ```bash
-PORT="${PORT:-5173}"
-open "http://localhost:$PORT" 2>/dev/null || xdg-open "http://localhost:$PORT" 2>/dev/null || echo "OPEN_MANUALLY:$PORT"
+open "http://localhost:3849" 2>/dev/null || xdg-open "http://localhost:3849" 2>/dev/null || echo "OPEN_MANUALLY:http://localhost:3849"
 ```
 
 ---
@@ -177,69 +89,54 @@ open "http://localhost:$PORT" 2>/dev/null || xdg-open "http://localhost:$PORT" 2
 
 **If already running:**
 ```
-Your brain is already live at http://localhost:[PORT]
+Your brain is live at http://localhost:3849
 ```
 
 **If started successfully:**
 ```
 **Brain Visualizer**
-Launched at http://localhost:[PORT]
+Live at http://localhost:3849
 
 Viewing database for: [PROJECT_DIR]
 
 What you're seeing:
-- **Entities** (people, orgs, projects, concepts) as colored nodes
-- **Memories** as smaller particles orbiting connected entities
-- **Relationships** as curved edges between entities
+- **Entities** (people, orgs, projects, concepts) as colored nodes, size scales with importance
+- **Relationships** as arcing edges with traveling pulse particles
 - **Patterns** as wireframe clusters
+- **Starfield** background, the galaxy is just ambiance
 
 **Controls:**
-- Click any node for details
-- Press **H** to open the design panel (tweak colors, bloom, animations)
-- Use the search bar to find specific entities
-- The graph updates in real-time as I learn
+- Click any node to see details, memories, and relationships
+- Search bar (top left) to find specific entities, camera flies to matches
+- H = toggle HUD, R = reset camera, F = fullscreen, Esc = close panel
+- The graph updates live as I learn new things
 ```
 
-**If daemon not running:**
-```
-The memory daemon isn't running. Start it first:
-
-```bash
-cd ~/.claudia && python -m claudia_memory
+**If visualizer not found:**
 ```
+The Brain Visualizer isn't installed at ~/.claudia/visualizer/.
 
-Then try `/brain` again.
+To install: run `npx get-claudia` again, or manually copy the visualizer directory:
+1. Copy `visualizer/` from the get-claudia package to `~/.claudia/visualizer/`
+2. Run `npm install --production` there
+3. Try `/brain` again
 ```
 
-**If API server failed:**
+**If server failed to start:**
 ```
-The API server couldn't start. Check the log:
+The server couldn't start. Check the log:
 ```bash
-tail -50 /tmp/claudia-brain-api.log
+tail -50 /tmp/claudia-brain.log
 ```
 
 Common issues:
-- Port 3849 already in use
-- Database not found for this project
-- Missing node_modules (run `npm install` in the visualizer directory)
-```
-
-**If visualizer not found:**
+- Port 3849 already in use (kill the old process first)
+- Database not found for this project (make sure --project-dir is correct)
+- Missing node_modules (run `npm install --production` in ~/.claudia/visualizer/)
 ```
-The Brain Visualizer isn't installed. It ships with the visualizer and visualizer-threejs directories in the Claudia package.
-
-To install manually:
-1. Copy visualizer/ to ~/.claudia/visualizer
-2. Copy visualizer-threejs/ to ~/.claudia/visualizer-threejs
-3. Run `npm install` in both directories
-4. Try `/brain` again
-```
-
-**If frontend failed:**
-Show the log output and suggest checking `/tmp/claudia-brain.log`.
 
 ---
 
 ## Tone
 
-Treat this like showing someone a cool feature. Be a little proud of it. "Want to see what your memory graph looks like?" energy.
+Treat this like showing someone something cool. A little proud of it. "Want to see what your memory graph looks like?" energy.

package/visualizer/README.md

@@ -0,0 +1,103 @@
+# Claudia Brain Visualizer
+
+Real-time 3D visualization of Claudia's memory system. Entities, relationships, memories, patterns, and predictions rendered as an interactive force-directed graph with semantic clustering.
+
+## Quick Start
+
+```bash
+cd visualizer
+npm install
+node server.js
+# Open http://localhost:3849
+```
+
+The server auto-detects your Claudia memory database at `~/.claudia/memory/`.
+
+### Options
+
+```
+--port 3849           Server port (default: 3849)
+--project-dir /path   Use project-specific database (hashed like the daemon)
+--db /path/to/db      Direct path to a .db file
+```
+
+### From a Claudia session
+
+```
+/brain
+```
+
+## What You See
+
+### Nodes
+
+| Type | Shape | Color |
+|------|-------|-------|
+| Person | Sphere | Warm gold |
+| Organization | Cube | Blue |
+| Project | Octahedron | Green |
+| Concept | Icosahedron | Purple |
+| Location | Sphere + rings | Orange |
+| Memory (fact) | Particle | White |
+| Memory (commitment) | Particle (pulsing) | Red |
+| Memory (learning) | Particle | Green |
+| Pattern | Wireframe icosahedron | Purple (breathing) |
+
+Node size scales with `sqrt(importance)`. Opacity fades for items not accessed in 90+ days.
+
+### Edges
+
+- **Entity relationships:** Thickness = strength, directional particles for forward edges
+- **Memory links:** Thin lines connecting memories to related entities
+- **Historical relationships:** Dashed ghost edges (toggle with `?historical=true`)
+
+### Real-Time Updates
+
+The visualizer polls the database every 500ms via SSE. When Claudia learns something new in another session:
+
+- New memories spawn with a flash animation
+- Recalled memories pulse and brighten
+- LLM-improved memories shimmer with golden aura
+- New relationships draw in with growing edges
+- Superseded relationships fade to dashed ghosts
+
+### Controls
+
+- **Click** a node to see details (memories, relationships, documents)
+- **Search** entities and memories in the sidebar
+- **Filter** by node type and memory type
+- **Timeline** scrubber to view the graph at any point in time
+- **Drag** to rotate, scroll to zoom
+
+## Architecture
+
+```
+server.js          Express on :3849, static files + API
+lib/database.js    Read-only SQLite (WAL mode), workspace hash
+lib/graph.js       SQL -> graph JSON (nodes + edges)
+lib/projection.js  UMAP 384-dim -> 3D (with graceful fallback)
+lib/events.js      SSE stream, 500ms change detection
+public/            Vanilla JS + 3d-force-graph (zero build step)
+```
+
+The visualizer opens the database in **read-only mode** and never interferes with the running memory daemon.
+
+## API
+
+| Endpoint | Purpose |
+|----------|---------|
+| `GET /health` | Server status + entity count |
+| `GET /api/graph` | Full graph (nodes + edges + UMAP positions) |
+| `GET /api/graph?historical=true` | Include superseded relationships |
+| `GET /api/stats` | Counts for HUD overlay |
+| `GET /api/entity/:id` | Entity detail with memories, relationships, documents |
+| `GET /api/timeline?start=&end=` | Events for timeline scrubber |
+| `GET /api/events` | SSE stream for real-time updates |
+
+## Schema Compatibility
+
+The visualizer detects available database columns at startup and adapts queries accordingly. It works with any schema version from v1 through v8+:
+
+- Pre-v5: No verification_status on memories (defaults to 'pending')
+- Pre-v7: No documents table (documents section hidden)
+- Pre-v8: No bi-temporal relationships (no historical toggle)