claude-recall 0.2.10 → 0.2.12

package/README.md

@@ -16,6 +16,8 @@ Every time you start a new conversation with Claude, you're starting from scratc
 - **MCP Native**: Built on Anthropic's official Model Context Protocol for seamless integration
 - **Zero Configuration**: Start capturing memories immediately after installation
 - **Lightweight**: SQLite database with automatic memory management
+- **Restart Continuity**: Maintains state across Claude Code restarts for uninterrupted workflows
+- **Live Testing**: AI-driven testing with automatic restart and recovery capabilities
 
 ## 🚀 Quick Start
 
@@ -169,6 +171,40 @@ No manual configuration needed!
 - **You Own Your Data**: Export and delete at any time
 - **Open Source**: Inspect the code yourself
 
+## Restart Continuity & Live Testing (v0.2.11+)
+
+Claude Recall now includes advanced restart continuity and live testing capabilities, ensuring your workflows continue seamlessly even when Claude Code needs to restart.
+
+### Restart Continuity
+
+Maintains state across Claude Code restarts:
+- **Automatic Recovery**: Resumes interrupted tests and workflows after restart
+- **Checkpoint System**: Save progress points for granular recovery
+- **Session Tracking**: Preserves session context through restarts
+- **Pending Actions**: Queues actions to be processed after restart
+
+### Live Testing
+
+AI-driven testing with automatic restart capability:
+```bash
+# Start live testing with auto-restart
+claude-recall live-test start -s memory_persistence search_compliance
+
+# Check status
+claude-recall live-test status
+
+# View continuity state
+claude-recall live-test continuity
+```
+
+**Features:**
+- **Auto-Restart on Changes**: Detects hook/CLI changes and restarts automatically
+- **Test Recovery**: Resumes tests from last checkpoint after restart
+- **Result Injection**: Test results stored as searchable memories
+- **Configurable Policies**: Control restart behavior and limits
+
+See [RESTART_CONTINUITY.md](docs/RESTART_CONTINUITY.md) for detailed documentation.
+
 ## Advanced Usage
 
 ### Custom Memory Storage

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

@@ -43,6 +43,7 @@ const pattern_service_1 = require("../services/pattern-service");
 const migrate_1 = require("./commands/migrate");
 const server_1 = require("../mcp/server");
 const search_monitor_1 = require("../services/search-monitor");
+const live_test_1 = require("./commands/live-test");
 const program = new commander_1.Command();
 class ClaudeRecallCLI {
     constructor(options) {
@@ -252,7 +253,7 @@ async function main() {
     program
         .name('claude-recall')
         .description('Memory-enhanced Claude Code via MCP')
-        .version('0.2.10')
+        .version('0.2.12')
         .option('--verbose', 'Enable verbose logging')
         .option('--config <path>', 'Path to custom config file');
     // MCP command
@@ -318,6 +319,8 @@ async function main() {
     });
     // Migration commands
     migrate_1.MigrateCommand.register(program);
+    // Register live test command
+    new live_test_1.LiveTestCommand().register(program);
     // Search command
     program
         .command('search <query>')
@@ -330,6 +333,7 @@ async function main() {
             limit: parseInt(options.limit),
             json: options.json
         });
+        process.exit(0);
     });
     // Stats command
     program
