claude-memory-agent 2.2.3 → 3.0.0

package/bin/cli.js

@@ -3,158 +3,374 @@
 /**
  * Claude Memory Agent CLI
  *
- * This is the npm entry point that wraps the Python CLI.
+ * Cross-platform entry point that manages the Python memory agent server.
  * 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
+ *   claude-memory-agent start     - Start the agent in background
+ *   claude-memory-agent stop      - Stop the running agent
+ *   claude-memory-agent status    - Check if agent is running
+ *   claude-memory-agent dashboard - Open the web dashboard
  */
 
 const { spawn, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const http = require('http');
 
 const AGENT_DIR = path.dirname(__dirname);
+const PID_FILE = path.join(AGENT_DIR, 'memory-agent.pid');
+const LOG_FILE = path.join(AGENT_DIR, 'memory-agent.log');
+const ENV_FILE = path.join(AGENT_DIR, '.env');
 const args = process.argv.slice(2);
 const command = args[0] || 'help';
 
-// Check Python availability
-function getPython() {
-    const pythonCommands = ['python3', 'python', 'py'];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Read PORT from .env file, default 8102 */
+function getPort() {
+    try {
+        const env = fs.readFileSync(ENV_FILE, 'utf8');
+        const match = env.match(/^PORT=(\d+)/m);
+        if (match) return parseInt(match[1], 10);
+    } catch (_) {}
+    return parseInt(process.env.PORT || '8102', 10);
+}
+
+/** Read HOST from .env file, default 127.0.0.1 */
+function getHost() {
+    try {
+        const env = fs.readFileSync(ENV_FILE, 'utf8');
+        const match = env.match(/^HOST=(.+)/m);
+        if (match) {
+            const h = match[1].trim();
+            return (h === '0.0.0.0') ? 'localhost' : h;
+        }
+    } catch (_) {}
+    return 'localhost';
+}
 
-    for (const cmd of pythonCommands) {
+/** Detect Python 3 command */
+function getPython() {
+    const commands = ['python3', 'python', 'py'];
+    for (const cmd of commands) {
         try {
-            const result = execSync(`${cmd} --version`, {
+            const out = execSync(`${cmd} --version`, {
                 encoding: 'utf8',
-                stdio: ['pipe', 'pipe', 'pipe']
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: 5000,
             });
-            if (result.includes('Python 3')) {
-                return cmd;
-            }
-        } catch (e) {
-            continue;
-        }
+            if (out && out.includes('Python 3')) return cmd;
+        } catch (_) {}
     }
     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']
+/** Require Python or exit */
+function requirePython() {
+    const py = getPython();
+    if (!py) {
+        console.error('Error: Python 3 is required but not found.');
+        console.error('Install from: https://python.org/');
+        process.exit(1);
+    }
+    return py;
+}
+
+/** Run a Python script with inherited stdio */
+function runPython(script, scriptArgs = []) {
+    const python = requirePython();
+    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);
+    });
+}
+
+/** HTTP GET with timeout, resolves { ok, status, body } */
+function httpGet(url, timeout = 3000) {
+    return new Promise((resolve) => {
+        const req = http.get(url, { timeout }, (res) => {
+            let body = '';
+            res.on('data', (c) => (body += c));
+            res.on('end', () => resolve({ ok: res.statusCode === 200, status: res.statusCode, body }));
         });
+        req.on('error', () => resolve({ ok: false, status: 0, body: '' }));
+        req.on('timeout', () => { req.destroy(); resolve({ ok: false, status: 0, body: '' }); });
+    });
+}
+
+/** Check if the agent is responding on its health endpoint */
+async function isAgentRunning() {
+    const port = getPort();
+    const host = getHost();
+    const { ok } = await httpGet(`http://${host}:${port}/health`);
+    return ok;
+}
+
+/** Read PID from file */
+function readPid() {
+    try {
+        if (fs.existsSync(PID_FILE)) {
+            const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+            if (!isNaN(pid)) return pid;
+        }
+    } catch (_) {}
+    return null;
+}
+
+/** Check if a process with given PID is alive */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 = check existence
         return true;
-    } catch (e) {
+    } catch (_) {
         return false;
     }
 }
 
