claude-recall 0.7.5 → 0.7.6

package/README.md

@@ -136,6 +136,51 @@ npm install -g claude-recall@latest
 
 **Note:** MCP server configuration in `~/.claude.json` persists across updates. You only need to update the package.
 
+### Schema Migration (v0.7.6+)
+
+**Automatic Migration:**
+
+Starting with v0.7.6, Claude Recall automatically migrates your database schema when needed. The first time you run any command after upgrading, missing columns will be added automatically.
+
+**What Gets Migrated:**
+- `sophistication_level` column (added in v0.7.0)
+- `scope` column (added in v0.7.2)
+
+You'll see console messages like:
+```
+📋 Migrating database schema: Adding scope column...
+✅ Added scope column
+```
+
+**Manual Migration (Optional):**
+
+If you prefer to run the migration explicitly:
+
+```bash
+# Check current schema and migrate if needed
+npx claude-recall migrate schema
+
+# Create backup before migration
+npx claude-recall migrate schema --backup
+```
+
+**Troubleshooting Schema Errors:**
+
+If you see errors like:
+- `"no such column: scope"`
+- `"no such column: sophistication_level"`
+
+Run the manual migration:
+```bash
+npx claude-recall migrate schema --backup
+```
+
+This will:
+1. Create a backup of your database (if `--backup` flag used)
+2. Add any missing columns
+3. Create necessary indexes
+4. Verify the migration succeeded
+
 ## Verifying Claude Recall is Working
 
 To confirm claude-recall is active in your Claude Code session:
@@ -529,9 +574,14 @@ npx claude-recall monitor                      # View search monitoring stats
 npx claude-recall test-memory-search           # Test if Claude searches before file creation
 ```
 
-**Migration (if upgrading from old versions):**
+**Migration:**
 ```bash
-npx claude-recall migrate       # Migrate from file-watcher to MCP architecture
+# Database schema migration (v0.7.6+)
+npx claude-recall migrate schema                # Migrate database schema (automatic)
+npx claude-recall migrate schema --backup       # Create backup before migration
+
+# Architecture migration (file-watcher → MCP)
+npx claude-recall migrate                       # Migrate from file-watcher to MCP architecture
 ```
 
 ### Global Options

package/dist/cli/commands/migrate.js

@@ -73,6 +73,14 @@ class MigrateCommand {
             const migrator = new MigrateCommand();
             await migrator.completeMigration();
         });
+        migrateCmd
+            .command('schema')
+            .description('Migrate database schema to latest version (adds missing columns)')
+            .option('--backup', 'Create backup before migration')
+            .action(async (options) => {
+            const migrator = new MigrateCommand();
+            await migrator.migrateSchema(options.backup);
+        });
     }
     async checkInstallation() {
         console.log('🔍 Checking for existing Claude Recall installation...\n');
@@ -241,5 +249,69 @@ class MigrateCommand {
         }
         return false;
     }
+    async migrateSchema(createBackup = false) {
+        console.log('📋 Migrating database schema...\n');
+        try {
+            const dbPath = path.join(os.homedir(), '.claude-recall', 'claude-recall.db');
+            if (!fs.existsSync(dbPath)) {
+                console.log('❌ Database not found. Nothing to migrate.');
+                return;
+            }
+            // Create backup if requested
+            if (createBackup) {
+                const backupPath = `${dbPath}.backup.${Date.now()}`;
+                console.log(`📦 Creating backup: ${backupPath}`);
+                fs.copyFileSync(dbPath, backupPath);
+                console.log('✅ Backup created\n');
+            }
+            // Access storage to trigger migration
+            const { MemoryStorage } = require('../../memory/storage');
+            const storage = new MemoryStorage(dbPath);
+            // Check what columns exist
+            const db = storage.getDatabase();
+            const columns = db.prepare("PRAGMA table_info(memories)").all();
+            const columnNames = columns.map((c) => c.name);
+            console.log('Current schema columns:');
+            console.log('  ' + columnNames.join(', '));
+            const hasSophistication = columnNames.includes('sophistication_level');
+            const hasScope = columnNames.includes('scope');
+            if (hasSophistication && hasScope) {
+                console.log('\n✅ Schema is already up to date!');
+                console.log('   All required columns are present.');
+            }
+            else {
+                console.log('\n📋 Schema update needed:');
+                if (!hasSophistication) {
+                    console.log('   - Missing: sophistication_level (added in v0.7.0)');
+                }
+                if (!hasScope) {
+                    console.log('   - Missing: scope (added in v0.7.2)');
+                }
+                console.log('\n⚙️  Running migration...');
+                // The migration happens automatically when MemoryStorage initializes
+                // Just force a re-init by creating a new instance
+                const { MemoryStorage: Storage2 } = require('../../memory/storage');
+                new Storage2(dbPath);
+                console.log('\n✅ Migration complete!');
+                console.log('   Database schema is now up to date.');
+            }
+            // Display stats
+            console.log('\n📊 Database stats:');
+            const stats = storage.getStats();
+            console.log(`   Total memories: ${stats.total}`);
+            if (stats.byType) {
+                console.log('   By type:');
+                for (const [type, count] of Object.entries(stats.byType)) {
+                    console.log(`     ${type}: ${count}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error('\n❌ Migration failed:', error);
+            console.log('\nIf you created a backup, you can restore it manually:');
+            console.log(`  cp ~/.claude-recall/claude-recall.db.backup.* ~/.claude-recall/claude-recall.db`);
+            process.exit(1);
+        }
+    }
 }
 exports.MigrateCommand = MigrateCommand;

