claude-recall 0.9.0 → 0.9.2

package/.claude/settings.json

@@ -1,4 +1 @@
-{
-  "hooks": {},
-  "hooksVersion": "1.0.0"
-}
+{"hooks": {}, "hooksVersion": "1.0.0"}

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

@@ -50,7 +50,6 @@ 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 hook_commands_1 = require("./commands/hook-commands");
-const agent_commands_1 = require("./commands/agent-commands");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
     constructor(options) {
@@ -566,73 +565,82 @@ async function main() {
             }
         }
     }
-    // Install hooks and skills to current project
-    function installHooksAndSkills(force = false) {
+    // Install skills and clean up old hooks (v0.9.0+ uses Skills, not hooks)
+    function installSkillsAndCleanupHooks(force = false) {
         const cwd = process.cwd();
         const projectName = path.basename(cwd);
-        console.log('\n📦 Installing Claude Recall hooks and skills...\n');
+        console.log('\n📦 Claude Recall v0.9.x Setup\n');
         console.log(`📍 Project: ${projectName}`);
         console.log(`📍 Directory: ${cwd}\n`);
         // Find the package directory (where claude-recall is installed)
-        // When run via npx, __dirname points to dist/cli, so we go up to find .claude
         const packageDir = path.resolve(__dirname, '../..');
-        const packageHooksDir = path.join(packageDir, '.claude/hooks');
         const packageSkillsDir = path.join(packageDir, '.claude/skills');
         const claudeDir = path.join(cwd, '.claude');
         const hooksDir = path.join(claudeDir, 'hooks');
-        // Create .claude/hooks directory
-        if (!fs.existsSync(hooksDir)) {
-            fs.mkdirSync(hooksDir, { recursive: true });
-        }
-        // Copy single enforcement hook
-        const hookSource = path.join(packageHooksDir, 'memory_enforcer.py');
-        const hookDest = path.join(hooksDir, 'memory_enforcer.py');
-        if (fs.existsSync(hookSource)) {
-            fs.copyFileSync(hookSource, hookDest);
-            fs.chmodSync(hookDest, 0o755);
-            console.log('✅ Installed memory_enforcer.py to .claude/hooks/');
-        }
-        else {
-            console.log(`⚠️  Hook not found at: ${packageHooksDir}`);
-        }
-        // Create or update .claude/settings.json with hook configuration
         const settingsPath = path.join(claudeDir, 'settings.json');
+        // === CLEANUP: Remove old hooks (v0.9.0+ doesn't use hooks) ===
+        if (fs.existsSync(hooksDir)) {
+            const oldHooks = [
+                'memory_enforcer.py',
+                'pre_tool_search_enforcer.py',
+                'mcp_tool_tracker.py',
+                'pubnub_pre_tool_hook.py',
+                'pubnub_prompt_hook.py',
+                'user_prompt_capture.py',
+                'user_prompt_reminder.py'
+            ];
+            let removedCount = 0;
+            for (const hook of oldHooks) {
+                const hookPath = path.join(hooksDir, hook);
+                if (fs.existsSync(hookPath)) {
+                    fs.unlinkSync(hookPath);
+                    removedCount++;
+                }
+            }
+            // Remove hooks directory if empty
+            try {
+                const remaining = fs.readdirSync(hooksDir);
+                if (remaining.length === 0) {
+                    fs.rmdirSync(hooksDir);
+                }
+            }
+            catch (e) {
+                // Ignore
+            }
+            if (removedCount > 0) {
+                console.log(`🧹 Removed ${removedCount} old hook file(s) from .claude/hooks/`);
+            }
+        }
+        // === CLEANUP: Clear hook configuration from settings.json ===
         let settings = {};
         if (fs.existsSync(settingsPath)) {
             try {
                 settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+                const hadHooks = settings.hooks && Object.keys(settings.hooks).length > 0;
+                // Clear hooks - v0.9.0+ uses Skills instead
+                settings.hooks = {};
+                settings.hooksVersion = '2.0.0';
+                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+                if (hadHooks) {
+                    console.log('🧹 Cleared old hook configuration from .claude/settings.json');
+                }
             }
             catch (e) {
-                settings = {};
-            }
-        }
-        const CURRENT_HOOKS_VERSION = '1.0.0';
-        const needsUpdate = force || !settings.hooks || settings.hooksVersion !== CURRENT_HOOKS_VERSION;
-        if (needsUpdate) {
-            settings.hooksVersion = CURRENT_HOOKS_VERSION;
-            settings.hooks = {
-                PreToolUse: [
-                    {
-                        matcher: "mcp__claude-recall__.*|Write|Edit|Bash|Task",
-                        hooks: [
-                            {
-                                type: "command",
-                                command: `python3 ${path.join(hooksDir, 'memory_enforcer.py')}`,
-                            }
-                        ]
-                    }
-                ]
-            };
-            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-            console.log('✅ Configured hook in .claude/settings.json');
-            if (force) {
-                console.log('   → Force flag: overwrote existing configuration');
+                // If settings.json is invalid, create fresh one
+                if (!fs.existsSync(claudeDir)) {
+                    fs.mkdirSync(claudeDir, { recursive: true });
+                }
+                fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
             }
         }
         else {
-            console.log(`ℹ️  Hooks already at version ${CURRENT_HOOKS_VERSION}`);
+            // Create new settings.json without hooks
+            if (!fs.existsSync(claudeDir)) {
+                fs.mkdirSync(claudeDir, { recursive: true });
+            }
+            fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
         }
-        // Copy skills directory
+        // === INSTALL: Copy skills directory ===
         if (fs.existsSync(packageSkillsDir)) {
             const skillsDir = path.join(claudeDir, 'skills');
             copyDirRecursive(packageSkillsDir, skillsDir);
@@ -641,18 +649,19 @@ async function main() {
         else {
             console.log(`⚠️  Skills not found at: ${packageSkillsDir}`);
         }
-        console.log('\n✅ Installation complete!\n');
+        console.log('\n✅ Setup complete!\n');
+        console.log('ℹ️  v0.9.0+ uses native Claude Skills instead of hooks.');
         console.log('Restart Claude Code to activate.\n');
     }
-    // Setup command - shows activation instructions or installs hooks/skills
+    // Setup command - shows activation instructions or installs skills
     program
         .command('setup')
-        .description('Show activation instructions or install hooks/skills')
-        .option('--install', 'Install hooks and skills to current project')
+        .description('Show activation instructions or install skills')
+        .option('--install', 'Install skills and clean up old hooks')
         .action((options) => {
         if (options.install) {
-            // Install hooks and skills to current project
-            installHooksAndSkills();
+            // Install skills and clean up old hooks
+            installSkillsAndCleanupHooks();
         }
         else {
             // Show activation instructions
@@ -677,13 +686,13 @@ async function main() {
         }
         process.exit(0);
     });
-    // Repair command - simple alias for setup --install
+    // Repair command - cleans up old hooks and installs skills
     program
         .command('repair')
-        .description('Repair broken or missing hooks and skills')
-        .option('--force', 'Force overwrite existing hook configuration')
+        .description('Clean up old hooks and install skills (v0.9.0+ migration)')
+        .option('--force', 'Force overwrite existing configuration')
         .action((options) => {
-        installHooksAndSkills(options.force || false);
+        installSkillsAndCleanupHooks(options.force || false);
         process.exit(0);
     });
     // Check hooks function
@@ -967,10 +976,8 @@ async function main() {
     project_commands_1.ProjectCommands.register(program);
     // Migration commands
     migrate_1.MigrateCommand.register(program);
-    // Hook commands (used by Claude Code hooks)
+    // Hook commands (legacy, kept for backwards compatibility)
     hook_commands_1.HookCommands.register(program);
-    // Agent commands (autonomous memory agent management)
-    agent_commands_1.AgentCommands.register(program);
     // Register live test command
     new live_test_1.LiveTestCommand().register(program);
     // Search command

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "Persistent memory for Claude Code with native Skills integration, automatic capture, failure learning, and project scoping via MCP server",
   "main": "dist/index.js",
   "bin": {
@@ -49,12 +49,7 @@
     "mcp:dev": "ts-node src/cli/claude-recall-cli.ts mcp start",
     "mcp:debug": "NODE_ENV=development DEBUG=claude-recall:* ts-node src/cli/claude-recall-cli.ts mcp start",
     "mcp:test": "echo '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{}}' | npm run mcp:start",
-    "mcp:health": "echo '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"health/check\",\"params\":{}}' | npm run mcp:start",
-    "agent:start": "node dist/pubnub/agent-cli.js start",
-    "agent:stop": "node dist/pubnub/agent-cli.js stop",
-    "agent:status": "node dist/pubnub/agent-cli.js status",
-    "agent:logs": "node dist/pubnub/agent-cli.js logs",
-    "test:pubnub": "node dist/pubnub/test-integration.js"
+    "mcp:health": "echo '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"health/check\",\"params\":{}}' | npm run mcp:start"
   },
   "keywords": [
     "claude-code",
@@ -94,7 +89,6 @@
   "dependencies": {
     "better-sqlite3": "^12.2.0",
     "chalk": "^5.5.0",
-    "commander": "^12.1.0",
-    "pubnub": "^10.2.3"
+    "commander": "^12.1.0"
   }
 }

package/scripts/postinstall.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-console.log('\n🚀 Setting up Claude Recall...\n');
+console.log('\n🚀 Setting up Claude Recall v0.9.x...\n');
 
 const { execSync } = require('child_process');
 
@@ -28,6 +28,22 @@ function copyDirRecursive(src, dest) {
   }
 }
 
+// Helper function to remove directory recursively
+function rmDirRecursive(dir) {
+  if (fs.existsSync(dir)) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        rmDirRecursive(fullPath);
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+    fs.rmdirSync(dir);
+  }
+}
+
 try {
   // Set up database location in user's home directory
   const dbDir = path.join(os.homedir(), '.claude-recall');
@@ -88,78 +104,90 @@ try {
     console.log('⚠️  Failed to register project (non-fatal):', error.message);
   }
 
-  // Install hook and skill to .claude/ directory
+  // Install skills and clean up old hooks (v0.9.0+ uses Skills, not hooks)
   try {
     const cwd = process.cwd();
     const projectName = path.basename(cwd);
-    const packageHooksDir = path.join(__dirname, '../.claude/hooks');
     const packageSkillsDir = path.join(__dirname, '../.claude/skills');
 
     if (projectName !== 'claude-recall' && !cwd.includes('node_modules/.pnpm') && !cwd.includes('node_modules/claude-recall')) {
       const claudeDir = path.join(cwd, '.claude');
       const hooksDir = path.join(claudeDir, 'hooks');
+      const settingsPath = path.join(claudeDir, 'settings.json');
 
-      // Create .claude/hooks directory
-      if (!fs.existsSync(hooksDir)) {
-        fs.mkdirSync(hooksDir, { recursive: true });
-      }
-
-      // Copy single enforcement hook
-      const hookSource = path.join(packageHooksDir, 'memory_enforcer.py');
-      const hookDest = path.join(hooksDir, 'memory_enforcer.py');
+      // === CLEANUP: Remove old hooks (v0.9.0+ doesn't use hooks) ===
+      if (fs.existsSync(hooksDir)) {
+        // Remove known hook files from previous versions
+        const oldHooks = [
+          'memory_enforcer.py',
+          'pre_tool_search_enforcer.py',
+          'mcp_tool_tracker.py',
+          'pubnub_pre_tool_hook.py',
+          'pubnub_prompt_hook.py',
+          'user_prompt_capture.py',
+          'user_prompt_reminder.py'
+        ];
+
+        let removedCount = 0;
+        for (const hook of oldHooks) {
+          const hookPath = path.join(hooksDir, hook);
+          if (fs.existsSync(hookPath)) {
+            fs.unlinkSync(hookPath);
+            removedCount++;
+          }
+        }
 
-      if (fs.existsSync(hookSource)) {
-        fs.copyFileSync(hookSource, hookDest);
-        fs.chmodSync(hookDest, 0o755);
-        console.log('✅ Installed memory_enforcer.py to .claude/hooks/');
-      }
+        // Remove hooks directory if empty
+        try {
+          const remaining = fs.readdirSync(hooksDir);
+          if (remaining.length === 0) {
+            fs.rmdirSync(hooksDir);
+          }
+        } catch (e) {
+          // Ignore
+        }
 
-      // Copy skills directory
-      if (fs.existsSync(packageSkillsDir)) {
-        const skillsDir = path.join(claudeDir, 'skills');
-        copyDirRecursive(packageSkillsDir, skillsDir);
-        console.log('✅ Installed SKILL.md to .claude/skills/');
+        if (removedCount > 0) {
+          console.log(`🧹 Removed ${removedCount} old hook file(s) from .claude/hooks/`);
+        }
       }
 
-      // Create .claude/settings.json with hook configuration
-      const settingsPath = path.join(claudeDir, 'settings.json');
-      let settings = {};
-
+      // === CLEANUP: Clear hook configuration from settings.json ===
       if (fs.existsSync(settingsPath)) {
         try {
-          settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+          let settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+          const hadHooks = settings.hooks && Object.keys(settings.hooks).length > 0;
+
+          // Clear hooks - v0.9.0+ uses Skills instead
+          settings.hooks = {};
+          settings.hooksVersion = '2.0.0'; // Bump version to indicate skills-based
+
+          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+
+          if (hadHooks) {
+            console.log('🧹 Cleared old hook configuration from .claude/settings.json');
+          }
         } catch (e) {
-          settings = {};
+          // If settings.json is invalid, create fresh one
+          fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
         }
+      } else {
+        // Create new settings.json without hooks
+        if (!fs.existsSync(claudeDir)) {
+          fs.mkdirSync(claudeDir, { recursive: true });
+        }
+        fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
       }
 
-      const CURRENT_HOOKS_VERSION = '1.0.0';
-      const needsUpdate = !settings.hooks || settings.hooksVersion !== CURRENT_HOOKS_VERSION;
-
-      if (needsUpdate) {
-        settings.hooksVersion = CURRENT_HOOKS_VERSION;
-        settings.hooks = {
-          PreToolUse: [
-            {
-              matcher: "mcp__claude-recall__.*|Write|Edit|Bash|Task",
-              hooks: [
-                {
-                  type: "command",
-                  command: `python3 ${path.join(hooksDir, 'memory_enforcer.py')}`
-                }
-              ]
-            }
-          ]
-        };
-
-        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-        console.log('✅ Configured hook in .claude/settings.json');
-      } else {
-        console.log(`ℹ️  Hooks already at version ${CURRENT_HOOKS_VERSION}`);
+      // === INSTALL: Copy skills directory ===
+      if (fs.existsSync(packageSkillsDir)) {
+        const skillsDir = path.join(claudeDir, 'skills');
+        copyDirRecursive(packageSkillsDir, skillsDir);
+        console.log('✅ Installed SKILL.md to .claude/skills/');
       }
     }
   } catch (error) {
-    console.log('⚠️  Failed to install hooks/skills (non-fatal):', error.message);
+    console.log('⚠️  Failed to install skills (non-fatal):', error.message);
   }
 
   console.log('\n✅ Installation complete!\n');
@@ -173,6 +201,7 @@ try {
   console.log('');
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');
+  console.log('ℹ️  v0.9.0+ uses native Claude Skills instead of hooks.');
   console.log('💡 Your memories persist across conversations and restarts.\n');
 
 } catch (error) {

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

@@ -1,249 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentCommands = void 0;
-const fs_1 = require("fs");
-const os_1 = require("os");
-const path_1 = require("path");
-const child_process_1 = require("child_process");
-const chalk_1 = __importDefault(require("chalk"));
-/**
- * Memory Agent Management Commands
- *
- * Provides CLI commands for managing the autonomous memory agent:
- * - start: Start the memory agent daemon
- * - stop: Stop the memory agent
- * - restart: Restart the agent
- * - status: Check agent status
- * - logs: View agent logs
- */
-class AgentCommands {
-    static register(program) {
-        const agentCmd = program
-            .command('agent')
-            .description('Manage the autonomous memory agent');
-        // agent start - Start the memory agent daemon
-        agentCmd
-            .command('start')
-            .description('Start the memory agent daemon')
-            .option('--project <id>', 'Project ID to monitor')
-            .action(async (options) => {
-            await AgentCommands.start(options.project);
-        });
-        // agent stop - Stop the memory agent
-        agentCmd
-            .command('stop')
-            .description('Stop the memory agent')
-            .action(() => {
-            AgentCommands.stop();
-        });
-        // agent restart - Restart the agent
-        agentCmd
-            .command('restart')
-            .description('Restart the memory agent')
-            .option('--project <id>', 'Project ID to monitor')
-            .action(async (options) => {
-            await AgentCommands.restart(options.project);
-        });
-        // agent status - Check agent status
-        agentCmd
-            .command('status')
-            .description('Check memory agent status')
-            .action(() => {
-            AgentCommands.status();
-        });
-        // agent logs - Show agent logs
-        agentCmd
-            .command('logs')
-            .description('Show memory agent logs')
-            .option('--lines <number>', 'Number of lines to show', '50')
-            .action((options) => {
-            AgentCommands.logs(parseInt(options.lines));
-        });
-    }
-    /**
-     * Ensure agent directory exists
-     */
-    static ensureAgentDir() {
-        if (!(0, fs_1.existsSync)(AgentCommands.AGENT_DIR)) {
-            const fs = require('fs');
-            fs.mkdirSync(AgentCommands.AGENT_DIR, { recursive: true });
-        }
-    }
-    /**
-     * Start the memory agent as a background daemon
-     */
-    static async start(projectId) {
-        AgentCommands.ensureAgentDir();
-        // Check if already running
-        if ((0, fs_1.existsSync)(AgentCommands.PID_FILE)) {
-            const pid = parseInt((0, fs_1.readFileSync)(AgentCommands.PID_FILE, 'utf-8').trim());
-            try {
-                process.kill(pid, 0); // Check if process exists
-                console.log(chalk_1.default.yellow('⚠ Memory agent already running'));
-                console.log(`   PID: ${chalk_1.default.cyan(pid)}`);
-                console.log(`   Use ${chalk_1.default.cyan('npx claude-recall agent stop')} to stop it`);
-                console.log();
-                return;
-            }
-            catch {
-                // Process doesn't exist, remove stale PID file
-                (0, fs_1.unlinkSync)(AgentCommands.PID_FILE);
-            }
-        }
-        console.log(chalk_1.default.cyan('\n🤖 Starting Memory Agent\n'));
-        // Spawn agent as detached background process
-        const agentPath = (0, path_1.join)(__dirname, '..', '..', 'pubnub', 'memory-agent.js');
-        const args = projectId ? [projectId] : [];
-        const child = (0, child_process_1.spawn)('node', [agentPath, ...args], {
-            detached: true,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        // Write PID file
-        (0, fs_1.writeFileSync)(AgentCommands.PID_FILE, child.pid.toString());
-        // Pipe logs to file
-        const logStream = require('fs').createWriteStream(AgentCommands.LOG_FILE, { flags: 'a' });
-        child.stdout?.pipe(logStream);
-        child.stderr?.pipe(logStream);
-        // Detach from parent
-        child.unref();
-        console.log(chalk_1.default.green('✓ Memory agent started'));
-        console.log(`  PID:     ${chalk_1.default.cyan(child.pid)}`);
-        console.log(`  Project: ${chalk_1.default.yellow(projectId || 'global')}`);
-        console.log(`  Logs:    ${chalk_1.default.gray(AgentCommands.LOG_FILE)}`);
-        console.log();
-        console.log(chalk_1.default.gray(`💡 Use ${chalk_1.default.cyan('npx claude-recall agent logs')} to view logs`));
-        console.log(chalk_1.default.gray(`💡 Use ${chalk_1.default.cyan('npx claude-recall agent status')} to check status`));
-        console.log();
-        // Wait a bit to ensure startup, then exit cleanly
-        await new Promise((resolve) => setTimeout(resolve, 500));
-        process.exit(0);
-    }
-    /**
-     * Stop the memory agent
-     */
-    static stop() {
-        if (!(0, fs_1.existsSync)(AgentCommands.PID_FILE)) {
-            console.log(chalk_1.default.gray('✗ Memory agent is not running'));
-            console.log();
-            return;
-        }
-        const pid = parseInt((0, fs_1.readFileSync)(AgentCommands.PID_FILE, 'utf-8').trim());
-        try {
-            console.log(chalk_1.default.cyan('\n🛑 Stopping Memory Agent\n'));
-            console.log(`Stopping agent (PID: ${chalk_1.default.yellow(pid)})...`);
-            process.kill(pid, 'SIGTERM');
-            // Wait for process to exit
-            let attempts = 0;
-            const maxAttempts = 10;
-            const checkInterval = setInterval(() => {
-                try {
-                    process.kill(pid, 0);
-                    attempts++;
-                    if (attempts >= maxAttempts) {
-                        console.log(chalk_1.default.yellow('⚠ Agent did not stop gracefully, forcing...'));
-                        process.kill(pid, 'SIGKILL');
-                        clearInterval(checkInterval);
-                        (0, fs_1.unlinkSync)(AgentCommands.PID_FILE);
-                        console.log(chalk_1.default.green('✓ Memory agent stopped (forced)'));
-                        console.log();
-                    }
-                }
-                catch {
-                    // Process no longer exists
-                    clearInterval(checkInterval);
-                    (0, fs_1.unlinkSync)(AgentCommands.PID_FILE);
-                    console.log(chalk_1.default.green('✓ Memory agent stopped'));
-                    console.log();
-                }
-            }, 500);
-        }
-        catch (error) {
-            console.error(chalk_1.default.red(`✗ Failed to stop agent: ${error}`));
-            // Remove stale PID file
-            (0, fs_1.unlinkSync)(AgentCommands.PID_FILE);
-            console.log();
-        }
-    }
-    /**
-     * Restart the memory agent
-     */
-    static async restart(projectId) {
-        console.log(chalk_1.default.cyan('\n🔄 Restarting Memory Agent\n'));
-        // Stop if running
-        if ((0, fs_1.existsSync)(AgentCommands.PID_FILE)) {
-            AgentCommands.stop();
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-        }
-        // Start again
-        await AgentCommands.start(projectId);
-    }
-    /**
-     * Check agent status
-     */
-    static status() {
-        console.log(chalk_1.default.cyan('\n📊 Memory Agent Status\n'));
-        if (!(0, fs_1.existsSync)(AgentCommands.PID_FILE)) {
-            console.log(`Status: ${chalk_1.default.gray('✗ Not running')}`);
-            console.log();
-            console.log(chalk_1.default.gray(`💡 Start with: ${chalk_1.default.cyan('npx claude-recall agent start')}`));
-            console.log();
-            return;
-        }
-        const pid = parseInt((0, fs_1.readFileSync)(AgentCommands.PID_FILE, 'utf-8').trim());
-        try {
-            process.kill(pid, 0);
-            console.log(`Status: ${chalk_1.default.green('✓ Running')}`);
-            console.log(`PID:    ${chalk_1.default.cyan(pid)}`);
-            console.log(`Logs:   ${chalk_1.default.gray(AgentCommands.LOG_FILE)}`);
-            // Check log file size
-            if ((0, fs_1.existsSync)(AgentCommands.LOG_FILE)) {
-                const stats = require('fs').statSync(AgentCommands.LOG_FILE);
-                const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-                console.log(`Size:   ${chalk_1.default.gray(sizeMB)} ${chalk_1.default.gray('MB')}`);
-            }
-            console.log();
-            console.log(chalk_1.default.gray(`💡 View logs: ${chalk_1.default.cyan('npx claude-recall agent logs')}`));
-            console.log(chalk_1.default.gray(`💡 Stop agent: ${chalk_1.default.cyan('npx claude-recall agent stop')}`));
-            console.log();
-        }
-        catch {
-            console.log(`Status: ${chalk_1.default.yellow('✗ Not running')} ${chalk_1.default.gray('(stale PID file)')}`);
-            console.log();
-            (0, fs_1.unlinkSync)(AgentCommands.PID_FILE);
-        }
-    }
-    /**
-     * Show agent logs
-     */
-    static logs(lines = 50) {
-        if (!(0, fs_1.existsSync)(AgentCommands.LOG_FILE)) {
-            console.log(chalk_1.default.gray('✗ No logs found'));
-            console.log();
-            console.log(chalk_1.default.gray(`💡 Start agent first: ${chalk_1.default.cyan('npx claude-recall agent start')}`));
-            console.log();
-            return;
-        }
-        console.log(chalk_1.default.cyan(`\n📋 Memory Agent Logs (last ${lines} lines)\n`));
-        try {
-            // Use tail to show last N lines
-            const output = (0, child_process_1.execSync)(`tail -n ${lines} "${AgentCommands.LOG_FILE}"`, {
-                encoding: 'utf-8',
-            });
-            console.log(output);
-        }
-        catch (error) {
-            // Fallback: read entire file
-            const logs = (0, fs_1.readFileSync)(AgentCommands.LOG_FILE, 'utf-8');
-            const logLines = logs.split('\n');
-            console.log(logLines.slice(-lines).join('\n'));
-        }
-        console.log();
-    }
-}
-exports.AgentCommands = AgentCommands;
-AgentCommands.AGENT_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude-recall', 'agent');
-AgentCommands.PID_FILE = (0, path_1.join)(AgentCommands.AGENT_DIR, 'memory-agent.pid');
-AgentCommands.LOG_FILE = (0, path_1.join)(AgentCommands.AGENT_DIR, 'memory-agent.log');