-// Install Python dependencies
-function installDependencies(python) {
-    console.log('Installing Python dependencies...');
+/** Kill a process by PID (cross-platform) */
+function killProcess(pid) {
     try {
-        execSync(`${python} -m pip install -r requirements.txt -q`, {
-            cwd: AGENT_DIR,
-            stdio: 'inherit'
-        });
+        if (process.platform === 'win32') {
+            execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'pipe' });
+        } else {
+            process.kill(pid, 'SIGTERM');
+        }
         return true;
-    } catch (e) {
-        console.error('Failed to install dependencies:', e.message);
+    } catch (_) {
         return false;
     }
 }
 
-// Run Python script
-function runPython(script, scriptArgs = []) {
-    const python = getPython();
+/** Open a URL in the default browser */
+function openBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start'
+        : 'xdg-open';
+    try {
+        execSync(`${cmd} ${url}`, { stdio: 'ignore', shell: true });
+    } catch (_) {
+        console.log(`Open in browser: ${url}`);
+    }
+}
 
-    if (!python) {
-        console.error('Error: Python 3 is required but not found.');
-        console.error('Please install Python 3.9+ from https://python.org/');
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+async function cmdStart() {
+    // Already running?
+    if (await isAgentRunning()) {
+        console.log('Memory agent is already running.');
+        return;
+    }
+
+    const python = requirePython();
+    const mainPy = path.join(AGENT_DIR, 'main.py');
+
+    if (!fs.existsSync(mainPy)) {
+        console.error('Error: main.py not found in ' + AGENT_DIR);
         process.exit(1);
     }
 
-    const proc = spawn(python, [script, ...scriptArgs], {
+    console.log('Starting Memory Agent...');
+
+    const logFd = fs.openSync(LOG_FILE, 'w');
+    const spawnOpts = {
         cwd: AGENT_DIR,
-        stdio: 'inherit',
-        shell: process.platform === 'win32'
-    });
+        stdio: ['ignore', logFd, logFd],
+        detached: true,
+        shell: process.platform === 'win32',
+    };
+
+    // Windows needs special flags
+    if (process.platform === 'win32') {
+        spawnOpts.windowsHide = true;
+    }
 
-    proc.on('close', (code) => {
-        process.exit(code || 0);
-    });
+    const child = spawn(python, [mainPy], spawnOpts);
+    child.unref();
 
-    proc.on('error', (err) => {
-        console.error('Failed to start:', err.message);
-        process.exit(1);
-    });
+    // Write PID
+    fs.writeFileSync(PID_FILE, String(child.pid), 'utf8');
+
+    // Wait up to 8 seconds for health check
+    for (let i = 0; i < 16; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        if (await isAgentRunning()) {
+            const port = getPort();
+            console.log(`Memory agent started (PID: ${child.pid}, port: ${port})`);
+            fs.closeSync(logFd);
+            return;
+        }
+    }
+
+    fs.closeSync(logFd);
+    console.log(`Agent started (PID: ${child.pid}) but health check not responding yet.`);
+    console.log(`Check logs: claude-memory-agent logs`);
+}
+
+async function cmdStop() {
+    const pid = readPid();
+
+    if (!pid) {
+        // Try health check anyway
+        if (await isAgentRunning()) {
+            console.log('Agent is running but no PID file found. Cannot stop automatically.');
+            console.log('Find the process manually and kill it.');
+        } else {
+            console.log('Memory agent is not running.');
+        }
+        return;
+    }
+
+    if (!isProcessAlive(pid)) {
+        console.log('Memory agent is not running (stale PID file).');
+        try { fs.unlinkSync(PID_FILE); } catch (_) {}
+        return;
+    }
+
+    console.log(`Stopping Memory Agent (PID: ${pid})...`);
+    if (killProcess(pid)) {
+        // Wait for it to die
+        for (let i = 0; i < 10; i++) {
+            await new Promise((r) => setTimeout(r, 300));
+            if (!isProcessAlive(pid)) {
+                console.log('Memory agent stopped.');
+                try { fs.unlinkSync(PID_FILE); } catch (_) {}
+                return;
+            }
+        }
+        console.log('Sent kill signal but process may still be shutting down.');
+    } else {
+        console.log('Failed to stop agent. Try killing PID ' + pid + ' manually.');
+    }
+}
+
+async function cmdStatus() {
+    const port = getPort();
+    const host = getHost();
+    const pid = readPid();
+    const running = await isAgentRunning();
+
+    if (running) {
+        console.log(`Memory agent is RUNNING`);
+        console.log(`  URL:  http://${host}:${port}`);
+        if (pid) console.log(`  PID:  ${pid}`);
+    } else {
+        console.log('Memory agent is NOT running.');
+        if (pid && isProcessAlive(pid)) {
+            console.log(`  PID ${pid} exists but health check failed.`);
+            console.log('  Check logs: claude-memory-agent logs');
+        }
+    }
+}
+
+async function cmdDashboard() {
+    const port = getPort();
+    const host = getHost();
+    const url = `http://${host}:${port}/dashboard`;
+
+    if (!(await isAgentRunning())) {
+        console.log('Memory agent is not running. Start it first:');
+        console.log('  claude-memory-agent start');
+        return;
+    }
+
+    console.log(`Opening dashboard: ${url}`);
+    openBrowser(url);
+}
+
+function cmdLogs() {
+    if (!fs.existsSync(LOG_FILE)) {
+        console.log('No log file found. Start the agent first.');
+        return;
+    }
+    const content = fs.readFileSync(LOG_FILE, 'utf8');
+    const lines = content.split('\n');
+    // Show last 50 lines
+    const tail = lines.slice(-50).join('\n');
+    console.log(tail || '(empty log)');
+}
+
+async function cmdRestart() {
+    console.log('Restarting Memory Agent...');
+    await cmdStop();
+    await new Promise((r) => setTimeout(r, 1000));
+    await cmdStart();
 }
 
-// Doctor - diagnose issues (async)
 async function runDoctor() {
-    console.log('\n🩺 Claude Memory Agent - System Check\n');
+    console.log('\nClaude Memory Agent - System Check\n');
     console.log('='.repeat(50));
 
     let issues = 0;
     let warnings = 0;
 
-    // Check Python
+    // Python
     process.stdout.write('Python 3.9+........... ');
     const python = getPython();
     if (python) {
-        console.log('✓ OK');
+        console.log('OK');
     } else {
-        console.log('✗ NOT FOUND');
+        console.log('NOT FOUND');
         console.log('   Install from: https://python.org/');
         issues++;
     }
 
-    // Check Ollama
+    // Ollama
     process.stdout.write('Ollama................ ');
-    const ollamaOk = await checkUrl('http://localhost:11434/api/tags');
+    const { ok: ollamaOk } = await httpGet('http://localhost:11434/api/tags');
     if (ollamaOk) {
-        console.log('✓ Running');
+        console.log('Running');
     } else {
-        console.log('✗ NOT RUNNING');
+        console.log('NOT RUNNING');
         console.log('   Install from: https://ollama.ai/download');
         console.log('   Then run: ollama serve');
         issues++;
     }
 
-    // Check embedding model
+    // Embedding model
     if (ollamaOk) {
         process.stdout.write('Embedding model....... ');
-        const modelOk = await checkOllamaModel();
-        if (modelOk) {
-            console.log('✓ nomic-embed-text');
+        const { ok: modelOk, body } = await httpGet('http://localhost:11434/api/tags');
+        let hasModel = false;
+        try {
+            const models = JSON.parse(body).models || [];
+            hasModel = models.some((m) => m.name && m.name.includes('nomic-embed-text'));
+        } catch (_) {}
+        if (hasModel) {
+            console.log('nomic-embed-text');
         } else {
-            console.log('✗ NOT INSTALLED');
+            console.log('NOT INSTALLED');
             console.log('   Run: ollama pull nomic-embed-text');
             issues++;
         }
     }
 
-    // Check Memory Agent
+    // Memory Agent
     process.stdout.write('Memory Agent.......... ');
-    const agentOk = await checkUrl('http://localhost:8102/health');
-    if (agentOk) {
-        console.log('✓ Running');
+    if (await isAgentRunning()) {
+        console.log('Running');
     } else {
-        console.log('✗ NOT RUNNING');
+        console.log('NOT RUNNING');
         console.log('   Run: claude-memory-agent start');
         warnings++;
     }
 
-    // Check .env file
+    // .env
     process.stdout.write('.env file............. ');
-    if (fs.existsSync(path.join(AGENT_DIR, '.env'))) {
-        console.log('✓ Exists');
+    if (fs.existsSync(ENV_FILE)) {
+        console.log('Exists');
     } else {
-        console.log('✗ MISSING');
+        console.log('MISSING');
         console.log('   Run: claude-memory-agent install');
         issues++;
     }
@@ -162,51 +378,17 @@ async function runDoctor() {
     // Summary
     console.log('\n' + '='.repeat(50));
     if (issues === 0 && warnings === 0) {
-        console.log('✅ All systems operational!\n');
+        console.log('All systems operational!\n');
     } else if (issues === 0) {
-        console.log(`⚠️  ${warnings} warning(s) - agent may not be running\n`);
+        console.log(`${warnings} warning(s) - agent may not be running\n`);
     } else {
-        console.log(`❌ ${issues} issue(s) found - fix above problems\n`);
+        console.log(`${issues} issue(s) found - fix above problems\n`);
     }
 }
 
-// Helper: Check if URL responds
-function checkUrl(url) {
-    return new Promise((resolve) => {
-        const http = require('http');
-        const req = http.get(url, { timeout: 2000 }, (res) => {
-            resolve(res.statusCode === 200);
-        });
-        req.on('error', () => resolve(false));
-        req.on('timeout', () => { req.destroy(); resolve(false); });
-    });
-}
-
-// Helper: Check if Ollama has embedding model
-function checkOllamaModel() {
-    return new Promise((resolve) => {
-        const http = require('http');
-        http.get('http://localhost:11434/api/tags', (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);
-                }
-            });
-        }).on('error', () => resolve(false));
-    });
-}
-
-// Print help
 function printHelp() {
     console.log(`
-Claude Memory Agent v2.2.3
+Claude Memory Agent v2.2.4
 Persistent semantic memory for Claude Code sessions
 
 USAGE:
@@ -242,58 +424,52 @@ For more info: https://www.npmjs.com/package/claude-memory-agent
 `);
 }
 
-// Main
-function main() {
+// ---------------------------------------------------------------------------
+// Main dispatch
+// ---------------------------------------------------------------------------
+
+async function main() {
     switch (command) {
         case 'install':
         case 'setup':
-            // Run the onboarding wizard
             try {
                 const { main: runOnboarding } = require('./onboarding');
-                runOnboarding().catch(err => {
+                runOnboarding().catch((err) => {
                     console.error('Setup error:', err.message);
                     process.exit(1);
                 });
-            } catch (e) {
-                // Fallback to Python installer if onboarding deps missing
+            } catch (_) {
                 runPython('install.py', args.slice(1));
             }
             break;
 
         case 'start':
-            runPython('memory-agent', ['start', ...args.slice(1)]);
+            await cmdStart();
             break;
 
         case 'stop':
-            runPython('memory-agent', ['stop', ...args.slice(1)]);
+            await cmdStop();
+            break;
+
+        case 'restart':
+            await cmdRestart();
             break;
 
         case 'status':
-            runPython('memory-agent', ['status', ...args.slice(1)]);
+            await cmdStatus();
             break;
 
         case 'dashboard':
-            runPython('memory-agent', ['dashboard', ...args.slice(1)]);
+            await cmdDashboard();
             break;
 
         case 'logs':
-            runPython('memory-agent', ['logs', ...args.slice(1)]);
-            break;
-
-        case 'restart':
-            // Stop then start
-            console.log('Restarting Memory Agent...');
-            try {
-                execSync(`${getPython()} memory-agent stop`, { cwd: AGENT_DIR, stdio: 'inherit', shell: process.platform === 'win32' });
-            } catch (e) { /* ignore stop errors */ }
-            setTimeout(() => {
-                runPython('memory-agent', ['start']);
-            }, 1000);
+            cmdLogs();
             break;
 
         case 'doctor':
         case 'diagnose':
-            runDoctor();
+            await runDoctor();
             break;
 
         case 'uninstall':
@@ -302,7 +478,7 @@ function main() {
 
         case 'run':
         case 'server':
-            // Run directly (not in background)
+            // Run main.py directly (foreground, not detached)
             runPython('main.py', args.slice(1));
             break;
 
@@ -314,7 +490,7 @@ function main() {
 
         case '--version':
         case '-v':
-            console.log('claude-memory-agent v2.2.3');
+            console.log('claude-memory-agent v2.2.4');
             break;
 
         default:

package/config.py

@@ -107,6 +107,12 @@ class Config:
         # Adaptive search ranking
         self.DEFAULT_SEARCH_TEMPERATURE = float(os.getenv("DEFAULT_SEARCH_TEMPERATURE", "1.0"))
 
+        # Cross-session awareness
+        self.SESSION_IDLE_THRESHOLD_MINUTES = int(os.getenv("SESSION_IDLE_THRESHOLD_MINUTES", "10"))
+        self.SESSION_COMPLETED_THRESHOLD_MINUTES = int(os.getenv("SESSION_COMPLETED_THRESHOLD_MINUTES", "30"))
+        self.SESSION_ACTIVITY_MAX_AGE_HOURS = int(os.getenv("SESSION_ACTIVITY_MAX_AGE_HOURS", "24"))
+        self.SESSION_CLEANUP_INTERVAL_SECONDS = int(os.getenv("SESSION_CLEANUP_INTERVAL_SECONDS", "300"))
+
         # Validate configuration
         self._validate()
 

package/hooks/auto_capture.py

@@ -23,7 +23,7 @@ import asyncio
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Dict, Any, Optional, List
 
 # Add parent to path for imports
 sys.path.insert(0, str(Path(__file__).parent.parent))
@@ -128,6 +128,53 @@ async def send_to_memory(
         return False
 
 
+async def post_session_activity(session_id: str, project_path: str, event_type: str, summary: str, files: List[str] = None):
+    """Post a cross-session activity event and track modified files."""
+    if not session_id or not project_path:
+        return
+
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["X-Memory-Key"] = API_KEY
+
+    try:
+        async with httpx.AsyncClient(timeout=3.0) as client:
+            # Post activity event
+            await client.post(
+                f"{MEMORY_AGENT_URL}/api/sessions/activity",
+                json={
+                    "session_id": session_id,
+                    "project_path": project_path,
+                    "event_type": event_type,
+                    "summary": summary,
+                    "files": files or [],
+                },
+                headers=headers,
+            )
+
+            # Append files to session's modified files list
+            if files:
+                for f in files:
+                    await client.post(
+                        f"{MEMORY_AGENT_URL}/a2a",
+                        json={
+                            "jsonrpc": "2.0",
+                            "method": "skills/call",
+                            "params": {
+                                "skill_id": "session_append_file",
+                                "params": {
+                                    "session_id": session_id,
+                                    "file_path": f,
+                                }
+                            },
+                            "id": f"auto-capture-file-{datetime.now().isoformat()}"
+                        },
+                        headers=headers,
+                    )
+    except Exception as e:
+        logger.debug(f"Cross-session activity post failed: {e}")
+
+
 async def capture_tool_use(hook_data: Dict[str, Any]):
     """Capture a tool execution event."""
     tool_name = hook_data.get("tool_name", "Unknown")
@@ -182,6 +229,16 @@ async def capture_tool_use(hook_data: Dict[str, Any]):
 
     await send_to_memory(content, mem_type, importance, metadata, project_path)
 
+    # ============================================================
+    # CROSS-SESSION AWARENESS: Post file changes to activity feed
+    # ============================================================
+    if tool_name in ("Write", "Edit") and session_id and project_path:
+        file_path = tool_input.get("file_path", "")
+        if file_path:
+            event_type = "file_change"
+            summary = f"{'Created' if tool_name == 'Write' else 'Edited'} {file_path}"
+            await post_session_activity(session_id, project_path, event_type, summary, [file_path])
+
 
 async def capture_notification(hook_data: Dict[str, Any]):
     """Capture a notification/error event."""