@@ -338,6 +342,7 @@ async function main() {
         .action(() => {
         const cli = new ClaudeRecallCLI(program.opts());
         cli.showStats();
+        process.exit(0);
     });
     // Export command
     program
@@ -347,6 +352,7 @@ async function main() {
         .action(async (output, options) => {
         const cli = new ClaudeRecallCLI(program.opts());
         await cli.export(output, options);
+        process.exit(0);
     });
     // Import command
     program
@@ -355,6 +361,7 @@ async function main() {
         .action(async (input) => {
         const cli = new ClaudeRecallCLI(program.opts());
         await cli.import(input);
+        process.exit(0);
     });
     // Clear command
     program
@@ -365,6 +372,7 @@ async function main() {
         .action(async (options) => {
         const cli = new ClaudeRecallCLI(program.opts());
         await cli.clear(options);
+        process.exit(0);
     });
     // Status command
     program
@@ -373,6 +381,7 @@ async function main() {
         .action(async () => {
         const cli = new ClaudeRecallCLI(program.opts());
         await cli.status();
+        process.exit(0);
     });
     // Test memory search command
     program
@@ -412,6 +421,7 @@ async function main() {
         }
         console.log('\n📊 Memory search monitoring is active.');
         console.log('   Check logs to verify search calls are being made.\n');
+        process.exit(0);
     });
     // Search monitor command
     program
@@ -423,7 +433,7 @@ async function main() {
         if (options.clear) {
             monitor.clearLogs();
             console.log('✅ Search monitoring logs cleared.\n');
-            return;
+            process.exit(0);
         }
         console.log('\n📊 Memory Search Monitoring Statistics\n');
         const stats = monitor.getSearchStats();
@@ -459,6 +469,7 @@ async function main() {
             });
         }
         console.log('\n');
+        process.exit(0);
     });
     // Parse arguments
     await program.parseAsync(process.argv);