package/dist/memory/storage.js

@@ -54,7 +54,8 @@ class MemoryStorage {
         try {
             const tableExists = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get();
             if (tableExists) {
-                // Database is already initialized, skip schema execution
+                // Database is already initialized, run schema migration if needed
+                this.migrateSchema();
                 return;
             }
         }
@@ -78,6 +79,35 @@ class MemoryStorage {
             }
         }
     }
+    /**
+     * Migrate existing database schema to add missing columns
+     * Adds columns introduced in v0.7.0+ (sophistication_level, scope)
+     */
+    migrateSchema() {
+        try {
+            // Get existing columns
+            const columns = this.db.prepare("PRAGMA table_info(memories)").all();
+            const columnNames = columns.map(c => c.name);
+            // Add sophistication_level if missing (v0.7.0+)
+            if (!columnNames.includes('sophistication_level')) {
+                console.log('📋 Migrating database schema: Adding sophistication_level column...');
+                this.db.exec('ALTER TABLE memories ADD COLUMN sophistication_level INTEGER DEFAULT 1');
+                this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_sophistication ON memories(sophistication_level)');
+                console.log('✅ Added sophistication_level column');
+            }
+            // Add scope if missing (v0.7.2+)
+            if (!columnNames.includes('scope')) {
+                console.log('📋 Migrating database schema: Adding scope column...');
+                this.db.exec("ALTER TABLE memories ADD COLUMN scope TEXT CHECK(scope IN ('universal', 'project', NULL))");
+                this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)');
+                console.log('✅ Added scope column');
+            }
+        }
+        catch (error) {
+            console.error('⚠️  Schema migration error:', error);
+            // Don't throw - let the database continue with existing schema
+        }
+    }
     save(memory) {
         const stmt = this.db.prepare(`
       INSERT OR REPLACE INTO memories
@@ -126,7 +156,9 @@ class MemoryStorage {
             is_active: row.is_active === 1,
             superseded_by: row.superseded_by,
             superseded_at: row.superseded_at,
-            confidence_score: row.confidence_score
+            confidence_score: row.confidence_score,
+            sophistication_level: row.sophistication_level || 1,
+            scope: row.scope || null
         };
     }
     searchByContext(context) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claude-recall",
-  "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",
+  "version": "0.7.6",
+  "description": "Persistent memory for Claude Code with automatic capture, failure learning, sophistication tracking, project scoping, project registry, and automatic schema migration via MCP server",
   "main": "dist/index.js",
   "bin": {
     "claude-recall": "dist/cli/claude-recall-cli.js"