claude-recall 0.7.4 → 0.7.5

package/README.md

@@ -94,7 +94,22 @@ npm uninstall -g claude-recall
 
 Claude Recall works on **Windows, Linux, and macOS**. Native binaries (SQLite) compile automatically for your platform during `npm install`.
 
-**WSL Users:** Use local installation only. Global installation on Windows + WSL usage causes binary conflicts ("invalid ELF header" errors).
+**WSL Users - Special Case:**
+
+If you use **both Windows and WSL** for the same project (e.g., Electron app runs on Windows, but Claude Code runs in WSL):
+
+**Problem**: Installing locally creates Windows binaries, but WSL needs Linux binaries → "invalid ELF header" errors.
+
+**Solution**: Install globally in WSL only:
+```bash
+# From WSL:
+npm install -g claude-recall
+
+# Verify:
+claude-recall --version
+```
+
+**Important**: Global installation does NOT affect project-specific memory scoping! See [How Project Scoping Works](#how-project-scoping-works-installation-location) below.
 
 **Everyone else:** Both local and global work, but local is still recommended for the benefits above.
 
@@ -526,6 +541,98 @@ All commands support:
 - `--config <path>` - Use custom config file
 - `-h, --help` - Show help for any command
 
+## Project Management (v0.7.5+)
+
+Claude Recall maintains a **project registry** to track all projects using it, enabling better organization and visibility across multiple projects.
+
+### Auto-Registration
+
+Projects are automatically registered when:
+- The MCP server starts (every time Claude Code connects)
+- You run `npm install claude-recall` locally
+- You manually run `npx claude-recall project register`
+
+The registry stores:
+- Project path
+- Claude Recall version
+- Registration date
+- Last activity timestamp
+
+### Project Commands
+
+**List all registered projects:**
+```bash
+npx claude-recall project list              # Human-friendly output
+npx claude-recall project list --json       # JSON format
+```
+
+Shows:
+- Project name and path
+- Claude Recall version
+- Last activity
+- MCP server status (active/inactive)
+
+**Show project details:**
+```bash
+npx claude-recall project show              # Current project
+npx claude-recall project show my-project   # Specific project
+```
+
+Displays:
+- Registry information (path, version, timestamps)
+- MCP server status (running/stopped, PID)
+
+**Register a project:**
+```bash
+npx claude-recall project register          # Current directory
+npx claude-recall project register --path /path/to/project
+```
+
+**Unregister a project:**
+```bash
+npx claude-recall project unregister        # Current project
+npx claude-recall project unregister my-project
+```
+
+**Note**: Unregistering does NOT remove memories or MCP configuration - only the registry entry.
+
+**Clean up stale entries:**
+```bash
+npx claude-recall project clean             # Remove projects not seen in 30 days
+npx claude-recall project clean --days 60   # Custom threshold
+npx claude-recall project clean --dry-run   # Preview without changes
+```
+
+### Enhanced MCP Commands
+
+MCP commands now show registry information:
+
+```bash
+npx claude-recall mcp status    # Shows registry info + MCP status
+npx claude-recall mcp ps        # Lists all servers with version info
+```
+
+### Registry Storage
+
+Registry stored at: `~/.claude-recall/projects.json`
+
+Format:
+```json
+{
+  "version": 1,
+  "projects": {
+    "my-project": {
+      "path": "/full/path/to/my-project",
+      "registeredAt": "2025-11-09T...",
+      "version": "0.7.5",
+      "lastSeen": "2025-11-09T..."
+    }
+  }
+}
+```
+
+**Note**: The registry is separate from your memory database. Cleaning the registry does NOT affect your stored memories.
+
 ## Project Scoping (v0.7.2+)
 
 Claude Recall now supports **project-specific memory isolation** while keeping universal preferences available everywhere.
@@ -610,6 +717,71 @@ npx claude-recall stats --global
 - Works like v0.7.1 and earlier
 - Available everywhere unless you explicitly scope them
 
+### How Project Scoping Works (Installation Location)
+
+**Important**: Where you install claude-recall (global vs local) does NOT affect project-specific memory scoping!
+
+**What Determines Project Scope:**
+
+1. ✅ **Claude Code's working directory** - Where you run Claude Code
+2. ✅ **Database scoping logic** - Filters memories by project_id
+3. ❌ **Installation location** - Doesn't matter for scoping
+
+**How It Works:**
+
+```
+# Claude Code runs in this directory:
+/home/user/projects/my-app
+
+# Project ID detected from directory name:
+project_id = "my-app"
+
+# Memories stored/searched with that project_id:
+- "For this project, use PostgreSQL" → stored with project_id="my-app"
+- "Remember everywhere: I prefer TypeScript" → stored with scope="universal"
+
+# Same behavior whether claude-recall is:
+# - Installed globally: /usr/local/lib/node_modules/claude-recall
+# - Installed locally: ./node_modules/claude-recall
+```
+
+**Database Location (Always Global):**
+
+Whether you install globally or locally, the database is **always** at:
+```
+~/.claude-recall/claude-recall.db
+```
+
+This single database contains:
+- Project-specific memories for each project (isolated by project_id)
+- Universal memories (available in all projects)
+- Unscoped memories (backward compatible)
+
+**Example: Two Projects, One Installation**
+
+```bash
+# Project A:
+cd ~/projects/project-a
+# Claude Code detects: project_id = "project-a"
+# Memories: isolated to project-a + universal + unscoped
+
+# Project B:
+cd ~/projects/project-b
+# Claude Code detects: project_id = "project-b"
+# Memories: isolated to project-b + universal + unscoped
+
+# Same global installation, proper isolation!
+```
+
+**WSL Users:**
+
+This is why **global installation in WSL** works perfectly for project scoping:
+- Code location: `/home/user/.nvm/.../bin/claude-recall` (global)
+- Project detection: Based on Claude Code's `cwd`, NOT installation path
+- Memory isolation: Each project gets its own memories + universal preferences
+
+Global installation actually **helps** WSL users by avoiding binary conflicts while maintaining perfect project isolation!
+
 ## Memory Management
 
 Claude Recall automatically manages memory to prevent unlimited database growth, with user notifications:

package/dist/cli/claude-recall-cli.js

@@ -48,6 +48,7 @@ const live_test_1 = require("./commands/live-test");
 const queue_integration_1 = require("../services/queue-integration");
 const memory_evolution_1 = require("../services/memory-evolution");
 const mcp_commands_1 = require("./commands/mcp-commands");
+const project_commands_1 = require("./commands/project-commands");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
     constructor(options) {
@@ -612,6 +613,8 @@ async function main() {
     });
     // Register MCP process management commands
     mcp_commands_1.MCPCommands.register(mcpCmd);
+    // Project management commands
+    project_commands_1.ProjectCommands.register(program);
     // Migration commands
     migrate_1.MigrateCommand.register(program);
     // Register live test command

package/dist/cli/commands/mcp-commands.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPCommands = void 0;
 const process_manager_1 = require("../../services/process-manager");
 const config_1 = require("../../services/config");
+const project_registry_1 = require("../../services/project-registry");
 const chalk_1 = __importDefault(require("chalk"));
 /**
  * MCP Process Management Commands
@@ -21,6 +22,7 @@ class MCPCommands {
     constructor() {
         this.processManager = process_manager_1.ProcessManager.getInstance();
         this.config = config_1.ConfigService.getInstance();
+        this.projectRegistry = project_registry_1.ProjectRegistry.getInstance();
     }
     static register(mcpCmd) {
         const commands = new MCPCommands();
@@ -72,6 +74,7 @@ class MCPCommands {
     async showStatus() {
         const projectId = this.config.getProjectId();
         const status = this.processManager.getServerStatus(projectId);
+        const registryEntry = this.projectRegistry.get(projectId);
         console.log(chalk_1.default.cyan('\n📊 MCP Server Status\n'));
         console.log(`Project:  ${chalk_1.default.yellow(projectId)}`);
         console.log(`Status:   ${status.isRunning ? chalk_1.default.green('✓ Running') : chalk_1.default.gray('✗ Stopped')}`);
@@ -82,6 +85,20 @@ class MCPCommands {
             }
         }
         console.log(`PID File: ${chalk_1.default.gray(status.pidFile)}`);
+        // Show registry information if available
+        if (registryEntry) {
+            console.log();
+            console.log(chalk_1.default.bold('Registry Info:'));
+            console.log(`  Version:      ${chalk_1.default.gray(registryEntry.version)}`);
+            console.log(`  Path:         ${chalk_1.default.gray(registryEntry.path)}`);
+            console.log(`  Registered:   ${chalk_1.default.gray(new Date(registryEntry.registeredAt).toLocaleString())}`);
+            console.log(`  Last Seen:    ${chalk_1.default.gray(new Date(registryEntry.lastSeen).toLocaleString())}`);
+        }
+        else {
+            console.log();
+            console.log(chalk_1.default.yellow('⚠ Project not registered in registry'));
+            console.log(chalk_1.default.gray('  Run `npx claude-recall project register` to register'));
+        }
         console.log();
     }
     /**
@@ -89,9 +106,10 @@ class MCPCommands {
      */
     async listServers() {
         const servers = this.processManager.getAllRunningServers();
-        console.log(chalk_1.default.cyan('\n📋 Running MCP Servers\n'));
-        if (servers.length === 0) {
-            console.log(chalk_1.default.gray('No MCP servers found.'));
+        const registeredProjects = this.projectRegistry.list();
+        console.log(chalk_1.default.cyan('\n📋 MCP Servers & Registered Projects\n'));
+        if (servers.length === 0 && registeredProjects.length === 0) {
+            console.log(chalk_1.default.gray('No MCP servers or registered projects found.'));
             console.log();
             return;
         }
@@ -100,7 +118,9 @@ class MCPCommands {
         if (runningServers.length > 0) {
             console.log(chalk_1.default.green(`✓ Running (${runningServers.length}):`));
             for (const server of runningServers) {
-                console.log(`  ${chalk_1.default.yellow(server.projectId.padEnd(40))} PID: ${chalk_1.default.cyan(server.pid)}`);
+                const registryEntry = this.projectRegistry.get(server.projectId);
+                const versionInfo = registryEntry ? ` [v${registryEntry.version}]` : '';
+                console.log(`  ${chalk_1.default.yellow(server.projectId.padEnd(40))} PID: ${chalk_1.default.cyan(server.pid)}${chalk_1.default.gray(versionInfo)}`);
             }
             console.log();
         }
@@ -113,6 +133,18 @@ class MCPCommands {
             console.log(chalk_1.default.yellow(`💡 Run 'npx claude-recall mcp cleanup' to remove stale PID files`));
             console.log();
         }
+        // Show registered projects that don't have running servers
+        const runningProjectIds = new Set(runningServers.map(s => s.projectId));
+        const inactiveProjects = registeredProjects.filter(({ projectId }) => !runningProjectIds.has(projectId));
+        if (inactiveProjects.length > 0) {
+            console.log(chalk_1.default.gray(`📂 Registered but Inactive (${inactiveProjects.length}):`));
+            for (const { projectId, entry } of inactiveProjects) {
+                console.log(`  ${chalk_1.default.gray(projectId.padEnd(40))} v${entry.version}`);
+            }
+            console.log();
+            console.log(chalk_1.default.gray(`💡 Run 'npx claude-recall project list' for detailed registry info`));
+            console.log();
+        }
     }
     /**
      * Stop MCP server

package/dist/cli/commands/project-commands.js

@@ -0,0 +1,309 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectCommands = void 0;
+const project_registry_1 = require("../../services/project-registry");
+const config_1 = require("../../services/config");
+const process_manager_1 = require("../../services/process-manager");
+const chalk_1 = __importDefault(require("chalk"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+/**
+ * Project Management Commands
+ *
+ * Provides CLI commands for managing project registration:
+ * - register: Register current or specific project
+ * - unregister: Remove project from registry
+ * - list: Show all registered projects
+ * - show: Show details for specific project
+ * - clean: Remove stale registry entries
+ */
+class ProjectCommands {
+    constructor() {
+        this.projectRegistry = project_registry_1.ProjectRegistry.getInstance();
+        this.config = config_1.ConfigService.getInstance();
+        this.processManager = process_manager_1.ProcessManager.getInstance();
+    }
+    static register(program) {
+        const commands = new ProjectCommands();
+        const projectCmd = program
+            .command('project')
+            .description('Project registration and management');
+        // project register
+        projectCmd
+            .command('register')
+            .description('Register current or specified project')
+            .option('--path <path>', 'Project path (default: current directory)')
+            .action(async (options) => {
+            await commands.registerProject(options);
+        });
+        // project unregister
+        projectCmd
+            .command('unregister [project-id]')
+            .description('Unregister a project')
+            .action(async (projectId) => {
+            await commands.unregisterProject(projectId);
+        });
+        // project list
+        projectCmd
+            .command('list')
+            .description('List all registered projects')
+            .option('--json', 'Output as JSON')
+            .action(async (options) => {
+            await commands.listProjects(options);
+        });
+        // project show
+        projectCmd
+            .command('show [project-id]')
+            .description('Show details for a project (default: current)')
+            .action(async (projectId) => {
+            await commands.showProject(projectId);
+        });
+        // project clean
+        projectCmd
+            .command('clean')
+            .description('Remove stale registry entries')
+            .option('--dry-run', 'Show what would be removed without removing')
+            .option('--days <number>', 'Days without activity to consider stale', '30')
+            .action(async (options) => {
+            await commands.cleanRegistry(options);
+        });
+    }
+    /**
+     * Register a project
+     */
+    async registerProject(options) {
+        console.log(chalk_1.default.cyan('\n📝 Registering Project\n'));
+        try {
+            // Determine project path
+            const projectPath = options.path
+                ? path.resolve(options.path)
+                : process.cwd();
+            // Validate path exists
+            if (!fs.existsSync(projectPath)) {
+                console.log(chalk_1.default.red(`✗ Path does not exist: ${projectPath}`));
+                console.log();
+                return;
+            }
+            // Get project ID
+            const projectId = path.basename(projectPath);
+            // Get version
+            const version = this.getVersion();
+            // Register
+            this.projectRegistry.register(projectId, projectPath, version);
+            console.log(`Project:  ${chalk_1.default.yellow(projectId)}`);
+            console.log(`Path:     ${chalk_1.default.gray(projectPath)}`);
+            console.log(`Version:  ${chalk_1.default.gray(version)}`);
+            console.log();
+            console.log(chalk_1.default.green('✓ Project registered successfully'));
+            console.log();
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`✗ Failed to register project: ${error}`));
+            console.log();
+        }
+    }
+    /**
+     * Unregister a project
+     */
+    async unregisterProject(projectId) {
+        console.log(chalk_1.default.cyan('\n🗑️  Unregistering Project\n'));
+        try {
+            // If no projectId provided, use current directory
+            const targetProjectId = projectId || this.config.getProjectId();
+            // Get project info before removing
+            const entry = this.projectRegistry.get(targetProjectId);
+            if (!entry) {
+                console.log(chalk_1.default.yellow(`⚠ Project not found in registry: ${targetProjectId}`));
+                console.log();
+                return;
+            }
+            console.log(`Project:  ${chalk_1.default.yellow(targetProjectId)}`);
+            console.log(`Path:     ${chalk_1.default.gray(entry.path)}`);
+            console.log();
+            // Unregister
+            const success = this.projectRegistry.unregister(targetProjectId);
+            if (success) {
+                console.log(chalk_1.default.green('✓ Project unregistered successfully'));
+                console.log();
+                console.log(chalk_1.default.gray('Note: This does not remove the MCP server configuration from ~/.claude.json'));
+                console.log(chalk_1.default.gray('      Use `claude mcp` commands to manage MCP servers.'));
+                console.log();
+            }
+            else {
+                console.log(chalk_1.default.red('✗ Failed to unregister project'));
+                console.log();
+            }
+        }
+        catch (error) {
+            console.log(chalk_1.default.red(`✗ Error: ${error}`));
+            console.log();
+        }
+    }
+    /**
+     * List all registered projects
+     */
+    async listProjects(options) {
+        const projects = this.projectRegistry.list();
+        if (options.json) {
+            console.log(JSON.stringify(projects, null, 2));
+            return;
+        }
+        console.log(chalk_1.default.cyan('\n📋 Registered Projects\n'));
+        if (projects.length === 0) {
+            console.log(chalk_1.default.gray('No projects registered.'));
+            console.log();
+            console.log(chalk_1.default.yellow('💡 Run `npx claude-recall project register` to register the current project'));
+            console.log();
+            return;
+        }
+        // Get running servers for status
+        const runningServers = this.processManager.getAllRunningServers();
+        const runningProjectIds = new Set(runningServers.filter(s => s.isRunning).map(s => s.projectId));
+        // Sort by lastSeen (most recent first)
+        projects.sort((a, b) => {
+            return new Date(b.entry.lastSeen).getTime() - new Date(a.entry.lastSeen).getTime();
+        });
+        for (const { projectId, entry } of projects) {
+            const isRunning = runningProjectIds.has(projectId);
+            const lastSeenTime = this.formatRelativeTime(entry.lastSeen);
+            console.log(chalk_1.default.bold(projectId));
+            console.log(`  Path:      ${chalk_1.default.gray(entry.path)}`);
+            console.log(`  Version:   ${chalk_1.default.gray(entry.version)}`);
+            console.log(`  Last seen: ${chalk_1.default.gray(lastSeenTime)}`);
+            console.log(`  Status:    ${isRunning ? chalk_1.default.green('✓ Active (MCP running)') : chalk_1.default.gray('✗ Inactive')}`);
+            console.log();
+        }
+        console.log(chalk_1.default.gray(`Total: ${projects.length} project(s)`));
+        console.log();
+    }
+    /**
+     * Show details for a specific project
+     */
+    async showProject(projectId) {
+        const targetProjectId = projectId || this.config.getProjectId();
+        console.log(chalk_1.default.cyan('\n📊 Project Details\n'));
+        const entry = this.projectRegistry.get(targetProjectId);
+        if (!entry) {
+            console.log(chalk_1.default.yellow(`⚠ Project not found: ${targetProjectId}`));
+            console.log();
+            console.log(chalk_1.default.gray('Run `npx claude-recall project list` to see registered projects'));
+            console.log();
+            return;
+        }
+        // Check if MCP server is running
+        const status = this.processManager.getServerStatus(targetProjectId);
+        console.log(`${chalk_1.default.bold('Project:')}  ${chalk_1.default.yellow(targetProjectId)}`);
+        console.log();
+        console.log(chalk_1.default.bold('Registry Information:'));
+        console.log(`  Path:         ${chalk_1.default.gray(entry.path)}`);
+        console.log(`  Version:      ${chalk_1.default.gray(entry.version)}`);
+        console.log(`  Registered:   ${chalk_1.default.gray(new Date(entry.registeredAt).toLocaleString())}`);
+        console.log(`  Last Seen:    ${chalk_1.default.gray(new Date(entry.lastSeen).toLocaleString())} (${this.formatRelativeTime(entry.lastSeen)})`);
+        console.log();
+        console.log(chalk_1.default.bold('MCP Server Status:'));
+        console.log(`  Running:      ${status.isRunning ? chalk_1.default.green('✓ Yes') : chalk_1.default.gray('✗ No')}`);
+        if (status.pid) {
+            console.log(`  PID:          ${chalk_1.default.gray(status.pid)}`);
+        }
+        console.log(`  PID File:     ${chalk_1.default.gray(status.pidFile)}`);
+        console.log();
+    }
+    /**
+     * Clean stale registry entries
+     */
+    async cleanRegistry(options) {
+        const daysOld = parseInt(options.days || '30', 10);
+        console.log(chalk_1.default.cyan('\n🧹 Cleaning Registry\n'));
+        if (options.dryRun) {
+            console.log(chalk_1.default.yellow('DRY RUN MODE - No changes will be made\n'));
+        }
+        console.log(`Removing projects not seen in ${daysOld} days...\n`);
+        const removed = this.projectRegistry.clean(daysOld, options.dryRun || false);
+        if (removed === 0) {
+            console.log(chalk_1.default.green('✓ No stale entries found'));
+        }
+        else {
+            if (options.dryRun) {
+                console.log(chalk_1.default.gray(`\nWould remove ${removed} stale project(s)`));
+            }
+            else {
+                console.log(chalk_1.default.green(`\n✓ Removed ${removed} stale project(s)`));
+            }
+        }
+        console.log();
+    }
+    /**
+     * Format relative time (e.g., "2 minutes ago", "5 days ago")
+     */
+    formatRelativeTime(timestamp) {
+        const now = Date.now();
+        const then = new Date(timestamp).getTime();
+        const diffMs = now - then;
+        const seconds = Math.floor(diffMs / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+        if (days > 0) {
+            return `${days} day${days === 1 ? '' : 's'} ago`;
+        }
+        else if (hours > 0) {
+            return `${hours} hour${hours === 1 ? '' : 's'} ago`;
+        }
+        else if (minutes > 0) {
+            return `${minutes} minute${minutes === 1 ? '' : 's'} ago`;
+        }
+        else {
+            return 'just now';
+        }
+    }
+    /**
+     * Get current version
+     */
+    getVersion() {
+        try {
+            const packageJsonPath = path.join(__dirname, '../../../package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            return packageJson.version;
+        }
+        catch (error) {
+            return 'unknown';
+        }
+    }
+}
+exports.ProjectCommands = ProjectCommands;

package/dist/mcp/server.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MCPServer = void 0;
 const stdio_1 = require("./transports/stdio");
@@ -18,6 +51,9 @@ const context_enhancer_1 = require("../services/context-enhancer");
 const conversation_context_manager_1 = require("../services/conversation-context-manager");
 const process_manager_1 = require("../services/process-manager");
 const config_1 = require("../services/config");
+const project_registry_1 = require("../services/project-registry");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 class MCPServer {
     constructor() {
         this.tools = new Map();
@@ -384,6 +420,13 @@ class MCPServer {
             this.logger.info('MCPServer', 'Starting Claude Recall MCP server...');
             // Get project ID for PID tracking
             const projectId = this.config.getProjectId();
+            // Auto-register project in registry
+            const rootDir = this.config.getConfig().project.rootDir;
+            const version = this.getVersion();
+            const projectRegistry = project_registry_1.ProjectRegistry.getInstance();
+            projectRegistry.register(projectId, rootDir, version);
+            projectRegistry.updateLastSeen(projectId);
+            this.logger.debug('MCPServer', `Project registered: ${projectId} at ${rootDir} (v${version})`);
             // Check for existing MCP server process
             const existingPid = this.processManager.readPidFile(projectId);
             if (existingPid) {
@@ -460,5 +503,18 @@ class MCPServer {
             process.exit(0);
         });
     }
+    /**
+     * Get current version from package.json
+     */
+    getVersion() {
+        try {
+            const packageJsonPath = path.join(__dirname, '../../package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            return packageJson.version;
+        }
+        catch (error) {
+            return 'unknown';
+        }
+    }
 }
 exports.MCPServer = MCPServer;

package/dist/services/project-registry.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectRegistry = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logging_1 = require("./logging");
+const config_1 = require("./config");
+/**
+ * ProjectRegistry
+ *
+ * Manages a registry of projects that have claude-recall installed.
+ * Stored in ~/.claude-recall/projects.json
+ *
+ * Features:
+ * - Auto-registration on MCP server start
+ * - Manual registration via CLI commands
+ * - Discovery of registered projects
+ * - Cleanup of stale entries
+ */
+class ProjectRegistry {
+    constructor() {
+        this.logger = logging_1.LoggingService.getInstance();
+        const config = config_1.ConfigService.getInstance();
+        const baseDir = path.dirname(config.getDatabasePath());
+        this.registryPath = path.join(baseDir, 'projects.json');
+    }
+    static getInstance() {
+        if (!ProjectRegistry.instance) {
+            ProjectRegistry.instance = new ProjectRegistry();
+        }
+        return ProjectRegistry.instance;
+    }
+    /**
+     * Read the project registry from disk
+     */
+    readRegistry() {
+        if (!fs.existsSync(this.registryPath)) {
+            return { version: 1, projects: {} };
+        }
+        try {
+            const content = fs.readFileSync(this.registryPath, 'utf-8');
+            const data = JSON.parse(content);
+            // Validate structure
+            if (typeof data.version !== 'number' || typeof data.projects !== 'object') {
+                this.logger.warn('ProjectRegistry', 'Invalid registry format, resetting');
+                return { version: 1, projects: {} };
+            }
+            return data;
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to read registry: ${error}`);
+            return { version: 1, projects: {} };
+        }
+    }
+    /**
+     * Write the project registry to disk atomically
+     */
+    writeRegistry(data) {
+        try {
+            // Ensure directory exists
+            const dir = path.dirname(this.registryPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            // Atomic write: temp file + rename
+            const tempPath = `${this.registryPath}.tmp`;
+            fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf-8');
+            fs.renameSync(tempPath, this.registryPath);
+            this.logger.debug('ProjectRegistry', `Wrote registry with ${Object.keys(data.projects).length} projects`);
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to write registry: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * Register a project in the registry
+     * @param projectId Project identifier (usually directory basename)
+     * @param projectPath Absolute path to project directory
+     * @param version Claude Recall version
+     */
+    register(projectId, projectPath, version) {
+        try {
+            const registry = this.readRegistry();
+            const now = new Date().toISOString();
+            // Check if already registered
+            const existing = registry.projects[projectId];
+            if (existing && existing.path === projectPath) {
+                // Already registered, just update version and lastSeen
+                registry.projects[projectId].version = version;
+                registry.projects[projectId].lastSeen = now;
+                this.logger.debug('ProjectRegistry', `Updated existing project: ${projectId}`);
+            }
+            else {
+                // New registration
+                registry.projects[projectId] = {
+                    path: projectPath,
+                    registeredAt: now,
+                    version: version,
+                    lastSeen: now
+                };
+                this.logger.info('ProjectRegistry', `Registered new project: ${projectId} at ${projectPath}`);
+            }
+            this.writeRegistry(registry);
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to register project ${projectId}: ${error}`);
+            // Don't throw - registration failure shouldn't break MCP server startup
+        }
+    }
+    /**
+     * Unregister a project from the registry
+     */
+    unregister(projectId) {
+        try {
+            const registry = this.readRegistry();
+            if (!registry.projects[projectId]) {
+                this.logger.warn('ProjectRegistry', `Project not found: ${projectId}`);
+                return false;
+            }
+            delete registry.projects[projectId];
+            this.writeRegistry(registry);
+            this.logger.info('ProjectRegistry', `Unregistered project: ${projectId}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to unregister project ${projectId}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Update lastSeen timestamp for a project
+     */
+    updateLastSeen(projectId) {
+        try {
+            const registry = this.readRegistry();
+            if (!registry.projects[projectId]) {
+                this.logger.debug('ProjectRegistry', `Cannot update lastSeen for unknown project: ${projectId}`);
+                return;
+            }
+            registry.projects[projectId].lastSeen = new Date().toISOString();
+            this.writeRegistry(registry);
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to update lastSeen for ${projectId}: ${error}`);
+            // Don't throw - this is non-critical
+        }
+    }
+    /**
+     * Get all registered projects
+     */
+    list() {
+        const registry = this.readRegistry();
+        return Object.entries(registry.projects).map(([projectId, entry]) => ({
+            projectId,
+            entry
+        }));
+    }
+    /**
+     * Get a specific project entry
+     */
+    get(projectId) {
+        const registry = this.readRegistry();
+        return registry.projects[projectId] || null;
+    }
+    /**
+     * Clean stale registry entries (not seen in X days)
+     * @param daysOld Number of days without activity to consider stale
+     * @param dryRun If true, don't actually remove entries
+     * @returns Number of entries that would be/were removed
+     */
+    clean(daysOld = 30, dryRun = false) {
+        try {
+            const registry = this.readRegistry();
+            const now = Date.now();
+            const cutoff = now - (daysOld * 24 * 60 * 60 * 1000);
+            let removed = 0;
+            for (const [projectId, entry] of Object.entries(registry.projects)) {
+                const lastSeenTime = new Date(entry.lastSeen).getTime();
+                if (lastSeenTime < cutoff) {
+                    if (dryRun) {
+                        this.logger.info('ProjectRegistry', `[DRY RUN] Would remove stale project: ${projectId} (last seen: ${entry.lastSeen})`);
+                    }
+                    else {
+                        this.logger.info('ProjectRegistry', `Removing stale project: ${projectId} (last seen: ${entry.lastSeen})`);
+                        delete registry.projects[projectId];
+                    }
+                    removed++;
+                }
+            }
+            if (!dryRun && removed > 0) {
+                this.writeRegistry(registry);
+            }
+            return removed;
+        }
+        catch (error) {
+            this.logger.error('ProjectRegistry', `Failed to clean registry: ${error}`);
+            return 0;
+        }
+    }
+    /**
+     * Get the registry file path (for debugging/inspection)
+     */
+    getRegistryPath() {
+        return this.registryPath;
+    }
+}
+exports.ProjectRegistry = ProjectRegistry;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-recall",
-  "version": "0.7.4",
-  "description": "Persistent memory for Claude Code with automatic capture, failure learning, sophistication tracking, and project scoping via MCP server",
+  "version": "0.7.5",
+  "description": "Persistent memory for Claude Code with automatic capture, failure learning, sophistication tracking, project scoping, and project registry via MCP server",
   "main": "dist/index.js",
   "bin": {
     "claude-recall": "dist/cli/claude-recall-cli.js"
@@ -11,6 +11,7 @@
     ".claude/",
     "scripts/postinstall.js",
     "scripts/postinstall-claude-md.js",
+    "scripts/uninstall.js",
     "README.md",
     "LICENSE",
     "docs/"
@@ -89,7 +90,6 @@
   "dependencies": {
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
-    "claude-recall": "^0.7.3",
     "commander": "^12.1.0"
   }
 }

package/scripts/postinstall.js

@@ -56,6 +56,53 @@ try {
     // Don't fail installation if CLAUDE.md update fails
   }
   
+  // Auto-register project if this is a local install
+  try {
+    // Detect if we're in a project (not global install, not claude-recall itself)
+    const cwd = process.cwd();
+    const projectName = path.basename(cwd);
+
+    // Skip registration if:
+    // 1. We're inside claude-recall itself
+    // 2. We're in node_modules (global install)
+    if (projectName !== 'claude-recall' && !cwd.includes('node_modules/.pnpm') && !cwd.includes('node_modules/claude-recall')) {
+      const registryPath = path.join(dbDir, 'projects.json');
+
+      // Read or create registry
+      let registry = { version: 1, projects: {} };
+      if (fs.existsSync(registryPath)) {
+        const registryContent = fs.readFileSync(registryPath, 'utf8');
+        registry = JSON.parse(registryContent);
+      }
+
+      // Get version from package.json
+      const packageJsonPath = path.join(__dirname, '../package.json');
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const version = packageJson.version;
+
+      // Register project
+      const now = new Date().toISOString();
+      const existing = registry.projects[projectName];
+
+      registry.projects[projectName] = {
+        path: cwd,
+        registeredAt: existing ? existing.registeredAt : now,
+        version: version,
+        lastSeen: now
+      };
+
+      // Write registry atomically
+      const tempPath = registryPath + '.tmp';
+      fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+      fs.renameSync(tempPath, registryPath);
+
+      console.log(`📋 Registered project: ${projectName}`);
+    }
+  } catch (error) {
+    // Don't fail installation if registration fails
+    console.log('⚠️  Failed to register project (non-fatal):', error.message);
+  }
+
   console.log('\n📝 Installation complete!');
   console.log('   Claude Recall MCP server is now configured.');
   console.log('   Restart your terminal to activate the memory system.');

package/scripts/uninstall.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+console.log('\n👋 Uninstalling Claude Recall...\n');
+
+try {
+  const dbDir = path.join(os.homedir(), '.claude-recall');
+  const registryPath = path.join(dbDir, 'projects.json');
+  const cwd = process.cwd();
+  const projectName = path.basename(cwd);
+
+  // Remove project from registry
+  if (fs.existsSync(registryPath)) {
+    try {
+      const registryContent = fs.readFileSync(registryPath, 'utf8');
+      const registry = JSON.parse(registryContent);
+
+      if (registry.projects && registry.projects[projectName]) {
+        delete registry.projects[projectName];
+
+        // Write registry atomically
+        const tempPath = registryPath + '.tmp';
+        fs.writeFileSync(tempPath, JSON.stringify(registry, null, 2));
+        fs.renameSync(tempPath, registryPath);
+
+        console.log(`📋 Removed project from registry: ${projectName}`);
+      } else {
+        console.log(`⚠️  Project not found in registry: ${projectName}`);
+      }
+    } catch (error) {
+      console.log('⚠️  Failed to update registry (non-fatal):', error.message);
+    }
+  }
+
+  // Stop MCP server if running
+  const pidDir = path.join(dbDir, 'pids');
+  const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, '_');
+  const pidFile = path.join(pidDir, `mcp-${safeName}.pid`);
+
+  if (fs.existsSync(pidFile)) {
+    try {
+      const pidContent = fs.readFileSync(pidFile, 'utf8').trim();
+      const pid = parseInt(pidContent, 10);
+
+      if (!isNaN(pid) && pid > 0) {
+        try {
+          // Check if process exists
+          process.kill(pid, 0);
+          // If we get here, process exists - kill it
+          process.kill(pid, 'SIGTERM');
+          console.log(`🛑 Stopped MCP server (PID: ${pid})`);
+        } catch (error) {
+          // Process doesn't exist or no permission
+          if (error.code === 'ESRCH') {
+            console.log('⚠️  MCP server was not running');
+          }
+        }
+      }
+
+      // Remove PID file
+      fs.unlinkSync(pidFile);
+      console.log('📄 Removed PID file');
+    } catch (error) {
+      console.log('⚠️  Failed to stop MCP server (non-fatal):', error.message);
+    }
+  }
+
+  console.log('\n✅ Uninstallation cleanup complete!\n');
+
+  console.log('📝 Note:');
+  console.log('   - Your memory database is still intact at ~/.claude-recall/');
+  console.log('   - MCP server configuration in ~/.claude.json is still present');
+  console.log('   - Other projects using Claude Recall are unaffected\n');
+
+  console.log('🗑️  To completely remove Claude Recall:');
+  console.log('   1. Remove MCP server from ~/.claude.json');
+  console.log('   2. Delete ~/.claude-recall/ directory');
+  console.log('   3. Uninstall globally: npm uninstall -g claude-recall\n');
+
+} catch (error) {
+  console.error('❌ Error during uninstall:', error.message);
+  console.log('\n💡 You may need to manually clean up:');
+  console.log('   - Remove project from ~/.claude-recall/projects.json');
+  console.log('   - Stop MCP server: npx claude-recall mcp stop');
+  console.log('   - Remove PID file from ~/.claude-recall/pids/\n');
+}