package/dist/cli/commands/live-test.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTestCommand = void 0;
+const live_testing_manager_1 = require("../../testing/live-testing-manager");
+const restart_continuity_1 = require("../../services/restart-continuity");
+const logging_1 = require("../../services/logging");
+class LiveTestCommand {
+    constructor() {
+        this.liveTestManager = live_testing_manager_1.LiveTestingManager.getInstance();
+        this.continuityManager = restart_continuity_1.RestartContinuityManager.getInstance();
+        this.logger = logging_1.LoggingService.getInstance();
+    }
+    register(program) {
+        const liveTestCmd = program
+            .command('live-test')
+            .description('Manage live testing with automatic restart capability');
+        // Start live testing
+        liveTestCmd
+            .command('start')
+            .description('Start a live testing session')
+            .option('-s, --scenario <scenarios...>', 'Test scenarios to run', ['memory_persistence', 'search_compliance'])
+            .option('-a, --auto-restart', 'Enable automatic restart on changes', true)
+            .option('-r, --restart-on-failure', 'Restart on test failures', true)
+            .option('-m, --max-restarts <number>', 'Maximum restart attempts', '3')
+            .option('-i, --inject-results', 'Inject test results as memories', true)
+            .action(async (options) => {
+            await this.startLiveTest(options);
+        });
+        // Check status
+        liveTestCmd
+            .command('status')
+            .description('Check live testing and continuity status')
+            .action(() => {
+            this.showStatus();
+        });
+        // Stop testing
+        liveTestCmd
+            .command('stop')
+            .description('Stop the current live testing session')
+            .action(async () => {
+            await this.stopLiveTest();
+        });
+        // Check continuity
+        liveTestCmd
+            .command('continuity')
+            .description('Show continuity state and restart information')
+            .action(() => {
+            this.showContinuity();
+        });
+        // Add checkpoint
+        liveTestCmd
+            .command('checkpoint <name>')
+            .description('Add a checkpoint for restart recovery')
+            .action((name) => {
+            this.addCheckpoint(name);
+        });
+        // Simulate restart
+        liveTestCmd
+            .command('restart')
+            .description('Simulate a restart for testing')
+            .option('-r, --reason <reason>', 'Reason for restart', 'manual_test')
+            .action((options) => {
+            this.simulateRestart(options.reason);
+        });
+    }
+    async startLiveTest(options) {
+        console.log('🚀 Starting Live Testing Session');
+        console.log('━'.repeat(50));
+        try {
+            // Parse scenarios
+            const scenarios = options.scenario.map((name) => ({
+                name,
+                params: {},
+                sessionId: `cli_${Date.now()}`
+            }));
+            // Configure live testing
+            this.liveTestManager.updateConfig({
+                autoRestart: options.autoRestart,
+                restartOnFailure: options.restartOnFailure,
+                maxRestartAttempts: parseInt(options.maxRestarts),
+                restartDelay: 2000,
+                watchFiles: [
+                    'src/hooks/**/*.sh',
+                    'src/cli/claude-recall-cli.ts',
+                    'src/services/**/*.ts'
+                ],
+                injectResults: options.injectResults
+            });
+            // Start session
+            const sessionId = await this.liveTestManager.startLiveTestSession(scenarios);
+            console.log('✅ Live testing session started');
+            console.log(`Session ID: ${sessionId}`);
+            console.log(`Scenarios: ${scenarios.map(s => s.name).join(', ')}`);
+            console.log();
+            console.log('Configuration:');
+            console.log(`  • Auto-restart: ${options.autoRestart ? 'enabled' : 'disabled'}`);
+            console.log(`  • Restart on failure: ${options.restartOnFailure ? 'enabled' : 'disabled'}`);
+            console.log(`  • Max restarts: ${options.maxRestarts}`);
+            console.log(`  • Inject results: ${options.injectResults ? 'enabled' : 'disabled'}`);
+            console.log();
+            console.log('Watching for file changes...');
+            console.log('Use "claude-recall live-test status" to check progress');
+        }
+        catch (error) {
+            console.error('❌ Failed to start live testing:', error.message);
+            process.exit(1);
+        }
+    }
+    showStatus() {
+        console.log('📊 Live Testing Status');
+        console.log('━'.repeat(50));
+        // Get live test status
+        const liveStatus = this.liveTestManager.getSessionStatus();
+        if (liveStatus.status === 'no_active_session') {
+            console.log('No active live testing session');
+        }
+        else {
+            console.log(`Session ID: ${liveStatus.sessionId}`);
+            console.log(`Status: ${this.getStatusEmoji(liveStatus.status)} ${liveStatus.status}`);
+            console.log(`Progress: ${liveStatus.testsRun}/${liveStatus.totalTests} tests`);
+            console.log(`Restart attempts: ${liveStatus.restartAttempts}`);
+            if (liveStatus.results && liveStatus.results.length > 0) {
+                console.log();
+                console.log('Test Results:');
+                liveStatus.results.forEach((result) => {
+                    const emoji = result.status === 'passed' ? '✅' : result.status === 'failed' ? '❌' : '⚠️';
+                    console.log(`  ${emoji} ${result.test}: ${result.status}`);
+                });
+            }
+        }
+        // Get continuity status
+        const continuityState = this.continuityManager.getCurrentState();
+        if (continuityState) {
+            console.log();
+            console.log('🔄 Continuity State');
+            console.log('━'.repeat(50));
+            console.log(`Session: ${continuityState.sessionId}`);
+            console.log(`Restarts: ${continuityState.restartCount}`);
+            console.log(`Test in progress: ${continuityState.testInProgress ? 'yes' : 'no'}`);
+            if (continuityState.currentTest) {
+                console.log(`Current test: ${continuityState.currentTest.name}`);
+                console.log(`Checkpoints: ${continuityState.currentTest.checkpoints.length}`);
+            }
+            if (continuityState.pendingActions.length > 0) {
+                console.log();
+                console.log(`Pending actions: ${continuityState.pendingActions.length}`);
+            }
+        }
+        // Stop monitoring to allow process to exit
+        this.continuityManager.stopMonitoring();
+    }
+    async stopLiveTest() {
+        console.log('🛑 Stopping Live Testing');
+        try {
+            await this.liveTestManager.stopLiveTestSession();
+            console.log('✅ Live testing session stopped');
+        }
+        catch (error) {
+            console.error('❌ Failed to stop live testing:', error.message);
+        }
+    }
+    showContinuity() {
+        console.log('🔄 Continuity Information');
+        console.log('━'.repeat(50));
+        const state = this.continuityManager.getCurrentState();
+        if (!state) {
+            console.log('No continuity state available');
+            return;
+        }
+        console.log('Session Information:');
+        console.log(`  • ID: ${state.sessionId}`);
+        console.log(`  • Restart count: ${state.restartCount}`);
+        console.log(`  • Last activity: ${new Date(state.lastActivity).toLocaleString()}`);
+        console.log();
+        if (state.testInProgress && state.currentTest) {
+            console.log('Current Test:');
+            console.log(`  • Name: ${state.currentTest.name}`);
+            console.log(`  • Started: ${new Date(state.currentTest.startTime).toLocaleString()}`);
+            console.log(`  • Checkpoints: ${state.currentTest.checkpoints.length}`);
+            if (state.currentTest.checkpoints.length > 0) {
+                console.log('  • Recent checkpoints:');
+                state.currentTest.checkpoints.slice(-3).forEach(cp => {
+                    console.log(`    - ${cp}`);
+                });
+            }
+        }
+        else {
+            console.log('No test currently in progress');
+        }
+        if (state.pendingActions.length > 0) {
+            console.log();
+            console.log(`Pending Actions (${state.pendingActions.length}):`);
+            state.pendingActions.forEach(action => {
+                console.log(`  • ${action.type} - ${new Date(action.timestamp).toLocaleString()}`);
+            });
+        }
+        // Stop monitoring to allow process to exit
+        this.continuityManager.stopMonitoring();
+    }
+    addCheckpoint(name) {
+        console.log('➕ Adding Checkpoint');
+        try {
+            this.continuityManager.addCheckpoint(name);
+            console.log(`✅ Checkpoint added: ${name}`);
+            const state = this.continuityManager.getCurrentState();
+            if (state?.currentTest) {
+                console.log(`Total checkpoints: ${state.currentTest.checkpoints.length}`);
+            }
+        }
+        catch (error) {
+            console.error('❌ Failed to add checkpoint:', error.message);
+        }
+        finally {
+            // Stop monitoring to allow process to exit
+            this.continuityManager.stopMonitoring();
+        }
+    }
+    simulateRestart(reason) {
+        console.log('🔄 Simulating Restart');
+        console.log('━'.repeat(50));
+        console.log(`Reason: ${reason}`);
+        console.log('Note: This simulates a restart for testing purposes');
+        console.log('In production, Claude Code would actually restart');
+        // Add restart action to continuity
+        this.continuityManager.addPendingAction('simulated_restart', {
+            reason,
+            timestamp: Date.now()
+        });
+        console.log();
+        console.log('✅ Restart simulation recorded');
+        console.log('The restart will be detected on next actual restart');
+        // Stop monitoring to allow process to exit
+        this.continuityManager.stopMonitoring();
+    }
+    getStatusEmoji(status) {
+        switch (status) {
+            case 'running': return '🏃';
+            case 'completed': return '✅';
+            case 'failed': return '❌';
+            case 'restarting': return '🔄';
+            default: return '❓';
+        }
+    }
+}
+exports.LiveTestCommand = LiveTestCommand;

