claude-cortex 1.7.2 → 1.8.1

package/scripts/pre-compact-hook.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Pre-compact hook for Claude Memory
+# This script runs before context compaction (manual or auto)
+# It outputs a reminder to save important context to memory
+
+# Read the hook input from stdin
+INPUT=$(cat)
+
+# Parse the trigger type (manual or auto)
+TRIGGER=$(echo "$INPUT" | grep -o '"trigger":"[^"]*"' | cut -d'"' -f4)
+
+# Output a system reminder that will be shown to Claude
+# Using stderr with exit 2 shows the message to Claude
+cat << 'EOF' >&2
+⚠️ CONTEXT COMPACTION IMMINENT
+
+Before this compaction completes, please use the memory tools to save any important context:
+
+1. Key decisions made in this session
+2. Important code patterns discovered
+3. User preferences or requirements learned
+4. Any pending tasks or TODOs
+
+Use `remember` to save important items, then compaction will proceed.
+EOF
+
+# Exit with 0 to allow compaction to proceed
+# (Exit 2 would block and show the message, but we want non-blocking)
+exit 0

package/scripts/session-start-hook.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * Session Start Hook for Claude Memory - Auto-Recall Context
+ *
+ * This script runs when Claude Code starts a new session and:
+ * 1. Detects the current project from the working directory
+ * 2. Retrieves relevant context from memory
+ * 3. Outputs it so Claude has immediate access to project knowledge
+ *
+ * The goal: Claude always starts with relevant project context.
+ */
+
+import Database from 'better-sqlite3';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// Database paths (with legacy fallback)
+const NEW_DB_DIR = join(homedir(), '.claude-cortex');
+const LEGACY_DB_DIR = join(homedir(), '.claude-memory');
+
+// Auto-detect: use new path if it exists, or if legacy doesn't exist (new install)
+function getDbPath() {
+  const newPath = join(NEW_DB_DIR, 'memories.db');
+  const legacyPath = join(LEGACY_DB_DIR, 'memories.db');
+  if (existsSync(newPath) || !existsSync(legacyPath)) {
+    return { dir: NEW_DB_DIR, path: newPath };
+  }
+  return { dir: LEGACY_DB_DIR, path: legacyPath };
+}
+
+const { dir: DB_DIR, path: DB_PATH } = getDbPath();
+
+// Configuration
+const MAX_CONTEXT_MEMORIES = 15;
+const MIN_SALIENCE_THRESHOLD = 0.3;
+
+// ==================== PROJECT DETECTION (Mirrors src/context/project-context.ts) ====================
+
+const SKIP_DIRECTORIES = [
+  'src', 'lib', 'dist', 'build', 'out',
+  'node_modules', '.git', '.next', '.cache',
+  'test', 'tests', '__tests__', 'spec',
+  'bin', 'scripts', 'config', 'public', 'static',
+];
+
+function extractProjectFromPath(path) {
+  if (!path) return null;
+
+  const segments = path.split(/[/\\]/).filter(Boolean);
+  if (segments.length === 0) return null;
+
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segment = segments[i];
+    if (!SKIP_DIRECTORIES.includes(segment.toLowerCase())) {
+      if (segment.startsWith('.')) continue;
+      return segment;
+    }
+  }
+
+  return null;
+}
+
+// ==================== CONTEXT RETRIEVAL ====================
+
+function getProjectContext(db, project) {
+  const memories = [];
+
+  // Get high-priority memories for this project
+  const highPriority = db.prepare(`
+    SELECT id, title, content, category, type, salience, tags, created_at
+    FROM memories
+    WHERE (project = ? OR project IS NULL)
+      AND salience >= ?
+      AND type IN ('long_term', 'episodic')
+    ORDER BY salience DESC, last_accessed DESC
+    LIMIT ?
+  `).all(project, MIN_SALIENCE_THRESHOLD, MAX_CONTEXT_MEMORIES);
+
+  memories.push(...highPriority);
+
+  // If we don't have enough, get recent memories too
+  if (memories.length < 5) {
+    const recent = db.prepare(`
+      SELECT id, title, content, category, type, salience, tags, created_at
+      FROM memories
+      WHERE (project = ? OR project IS NULL)
+        AND id NOT IN (${memories.map(m => m.id).join(',') || '0'})
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(project, 5 - memories.length);
+
+    memories.push(...recent);
+  }
+
+  return memories;
+}
+
+function formatContext(memories, project) {
+  if (memories.length === 0) {
+    return null;
+  }
+
+  const lines = [
+    `# Project Context: ${project}`,
+    '',
+  ];
+
+  // Group by category
+  const byCategory = {};
+  for (const mem of memories) {
+    const cat = mem.category || 'note';
+    if (!byCategory[cat]) byCategory[cat] = [];
+    byCategory[cat].push(mem);
+  }
+
+  // Priority order for categories
+  const categoryOrder = ['architecture', 'pattern', 'preference', 'error', 'context', 'learning', 'note', 'todo'];
+
+  for (const cat of categoryOrder) {
+    if (!byCategory[cat] || byCategory[cat].length === 0) continue;
+
+    const categoryTitle = cat.charAt(0).toUpperCase() + cat.slice(1);
+    lines.push(`## ${categoryTitle}`);
+
+    for (const mem of byCategory[cat]) {
+      const salience = Math.round(mem.salience * 100);
+      lines.push(`- **${mem.title}** (${salience}% salience)`);
+      // Truncate long content
+      const content = mem.content.length > 200
+        ? mem.content.slice(0, 200) + '...'
+        : mem.content;
+      lines.push(`  ${content}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// ==================== MAIN HOOK LOGIC ====================
+
+let input = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('readable', () => {
+  let chunk;
+  while ((chunk = process.stdin.read()) !== null) {
+    input += chunk;
+  }
+});
+
+process.stdin.on('end', () => {
+  try {
+    const hookData = JSON.parse(input || '{}');
+    const project = extractProjectFromPath(hookData.cwd || process.cwd());
+
+    if (!project) {
+      // No project detected, skip context retrieval
+      process.exit(0);
+    }
+
+    // Check if database exists
+    if (!existsSync(DB_PATH)) {
+      console.error('[session-start] Memory database not found, skipping context retrieval');
+      process.exit(0);
+    }
+
+    // Connect to database (read-only to avoid contention)
+    // timeout: 5000ms to handle busy database during concurrent access
+    const db = new Database(DB_PATH, { readonly: true, timeout: 5000 });
+
+    // Get project context
+    const memories = getProjectContext(db, project);
+    const context = formatContext(memories, project);
+
+    db.close();
+
+    // Proactive memory instructions
+    const proactiveInstructions = `
+## IMPORTANT: Proactive Memory Use
+
+You have access to a persistent memory system. Use it proactively:
+
+**ALWAYS use \`remember\` immediately when:**
+- Making architecture/design decisions
+- Fixing bugs (capture the root cause and solution)
+- Learning something new about the codebase
+- User states a preference
+- Completing significant features
+
+**Don't wait** - call \`remember\` right after the event, not at the end of the session.
+`;
+
+    if (context) {
+      // Output context to stdout - this will be shown to Claude
+      console.log(`
+🧠 CLAUDE CORTEX - Project "${project}"
+
+${context}
+${proactiveInstructions}
+`);
+      console.error(`[claude-cortex] Session start: loaded ${memories.length} memories for "${project}"`);
+    } else {
+      console.log(`
+🧠 CLAUDE CORTEX - New project "${project}"
+
+No stored memories yet for this project.
+${proactiveInstructions}
+`);
+      console.error(`[claude-cortex] Session start: no memories found for "${project}"`);
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error(`[session-start] Error: ${error.message}`);
+    process.exit(0); // Don't block session start on errors
+  }
+});

package/scripts/start-dashboard.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# Claude Memory Dashboard Startup Script
+# Starts both the API server and Next.js dashboard
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+LOG_DIR="$HOME/.claude-memory/logs"
+
+# Create log directory
+mkdir -p "$LOG_DIR"
+
+# Kill any existing instances
+pkill -f "node.*visualization-server" 2>/dev/null
+pkill -f "next-server.*3030" 2>/dev/null
+
+# Wait for processes to stop
+sleep 1
+
+# Start API server (port 3001)
+cd "$PROJECT_DIR"
+nohup npm run dev:api > "$LOG_DIR/api-server.log" 2>&1 &
+API_PID=$!
+echo "API server started (PID: $API_PID)"
+
+# Wait for API to be ready
+sleep 2
+
+# Start Next.js dashboard (port 3030)
+cd "$PROJECT_DIR/dashboard"
+nohup npm run dev > "$LOG_DIR/dashboard.log" 2>&1 &
+DASHBOARD_PID=$!
+echo "Dashboard started (PID: $DASHBOARD_PID)"
+
+# Save PIDs for later shutdown
+echo "$API_PID" > "$LOG_DIR/api-server.pid"
+echo "$DASHBOARD_PID" > "$LOG_DIR/dashboard.pid"
+
+echo "Claude Memory Dashboard running:"
+echo "  - API: http://localhost:3001"
+echo "  - Dashboard: http://localhost:3030"
+echo "  - Logs: $LOG_DIR"

package/scripts/stop-dashboard.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Stop Claude Memory Dashboard
+
+LOG_DIR="$HOME/.claude-memory/logs"
+
+# Kill by PID files if they exist
+if [ -f "$LOG_DIR/api-server.pid" ]; then
+  kill $(cat "$LOG_DIR/api-server.pid") 2>/dev/null
+  rm "$LOG_DIR/api-server.pid"
+fi
+
+if [ -f "$LOG_DIR/dashboard.pid" ]; then
+  kill $(cat "$LOG_DIR/dashboard.pid") 2>/dev/null
+  rm "$LOG_DIR/dashboard.pid"
+fi
+
+# Also kill by process name as fallback
+pkill -f "node.*visualization-server" 2>/dev/null
+pkill -f "next-server.*3030" 2>/dev/null
+
+echo "Claude Memory Dashboard stopped"