claude-memory-agent 2.1.0 → 2.2.0

package/bin/postinstall.js

@@ -1,270 +1,35 @@
 #!/usr/bin/env node
+'use strict';
 
 /**
  * Post-installation script for Claude Memory Agent
- *
- * This runs automatically after npm install to:
- * 1. Check Python availability
- * 2. Install Python dependencies
- * 3. Run the configuration wizard (if interactive)
+ * Dispatches to the onboarding wizard (interactive) or installs with defaults (CI/piped).
  */
 
-const { execSync, spawn } = require('child_process');
 const path = require('path');
-const fs = require('fs');
-const readline = require('readline');
 
-const AGENT_DIR = path.dirname(__dirname);
-
-// Colors for terminal output
-const colors = {
-    reset: '\x1b[0m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    red: '\x1b[31m',
-    cyan: '\x1b[36m',
-    bold: '\x1b[1m'
-};
-
-function log(msg) {
-    console.log(msg);
-}
-
-function success(msg) {
-    console.log(`${colors.green}✓${colors.reset} ${msg}`);
-}
-
-function warn(msg) {
-    console.log(`${colors.yellow}!${colors.reset} ${msg}`);
-}
-
-function error(msg) {
-    console.log(`${colors.red}✗${colors.reset} ${msg}`);
-}
-
-function header(msg) {
-    console.log(`\n${colors.bold}${colors.cyan}${msg}${colors.reset}\n`);
-}
-
-// Check Python availability
-function getPython() {
-    const pythonCommands = ['python3', 'python', 'py'];
-
-    for (const cmd of pythonCommands) {
-        try {
-            const result = execSync(`${cmd} --version`, {
-                encoding: 'utf8',
-                stdio: ['pipe', 'pipe', 'pipe']
-            });
-            const match = result.match(/Python (\d+)\.(\d+)/);
-            if (match) {
-                const major = parseInt(match[1]);
-                const minor = parseInt(match[2]);
-                if (major >= 3 && minor >= 9) {
-                    return { cmd, version: result.trim() };
-                }
-            }
-        } catch (e) {
-            continue;
-        }
-    }
-    return null;
-}
-
-// Check if Ollama is running
-function checkOllama() {
-    try {
-        const http = require('http');
-        return new Promise((resolve) => {
-            const req = http.get('http://localhost:11434/api/tags', { timeout: 2000 }, (res) => {
-                resolve(res.statusCode === 200);
-            });
-            req.on('error', () => resolve(false));
-            req.on('timeout', () => {
-                req.destroy();
-                resolve(false);
-            });
-        });
-    } catch (e) {
-        return Promise.resolve(false);
-    }
-}
-
-// Install Python dependencies
-function installPythonDeps(python) {
-    const requirementsPath = path.join(AGENT_DIR, 'requirements.txt');
-
-    if (!fs.existsSync(requirementsPath)) {
-        warn('requirements.txt not found, skipping Python dependencies');
-        return true;
-    }
-
-    log('Installing Python dependencies...');
-    try {
-        execSync(`${python} -m pip install -r requirements.txt -q --disable-pip-version-check`, {
-            cwd: AGENT_DIR,
-            stdio: ['pipe', 'pipe', 'pipe']
-        });
-        success('Python dependencies installed');
-        return true;
-    } catch (e) {
-        error('Failed to install Python dependencies');
-        console.log('  Run manually: pip install -r requirements.txt');
-        return false;
-    }
-}
-
-// Create .env file if it doesn't exist
-function createEnvFile() {
-    const envPath = path.join(AGENT_DIR, '.env');
-    const examplePath = path.join(AGENT_DIR, '.env.example');
-
-    if (fs.existsSync(envPath)) {
-        success('.env file already exists');
-        return true;
-    }
-
-    // Create basic .env
-    const envContent = `# Claude Memory Agent Configuration
-# Generated during npm install
-
-# Server
-PORT=8102
-HOST=0.0.0.0
-MEMORY_AGENT_URL=http://localhost:8102
-
-# Ollama
-OLLAMA_HOST=http://localhost:11434
-EMBEDDING_MODEL=nomic-embed-text
-
-# Database (relative to agent directory)
-DATABASE_PATH=${path.join(AGENT_DIR, 'memories.db').replace(/\\/g, '/')}
-
-# Logging
-LOG_LEVEL=INFO
-`;
-
-    try {
-        fs.writeFileSync(envPath, envContent);
-        success('Created .env configuration file');
-        return true;
-    } catch (e) {
-        warn('Could not create .env file');
-        return false;
-    }
-}
-
-// Main installation
 async function main() {
-    header('Claude Memory Agent - Post-Installation Setup');
-
-    // Check Python
-    log('Checking Python...');
-    const python = getPython();
-    if (!python) {
-        error('Python 3.9+ is required but not found');
-        console.log('\n  Please install Python from https://python.org/');
-        console.log('  Then run: claude-memory-agent install\n');
-        process.exit(1);
-    }
-    success(`Found ${python.version}`);
-
-    // Install Python dependencies
-    installPythonDeps(python.cmd);
-
-    // Create .env file
-    createEnvFile();
-
-    // Check Ollama
-    log('Checking Ollama...');
-    const ollamaRunning = await checkOllama();
-
-    if (ollamaRunning) {
-        success('Ollama is running');
-        // Check if model is installed
-        const modelInstalled = await checkOllamaModel();
-        if (modelInstalled) {
-            success('Embedding model is ready');
-        } else {
-            warn('Embedding model not found');
-        }
-    }
-
-    // Print next steps based on what's missing
-    header('Installation Complete!');
-
-    if (!ollamaRunning) {
-        // Ollama not installed - show big warning
-        console.log(`${colors.red}${colors.bold}╔════════════════════════════════════════════════════════════╗${colors.reset}`);
-        console.log(`${colors.red}${colors.bold}║  REQUIRED: Install Ollama for semantic search to work      ║${colors.reset}`);
-        console.log(`${colors.red}${colors.bold}╚════════════════════════════════════════════════════════════╝${colors.reset}`);
-        console.log('');
-        console.log('  Ollama is required for the memory agent to work properly.');
-        console.log('  Without it, semantic search will be disabled.');
-        console.log('');
-        console.log(`  ${colors.cyan}Step 1:${colors.reset} Download and install Ollama:`);
-        console.log(`          ${colors.bold}https://ollama.ai/download${colors.reset}`);
-        console.log('');
-        console.log(`  ${colors.cyan}Step 2:${colors.reset} After installing, open a terminal and run:`);
-        console.log(`          ${colors.bold}ollama pull nomic-embed-text${colors.reset}`);
-        console.log('');
-        console.log(`  ${colors.cyan}Step 3:${colors.reset} Start Ollama (it runs in background):`);
-        console.log(`          ${colors.bold}ollama serve${colors.reset}`);
-        console.log('');
-        console.log(`  ${colors.cyan}Step 4:${colors.reset} Then run the setup:`);
-        console.log(`          ${colors.bold}claude-memory-agent install${colors.reset}`);
-        console.log('');
-    } else {
-        // Ollama running - show normal next steps
-        console.log('Next steps:');
-        console.log('');
-        console.log('  1. Run the setup wizard:');
-        console.log(`     ${colors.bold}claude-memory-agent install${colors.reset}`);
-        console.log('');
-        console.log('  2. Start the agent:');
-        console.log(`     ${colors.bold}claude-memory-agent start${colors.reset}`);
-        console.log('');
-        console.log('  3. Open the dashboard:');
-        console.log(`     ${colors.bold}claude-memory-agent dashboard${colors.reset}`);
-        console.log('');
-    }
-}
-
-// Check if embedding model is installed in Ollama
-async function checkOllamaModel() {
+  // Skip in CI
+  if (process.env.CI) {
+    console.log('Skipping post-install in CI environment');
+    return;
+  }
+
+  try {
+    const { main: runOnboarding } = require('./onboarding');
+    await runOnboarding();
+  } catch (err) {
+    // Fallback: if onboarding deps missing, do basic setup
+    console.log('Running basic setup (onboarding dependencies not available)...');
     try {
-        const http = require('http');
-        return new Promise((resolve) => {
-            const req = http.get('http://localhost:11434/api/tags', { timeout: 2000 }, (res) => {
-                let data = '';
-                res.on('data', chunk => data += chunk);
-                res.on('end', () => {
-                    try {
-                        const json = JSON.parse(data);
-                        const models = json.models || [];
-                        const hasModel = models.some(m =>
-                            m.name && m.name.includes('nomic-embed-text')
-                        );
-                        resolve(hasModel);
-                    } catch (e) {
-                        resolve(false);
-                    }
-                });
-            });
-            req.on('error', () => resolve(false));
-            req.on('timeout', () => {
-                req.destroy();
-                resolve(false);
-            });
-        });
-    } catch (e) {
-        return false;
+      const { basicSetup } = require('./lib/installer');
+      await basicSetup(path.dirname(__dirname));
+    } catch (fallbackErr) {
+      console.log('Post-install: run "claude-memory-agent install" to complete setup.');
     }
+  }
 }
 
-// Run if not in CI/CD environment
-if (!process.env.CI && !process.env.npm_config_ignore_scripts) {
-    main().catch(console.error);
-} else {
-    console.log('Skipping post-install in CI environment');
-}
+main().catch(() => {
+  console.log('Post-install: run "claude-memory-agent install" to complete setup.');
+});

package/config.py

@@ -10,10 +10,13 @@ Usage:
     print(config.MEMORY_AGENT_URL)
 """
 import os
+import logging
 from pathlib import Path
 from typing import Optional
 from dotenv import load_dotenv
 
+logger = logging.getLogger(__name__)
+
 # Load .env from agent directory
 AGENT_DIR = Path(__file__).parent.resolve()
 load_dotenv(AGENT_DIR / ".env")
@@ -38,17 +41,18 @@ class Config:
         self.PID_FILE = AGENT_DIR / "memory-agent.pid"
 
         # Server configuration
-        self.HOST = os.getenv("HOST", "0.0.0.0")
+        self.HOST = os.getenv("HOST", "127.0.0.1")
         self.PORT = int(os.getenv("PORT", "8102"))
         self.MEMORY_AGENT_URL = os.getenv(
             "MEMORY_AGENT_URL",
             f"http://localhost:{self.PORT}"
         )
 
-        # Ollama / Embeddings
+        # Embeddings
+        self.EMBEDDING_PROVIDER = os.getenv("EMBEDDING_PROVIDER", "sentence-transformers")
         self.OLLAMA_HOST = os.getenv("OLLAMA_HOST", "http://localhost:11434")
-        self.EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "nomic-embed-text")
-        self.EMBEDDING_DIM = int(os.getenv("EMBEDDING_DIM", "768"))
+        self.EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "Alibaba-NLP/gte-large-en-v1.5")
+        self.EMBEDDING_DIM = int(os.getenv("EMBEDDING_DIM", "1024"))
         self.OLLAMA_HEALTH_TIMEOUT = float(os.getenv("OLLAMA_HEALTH_TIMEOUT", "2.0"))
         self.OLLAMA_HEALTH_CACHE_TTL = float(os.getenv("OLLAMA_HEALTH_CACHE_TTL", "30.0"))
 
@@ -68,12 +72,106 @@ class Config:
         self.AUTH_RATE_LIMIT = int(os.getenv("AUTH_RATE_LIMIT", "100"))
         self.AUTH_RATE_WINDOW = int(os.getenv("AUTH_RATE_WINDOW", "60"))
 
+        # Response size limits
+        self.MAX_RESPONSE_CHARS = int(os.getenv("MAX_RESPONSE_CHARS", "80000"))
+        self.CONTENT_TRUNCATE_LENGTH = int(os.getenv("CONTENT_TRUNCATE_LENGTH", "300"))
+        self.MIN_RESULT_COUNT = int(os.getenv("MIN_RESULT_COUNT", "3"))
+
         # Logging
         self.LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
 
+        # Memory decay
+        self.DECAY_ARCHIVE_THRESHOLD = float(os.getenv("DECAY_ARCHIVE_THRESHOLD", "0.1"))
+        self.DECAY_CHECK_INTERVAL_HOURS = int(os.getenv("DECAY_CHECK_INTERVAL_HOURS", "24"))
+
         # Hook timeouts
         self.API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
 
+        # CLaRa-inspired memory tiers
+        self.TIER_HOT_MAX_AGE_DAYS = int(os.getenv("TIER_HOT_MAX_AGE_DAYS", "14"))
+        self.TIER_HOT_MIN_IMPORTANCE = int(os.getenv("TIER_HOT_MIN_IMPORTANCE", "7"))
+        self.TIER_WARM_MAX_AGE_DAYS = int(os.getenv("TIER_WARM_MAX_AGE_DAYS", "90"))
+
+        # Memory consolidation
+        self.CONSOLIDATION_THRESHOLD = float(os.getenv("CONSOLIDATION_THRESHOLD", "0.85"))
+        self.CONSOLIDATION_MIN_GROUP = int(os.getenv("CONSOLIDATION_MIN_GROUP", "3"))
+        self.CONSOLIDATION_MAX_GROUP = int(os.getenv("CONSOLIDATION_MAX_GROUP", "20"))
+        self.CONSOLIDATION_MAX_PER_RUN = int(os.getenv("CONSOLIDATION_MAX_PER_RUN", "5"))
+        self.CONSOLIDATION_INTERVAL_HOURS = int(os.getenv("CONSOLIDATION_INTERVAL_HOURS", "12"))
+
+        # Embedding pipeline
+        self.EMBEDDING_CACHE_SIZE = int(os.getenv("EMBEDDING_CACHE_SIZE", "500"))
+        self.EMBEDDING_BATCH_SIZE = int(os.getenv("EMBEDDING_BATCH_SIZE", "10"))
+        self.EMBEDDING_PRECOMPUTE_INTERVAL = int(os.getenv("EMBEDDING_PRECOMPUTE_INTERVAL", "60"))
+
+        # Adaptive search ranking
+        self.DEFAULT_SEARCH_TEMPERATURE = float(os.getenv("DEFAULT_SEARCH_TEMPERATURE", "1.0"))
+
+        # Validate configuration
+        self._validate()
+
+    def _validate(self):
+        """Validate configuration values and warn on invalid settings."""
+        warnings = []
+
+        # Critical: port must be valid
+        if not (1 <= self.PORT <= 65535):
+            raise ValueError(f"PORT must be 1-65535, got {self.PORT}")
+
+        # Critical: pool size must be positive
+        if self.DB_POOL_SIZE < 1:
+            raise ValueError(f"DB_POOL_SIZE must be >= 1, got {self.DB_POOL_SIZE}")
+
+        # Critical: embedding provider must be valid
+        valid_providers = ("sentence-transformers", "ollama")
+        if self.EMBEDDING_PROVIDER not in valid_providers:
+            raise ValueError(f"EMBEDDING_PROVIDER must be one of {valid_providers}, got '{self.EMBEDDING_PROVIDER}'")
+
+        # Warnings for non-critical misconfigurations
+        if self.DB_TIMEOUT < 1.0:
+            warnings.append(f"DB_TIMEOUT={self.DB_TIMEOUT}s is very low, may cause spurious timeouts")
+
+        if self.DB_MAX_RETRIES < 0:
+            warnings.append(f"DB_MAX_RETRIES={self.DB_MAX_RETRIES} is negative, setting to 0")
+            self.DB_MAX_RETRIES = 0
+
+        if self.EMBEDDING_DIM not in (384, 768, 1024):
+            warnings.append(f"EMBEDDING_DIM={self.EMBEDDING_DIM} is unusual (expected 384/768/1024)")
+
+        if not (0.0 <= self.CONSOLIDATION_THRESHOLD <= 1.0):
+            warnings.append(f"CONSOLIDATION_THRESHOLD={self.CONSOLIDATION_THRESHOLD} out of range [0,1], clamping")
+            self.CONSOLIDATION_THRESHOLD = max(0.0, min(1.0, self.CONSOLIDATION_THRESHOLD))
+
+        if not (0.0 <= self.DECAY_ARCHIVE_THRESHOLD <= 1.0):
+            warnings.append(f"DECAY_ARCHIVE_THRESHOLD={self.DECAY_ARCHIVE_THRESHOLD} out of range [0,1], clamping")
+            self.DECAY_ARCHIVE_THRESHOLD = max(0.0, min(1.0, self.DECAY_ARCHIVE_THRESHOLD))
+
+        if not (0.0 <= self.DEFAULT_SEARCH_TEMPERATURE <= 2.0):
+            warnings.append(f"DEFAULT_SEARCH_TEMPERATURE={self.DEFAULT_SEARCH_TEMPERATURE} out of range [0,2], clamping")
+            self.DEFAULT_SEARCH_TEMPERATURE = max(0.0, min(2.0, self.DEFAULT_SEARCH_TEMPERATURE))
+
+        if self.MAX_RESPONSE_CHARS < 1000:
+            warnings.append(f"MAX_RESPONSE_CHARS={self.MAX_RESPONSE_CHARS} is very low, responses may be cut off")
+
+        if self.EMBEDDING_CACHE_SIZE < 0:
+            warnings.append(f"EMBEDDING_CACHE_SIZE={self.EMBEDDING_CACHE_SIZE} is negative, setting to 0")
+            self.EMBEDDING_CACHE_SIZE = 0
+
+        valid_log_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+        if self.LOG_LEVEL.upper() not in valid_log_levels:
+            warnings.append(f"LOG_LEVEL='{self.LOG_LEVEL}' is invalid, using INFO")
+            self.LOG_LEVEL = "INFO"
+
+        if self.TIER_HOT_MAX_AGE_DAYS >= self.TIER_WARM_MAX_AGE_DAYS:
+            warnings.append(
+                f"TIER_HOT_MAX_AGE_DAYS ({self.TIER_HOT_MAX_AGE_DAYS}) >= "
+                f"TIER_WARM_MAX_AGE_DAYS ({self.TIER_WARM_MAX_AGE_DAYS}), "
+                f"hot tier would overlap warm tier"
+            )
+
+        for w in warnings:
+            logger.warning(f"Config: {w}")
+
     def get_health_url(self) -> str:
         """Get the health check URL."""
         return f"{self.MEMORY_AGENT_URL}/health"
@@ -100,5 +198,6 @@ PORT = config.PORT
 HOST = config.HOST
 MEMORY_AGENT_URL = config.MEMORY_AGENT_URL
 OLLAMA_HOST = config.OLLAMA_HOST
+EMBEDDING_PROVIDER = config.EMBEDDING_PROVIDER
 EMBEDDING_MODEL = config.EMBEDDING_MODEL
 DATABASE_PATH = config.DATABASE_PATH