package/dist/hooks/minimal/post-tool-trigger.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Minimal Post-Tool Hook Trigger
+ *
+ * This is a lightweight trigger that delegates all business logic
+ * to the claude-recall-cli service layer. This hook only handles
+ * data forwarding and process management.
+ */
+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 });
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+// Determine CLI path - prefer built version, fallback to source
+const CLI_PATHS = [
+    path.join(__dirname, '../../dist/cli/claude-recall-cli.js'),
+    path.join(__dirname, '../../cli/claude-recall-cli.js'),
+    'claude-recall-cli' // Global installation
+];
+function findCliPath() {
+    const fs = require('fs');
+    for (const cliPath of CLI_PATHS) {
+        try {
+            if (fs.existsSync(cliPath)) {
+                return cliPath;
+            }
+        }
+        catch (error) {
+            // Continue to next path
+        }
+    }
+    // Fallback to global command
+    return 'claude-recall-cli';
+}
+async function executeCLI() {
+    return new Promise((resolve, reject) => {
+        const cliPath = findCliPath();
+        const isGlobal = cliPath === 'claude-recall-cli';
+        // Spawn the CLI process
+        const child = (0, child_process_1.spawn)(isGlobal ? cliPath : 'node', isGlobal ? ['post-tool'] : [cliPath, 'post-tool'], {
+            stdio: ['pipe', 'inherit', 'inherit'],
+            env: process.env
+        });
+        // Forward stdin data to CLI
+        process.stdin.pipe(child.stdin);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`CLI process exited with code ${code}`));
+            }
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        // Handle process signals
+        process.on('SIGTERM', () => child.kill('SIGTERM'));
+        process.on('SIGINT', () => child.kill('SIGINT'));
+    });
+}
+// Main execution
+async function main() {
+    try {
+        await executeCLI();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Post-tool hook error:', error);
+        process.exit(1);
+    }
+}
+// Handle timeout at process level
+const timeout = parseInt(process.env.CLAUDE_RECALL_HOOK_TIMEOUT || '5000');
+const timeoutHandle = setTimeout(() => {
+    console.error('Post-tool hook timeout');
+    process.exit(1);
+}, timeout);
+// Clear timeout when we start processing
+process.stdin.once('data', () => {
+    clearTimeout(timeoutHandle);
+});
+if (require.main === module) {
+    main();
+}

