claude-memory-agent 2.0.0

package/bin/cli.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Memory Agent CLI
+ *
+ * This is the npm entry point that wraps the Python CLI.
+ * Usage:
+ *   claude-memory-agent install   - Run installation wizard
+ *   claude-memory-agent start     - Start the agent
+ *   claude-memory-agent stop      - Stop the agent
+ *   claude-memory-agent status    - Check status
+ *   claude-memory-agent dashboard - Open dashboard
+ */
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const AGENT_DIR = path.dirname(__dirname);
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+
+// 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']
+            });
+            if (result.includes('Python 3')) {
+                return cmd;
+            }
+        } catch (e) {
+            continue;
+        }
+    }
+    return null;
+}
+
+// Check if Python dependencies are installed
+function checkDependencies(python) {
+    try {
+        execSync(`${python} -c "import fastapi, uvicorn, dotenv"`, {
+            cwd: AGENT_DIR,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+// Install Python dependencies
+function installDependencies(python) {
+    console.log('Installing Python dependencies...');
+    try {
+        execSync(`${python} -m pip install -r requirements.txt -q`, {
+            cwd: AGENT_DIR,
+            stdio: 'inherit'
+        });
+        return true;
+    } catch (e) {
+        console.error('Failed to install dependencies:', e.message);
+        return false;
+    }
+}
+
+// Run Python script
+function runPython(script, scriptArgs = []) {
+    const python = getPython();
+
+    if (!python) {
+        console.error('Error: Python 3 is required but not found.');
+        console.error('Please install Python 3.9+ from https://python.org/');
+        process.exit(1);
+    }
+
+    const proc = spawn(python, [script, ...scriptArgs], {
+        cwd: AGENT_DIR,
+        stdio: 'inherit',
+        shell: process.platform === 'win32'
+    });
+
+    proc.on('close', (code) => {
+        process.exit(code || 0);
+    });
+
+    proc.on('error', (err) => {
+        console.error('Failed to start:', err.message);
+        process.exit(1);
+    });
+}
+
+// Print help
+function printHelp() {
+    console.log(`
+Claude Memory Agent v2.0.0
+Persistent semantic memory for Claude Code sessions
+
+USAGE:
+  claude-memory-agent <command> [options]
+
+COMMANDS:
+  install     Run the installation wizard
+  start       Start the memory agent in background
+  stop        Stop the running agent
+  status      Check if agent is running
+  dashboard   Open the web dashboard
+  logs        Show recent log output
+  help        Show this help message
+
+QUICK START:
+  1. claude-memory-agent install   # Configure everything
+  2. claude-memory-agent start     # Start the agent
+  3. claude-memory-agent dashboard # Open web UI
+
+REQUIREMENTS:
+  - Python 3.9+
+  - Ollama with nomic-embed-text model (for embeddings)
+  - Claude Code (for full integration)
+
+For more info: https://github.com/yourusername/claude-memory-agent
+`);
+}
+
+// Main
+function main() {
+    switch (command) {
+        case 'install':
+        case 'setup':
+            runPython('install.py', args.slice(1));
+            break;
+
+        case 'start':
+            runPython('memory-agent', ['start', ...args.slice(1)]);
+            break;
+
+        case 'stop':
+            runPython('memory-agent', ['stop', ...args.slice(1)]);
+            break;
+
+        case 'status':
+            runPython('memory-agent', ['status', ...args.slice(1)]);
+            break;
+
+        case 'dashboard':
+            runPython('memory-agent', ['dashboard', ...args.slice(1)]);
+            break;
+
+        case 'logs':
+            runPython('memory-agent', ['logs', ...args.slice(1)]);
+            break;
+
+        case 'run':
+        case 'server':
+            // Run directly (not in background)
+            runPython('main.py', args.slice(1));
+            break;
+
+        case 'help':
+        case '--help':
+        case '-h':
+            printHelp();
+            break;
+
+        case '--version':
+        case '-v':
+            console.log('claude-memory-agent v2.0.0');
+            break;
+
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.error('Run "claude-memory-agent help" for usage.');
+            process.exit(1);
+    }
+}
+
+main();

package/bin/postinstall.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * 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)
+ */
+
+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 (non-blocking)
+    log('Checking Ollama...');
+    const ollamaRunning = await checkOllama();
+    if (ollamaRunning) {
+        success('Ollama is running');
+    } else {
+        warn('Ollama not detected - embeddings require Ollama');
+        console.log('  Install from: https://ollama.ai/');
+        console.log('  Then run: ollama pull nomic-embed-text');
+    }
+
+    // Print next steps
+    header('Installation Complete!');
+    console.log('Next steps:');
+    console.log('');
+    console.log('  1. Run the setup wizard:');
+    console.log('     claude-memory-agent install');
+    console.log('');
+    console.log('  2. Start the agent:');
+    console.log('     claude-memory-agent start');
+    console.log('');
+    console.log('  3. Open the dashboard:');
+    console.log('     claude-memory-agent dashboard');
+    console.log('');
+
+    if (!ollamaRunning) {
+        console.log('  For embeddings, install and start Ollama:');
+        console.log('     ollama pull nomic-embed-text');
+        console.log('     ollama serve');
+        console.log('');
+    }
+}
+
+// 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');
+}

package/config.py

@@ -0,0 +1,104 @@
+"""
+Centralized configuration for Claude Memory Agent.
+
+All configuration is loaded from environment variables with sensible defaults.
+Use .env file for local overrides (not committed to git).
+
+Usage:
+    from config import config
+    print(config.PORT)
+    print(config.MEMORY_AGENT_URL)
+"""
+import os
+from pathlib import Path
+from typing import Optional
+from dotenv import load_dotenv
+
+# Load .env from agent directory
+AGENT_DIR = Path(__file__).parent.resolve()
+load_dotenv(AGENT_DIR / ".env")
+
+
+class Config:
+    """Configuration singleton with environment variable loading."""
+
+    def __init__(self):
+        # Paths (auto-detected from script location)
+        self.AGENT_DIR = AGENT_DIR
+        self.DATABASE_PATH = Path(os.getenv(
+            "DATABASE_PATH",
+            str(AGENT_DIR / "memories.db")
+        ))
+        self.INDEX_DIR = Path(os.getenv(
+            "INDEX_DIR",
+            str(AGENT_DIR / "indexes")
+        ))
+        self.LOG_FILE = AGENT_DIR / "memory-agent.log"
+        self.LOCK_FILE = AGENT_DIR / "memory-agent.lock"
+        self.PID_FILE = AGENT_DIR / "memory-agent.pid"
+
+        # Server configuration
+        self.HOST = os.getenv("HOST", "0.0.0.0")
+        self.PORT = int(os.getenv("PORT", "8102"))
+        self.MEMORY_AGENT_URL = os.getenv(
+            "MEMORY_AGENT_URL",
+            f"http://localhost:{self.PORT}"
+        )
+
+        # Ollama / Embeddings
+        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.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"))
+
+        # Database
+        self.USE_VECTOR_INDEX = os.getenv("USE_VECTOR_INDEX", "true").lower() == "true"
+        self.DB_POOL_SIZE = int(os.getenv("DB_POOL_SIZE", "5"))
+        self.DB_TIMEOUT = float(os.getenv("DB_TIMEOUT", "30.0"))
+        self.DB_MAX_RETRIES = int(os.getenv("DB_MAX_RETRIES", "3"))
+        self.DB_RETRY_BASE_DELAY = float(os.getenv("DB_RETRY_BASE_DELAY", "0.1"))
+
+        # Authentication
+        self.AUTH_ENABLED = os.getenv("AUTH_ENABLED", "false").lower() == "true"
+        self.AUTH_KEY_FILE = Path(os.getenv(
+            "AUTH_KEY_FILE",
+            str(Path.home() / ".claude" / "memory-agent-keys.json")
+        ))
+        self.AUTH_RATE_LIMIT = int(os.getenv("AUTH_RATE_LIMIT", "100"))
+        self.AUTH_RATE_WINDOW = int(os.getenv("AUTH_RATE_WINDOW", "60"))
+
+        # Logging
+        self.LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+
+        # Hook timeouts
+        self.API_TIMEOUT = int(os.getenv("API_TIMEOUT", "30"))
+
+    def get_health_url(self) -> str:
+        """Get the health check URL."""
+        return f"{self.MEMORY_AGENT_URL}/health"
+
+    def get_dashboard_url(self) -> str:
+        """Get the dashboard URL."""
+        return f"{self.MEMORY_AGENT_URL}/dashboard"
+
+    def to_dict(self) -> dict:
+        """Export configuration as dictionary (for debugging)."""
+        return {
+            key: str(value) if isinstance(value, Path) else value
+            for key, value in vars(self).items()
+            if not key.startswith("_")
+        }
+
+
+# Singleton instance
+config = Config()
+
+
+# Convenience exports for backwards compatibility
+PORT = config.PORT
+HOST = config.HOST
+MEMORY_AGENT_URL = config.MEMORY_AGENT_URL
+OLLAMA_HOST = config.OLLAMA_HOST
+EMBEDDING_MODEL = config.EMBEDDING_MODEL
+DATABASE_PATH = config.DATABASE_PATH