package/dist/hooks/minimal/pre-tool-trigger.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Minimal Pre-Tool Hook Trigger
+ *
+ * This is a lightweight trigger that delegates all business logic
+ * to the claude-recall-cli service layer. This hook only handles
+ * data forwarding and process management.
+ */
+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 });
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+// Determine CLI path - prefer built version, fallback to source
+const CLI_PATHS = [
+    path.join(__dirname, '../../dist/cli/claude-recall-cli.js'),
+    path.join(__dirname, '../../cli/claude-recall-cli.js'),
+    'claude-recall-cli' // Global installation
+];
+function findCliPath() {
+    const fs = require('fs');
+    for (const cliPath of CLI_PATHS) {
+        try {
+            if (fs.existsSync(cliPath)) {
+                return cliPath;
+            }
+        }
+        catch (error) {
+            // Continue to next path
+        }
+    }
+    // Fallback to global command
+    return 'claude-recall-cli';
+}
+async function executeCLI() {
+    return new Promise((resolve, reject) => {
+        const cliPath = findCliPath();
+        const isGlobal = cliPath === 'claude-recall-cli';
+        // Spawn the CLI process
+        const child = (0, child_process_1.spawn)(isGlobal ? cliPath : 'node', isGlobal ? ['pre-tool'] : [cliPath, 'pre-tool'], {
+            stdio: ['pipe', 'inherit', 'inherit'],
+            env: process.env
+        });
+        // Forward stdin data to CLI
+        process.stdin.pipe(child.stdin);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`CLI process exited with code ${code}`));
+            }
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        // Handle process signals
+        process.on('SIGTERM', () => child.kill('SIGTERM'));
+        process.on('SIGINT', () => child.kill('SIGINT'));
+    });
+}
+// Main execution
+async function main() {
+    try {
+        await executeCLI();
+        process.exit(0);
+    }
+    catch (error) {
+        console.error('Pre-tool hook error:', error);
+        process.exit(1);
+    }
+}
+// Handle timeout at process level
+const timeout = parseInt(process.env.CLAUDE_RECALL_HOOK_TIMEOUT || '5000');
+const timeoutHandle = setTimeout(() => {
+    console.error('Pre-tool hook timeout');
+    process.exit(1);
+}, timeout);
+// Clear timeout when we start processing
+process.stdin.once('data', () => {
+    clearTimeout(timeoutHandle);
+});
+if (require.main === module) {
+    main();
+}