get-claudia 1.46.0 → 1.47.0

package/memory-daemon/claudia_memory/__main__.py

@@ -143,13 +143,14 @@ def _check_and_repair_database(db_path: Path) -> None:
         return
 
     backup_pattern = str(db_path) + ".backup-*.db"
-    backups = sorted(glob.glob(backup_pattern))
+    backups = sorted(glob.glob(backup_pattern), key=os.path.getmtime)
     if backups:
         latest = backups[-1]
         logger.warning(f"Restoring database from backup: {latest}")
         shutil.copy2(latest, db_path)
-        for suffix in (".db-shm", ".db-wal"):
-            stale = Path(str(db_path).replace(".db", "") + suffix)
+        # Clean up stale WAL files using direct path concatenation
+        for suffix in ("-shm", "-wal"):
+            stale = Path(str(db_path) + suffix)
             if stale.exists():
                 stale.unlink()
                 logger.info(f"Removed stale WAL file: {stale}")
@@ -162,6 +163,104 @@ def _check_and_repair_database(db_path: Path) -> None:
         )
 
 
+def _auto_migrate_legacy() -> None:
+    """Auto-migrate data from legacy claudia.db if it exists.
+
+    When Claudia switched from a single claudia.db to project-hash naming
+    ({sha256[:12]}.db), no data migration was performed. This function
+    detects the orphaned legacy database and migrates its data into the
+    active project-specific database.
+
+    Properties:
+    - Idempotent: checks _meta flag, won't run twice
+    - Safe: backs up before touching anything, preserves original
+    - Non-fatal: catches all exceptions, logs, continues
+    """
+    from .migration import (
+        check_legacy_database,
+        is_migration_completed,
+        mark_migration_completed,
+        migrate_legacy_database,
+    )
+
+    try:
+        config = get_config()
+        legacy_path = Path.home() / ".claudia" / "memory" / "claudia.db"
+        active_path = Path(config.db_path)
+
+        # Skip if active db IS the legacy db (no project isolation active)
+        try:
+            if legacy_path.resolve() == active_path.resolve():
+                return
+        except OSError:
+            if str(legacy_path) == str(active_path):
+                return
+
+        # Skip if legacy database doesn't exist
+        if not legacy_path.exists():
+            return
+
+        # Skip if migration already completed (idempotent)
+        db = get_db()
+        if is_migration_completed(db):
+            return
+
+        # Check if legacy database has meaningful data
+        legacy_stats = check_legacy_database(legacy_path)
+        if not legacy_stats:
+            # Empty or unreadable legacy db -- mark complete so we don't check again
+            mark_migration_completed(db, {"skipped": "no_data"})
+            logger.info("Legacy claudia.db exists but has no data worth migrating")
+            return
+
+        logger.info(
+            f"Found legacy claudia.db with {legacy_stats.get('entities', 0)} entities "
+            f"and {legacy_stats.get('memories', 0)} memories"
+        )
+
+        # Create pre-migration backup of active database (if it has data)
+        if active_path.exists():
+            try:
+                backup_path = db.backup(label="pre-migration")
+                logger.info(f"Pre-migration backup created: {backup_path}")
+            except Exception as e:
+                logger.warning(f"Pre-migration backup failed: {e}")
+                # Continue anyway -- the migration is additive, not destructive
+
+        # Run the migration
+        logger.info(f"Starting legacy database migration: {legacy_path} -> {active_path}")
+        results = migrate_legacy_database(legacy_path, active_path)
+
+        # Mark migration as completed
+        mark_migration_completed(db, results)
+
+        # Rename the legacy database (preserve, don't delete)
+        from datetime import datetime as dt
+        date_suffix = dt.now().strftime("%Y-%m-%d")
+        migrated_path = legacy_path.with_suffix(f".db.migrated-{date_suffix}")
+        try:
+            legacy_path.rename(migrated_path)
+            logger.info(f"Renamed legacy database: {legacy_path} -> {migrated_path}")
+        except OSError as e:
+            logger.warning(f"Could not rename legacy database: {e}")
+
+        # Log summary
+        logger.info(
+            f"Legacy migration complete: "
+            f"{results.get('entities_created', 0)} entities created, "
+            f"{results.get('entities_mapped', 0)} mapped, "
+            f"{results.get('memories_migrated', 0)} memories migrated, "
+            f"{results.get('links_migrated', 0)} links migrated, "
+            f"{results.get('relationships_migrated', 0)} relationships migrated"
+        )
+
+    except Exception as e:
+        # Non-fatal: log error and continue with whatever data we have
+        logger.error(f"Legacy migration failed (non-fatal): {e}")
+        logger.info("Daemon will continue with current database. "
+                     "Run --migrate-legacy manually to retry.")
+
+
 def run_daemon(mcp_mode: bool = True, debug: bool = False, project_id: str = None) -> None:
     """
     Run the Claudia Memory Daemon.
@@ -207,6 +306,9 @@ def run_daemon(mcp_mode: bool = True, debug: bool = False, project_id: str = Non
         db.initialize()
         logger.info(f"Database initialized at {get_config().db_path}")
 
+        # Auto-migrate legacy claudia.db if it exists
+        _auto_migrate_legacy()
+
         # Start health server and scheduler - ONLY in standalone mode.
         # MCP server processes are ephemeral and session-bound; the standalone
         # daemon (LaunchAgent/systemd) owns port 3848 and handles scheduling.
@@ -324,6 +426,21 @@ def main():
         action="store_true",
         help="Preview mode for --migrate-vault-para: show routing plan without making changes",
     )
+    parser.add_argument(
+        "--migrate-legacy",
+        action="store_true",
+        help="Manually migrate data from legacy claudia.db to project-specific database",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Preview migration without making changes (use with --migrate-legacy)",
+    )
+    parser.add_argument(
+        "--legacy-db",
+        type=str,
+        help="Path to legacy database (default: ~/.claudia/memory/claudia.db)",
+    )
 
     args = parser.parse_args()
 
@@ -857,6 +974,87 @@ def main():
         run_para_migration(vault_path, db=db, preview=args.preview)
         return
 
+    if args.migrate_legacy:
+        # Manual legacy database migration
+        setup_logging(debug=args.debug)
+        from .migration import (
+            check_legacy_database,
+            is_migration_completed,
+            mark_migration_completed,
+            migrate_legacy_database,
+        )
+
+        db = get_db()
+        db.initialize()
+        config = get_config()
+
+        # Resolve paths
+        legacy_path = Path(args.legacy_db) if args.legacy_db else (
+            Path.home() / ".claudia" / "memory" / "claudia.db"
+        )
+        active_path = Path(config.db_path)
+
+        if not legacy_path.exists():
+            print(f"Legacy database not found: {legacy_path}")
+            sys.exit(1)
+
+        if str(legacy_path.resolve()) == str(active_path.resolve()):
+            print("Error: Legacy and active databases are the same file.")
+            print("Use --project-dir to specify a project for isolation.")
+            sys.exit(1)
+
+        # Check legacy data
+        legacy_stats = check_legacy_database(legacy_path)
+        if not legacy_stats:
+            print(f"Legacy database at {legacy_path} has no data to migrate.")
+            return
+
+        print(f"\nLegacy database: {legacy_path}")
+        print(f"Active database: {active_path}")
+        print(f"  Entities:      {legacy_stats.get('entities', 0)}")
+        print(f"  Memories:      {legacy_stats.get('memories', 0)}")
+        print(f"  Links:         {legacy_stats.get('links', 0)}")
+        print(f"  Relationships: {legacy_stats.get('relationships', 0)}")
+        if legacy_stats.get("earliest"):
+            print(f"  Date range:    {legacy_stats['earliest']} to {legacy_stats['latest']}")
+
+        if is_migration_completed(db):
+            print("\nNote: Migration was already completed previously.")
+            if not args.dry_run:
+                confirm = input("Run again? (y/N): ").strip().lower()
+                if confirm != "y":
+                    print("Cancelled.")
+                    return
+
+        if args.dry_run:
+            print("\nDry run mode -- no changes will be made.\n")
+            results = migrate_legacy_database(legacy_path, active_path, dry_run=True)
+        else:
+            # Backup active database before migration
+            if active_path.exists():
+                backup_path = db.backup(label="pre-migration")
+                print(f"\nBackup created: {backup_path}")
+
+            print("\nMigrating...")
+            results = migrate_legacy_database(legacy_path, active_path)
+            mark_migration_completed(db, results)
+
+            # Rename legacy database
+            from datetime import datetime as dt
+            date_suffix = dt.now().strftime("%Y-%m-%d")
+            migrated_path = legacy_path.with_suffix(f".db.migrated-{date_suffix}")
+            try:
+                legacy_path.rename(migrated_path)
+                print(f"Renamed: {legacy_path.name} -> {migrated_path.name}")
+            except OSError as e:
+                print(f"Warning: Could not rename legacy database: {e}")
+
+        print(f"\nResults:")
+        for key, value in results.items():
+            if value > 0:
+                print(f"  {key}: {value}")
+        return
+
     # Run the daemon
     run_daemon(mcp_mode=not args.standalone, debug=args.debug, project_id=project_id)
 

package/memory-daemon/claudia_memory/config.py

@@ -80,6 +80,8 @@ class MemoryConfig:
     # Backup settings
     backup_retention_count: int = 3  # Number of rolling backups to keep
     enable_pre_consolidation_backup: bool = True  # Auto-backup before consolidation
+    backup_daily_retention: int = 7   # Keep 7 daily labeled backups (1 week)
+    backup_weekly_retention: int = 4  # Keep 4 weekly labeled backups (1 month)
 
     # Retention settings (data cleanup during consolidation)
     audit_log_retention_days: int = 90
@@ -154,6 +156,10 @@ class MemoryConfig:
                     config.backup_retention_count = data["backup_retention_count"]
                 if "enable_pre_consolidation_backup" in data:
                     config.enable_pre_consolidation_backup = data["enable_pre_consolidation_backup"]
+                if "backup_daily_retention" in data:
+                    config.backup_daily_retention = data["backup_daily_retention"]
+                if "backup_weekly_retention" in data:
+                    config.backup_weekly_retention = data["backup_weekly_retention"]
                 if "audit_log_retention_days" in data:
                     config.audit_log_retention_days = data["audit_log_retention_days"]
                 if "prediction_retention_days" in data:
@@ -241,6 +247,12 @@ class MemoryConfig:
         if self.backup_retention_count < 1:
             logger.warning(f"backup_retention_count={self.backup_retention_count} below minimum, using 1")
             self.backup_retention_count = 1
+        if self.backup_daily_retention < 1:
+            logger.warning(f"backup_daily_retention={self.backup_daily_retention} below minimum, using 1")
+            self.backup_daily_retention = 1
+        if self.backup_weekly_retention < 1:
+            logger.warning(f"backup_weekly_retention={self.backup_weekly_retention} below minimum, using 1")
+            self.backup_weekly_retention = 1
         for attr in ("audit_log_retention_days", "prediction_retention_days", "turn_buffer_retention_days", "metrics_retention_days"):
             val = getattr(self, attr)
             if val < 1:
@@ -305,6 +317,8 @@ class MemoryConfig:
             "enable_auto_dedupe": self.enable_auto_dedupe,
             "auto_dedupe_threshold": self.auto_dedupe_threshold,
             "graph_proximity_weight": self.graph_proximity_weight,
+            "backup_daily_retention": self.backup_daily_retention,
+            "backup_weekly_retention": self.backup_weekly_retention,
         }
 
         with open(config_path, "w") as f:

package/memory-daemon/claudia_memory/daemon/scheduler.py

@@ -64,6 +64,24 @@ class MemoryScheduler:
             replace_existing=True,
         )
 
+        # Daily at 2:30am: Labeled daily backup (7-day retention)
+        self.scheduler.add_job(
+            self._run_daily_backup,
+            CronTrigger(hour=2, minute=30),
+            id="daily_backup",
+            name="Daily backup",
+            replace_existing=True,
+        )
+
+        # Weekly on Sunday at 2:45am: Labeled weekly backup (4-week retention)
+        self.scheduler.add_job(
+            self._run_weekly_backup,
+            CronTrigger(day_of_week="sun", hour=2, minute=45),
+            id="weekly_backup",
+            name="Weekly backup",
+            replace_existing=True,
+        )
+
         # Daily at 3:15am: Vault sync (after consolidation)
         if self.config.vault_sync_enabled:
             self.scheduler.add_job(
@@ -128,6 +146,24 @@ class MemoryScheduler:
         except Exception as e:
             logger.exception("Error in full consolidation")
 
+    def _run_daily_backup(self) -> None:
+        """Create a labeled daily backup with 7-day retention."""
+        try:
+            from ..database import get_db
+            backup_path = get_db().backup(label="daily")
+            logger.info(f"Daily backup created: {backup_path}")
+        except Exception as e:
+            logger.exception("Error in daily backup")
+
+    def _run_weekly_backup(self) -> None:
+        """Create a labeled weekly backup with 4-week retention."""
+        try:
+            from ..database import get_db
+            backup_path = get_db().backup(label="weekly")
+            logger.info(f"Weekly backup created: {backup_path}")
+        except Exception as e:
+            logger.exception("Error in weekly backup")
+
     def _run_vault_sync(self) -> None:
         """Run Obsidian vault sync + canvas regeneration"""
         try:

package/memory-daemon/claudia_memory/database.py

@@ -254,6 +254,9 @@ class Database:
             # Store workspace path in _meta for database identification
             self._store_workspace_path(conn)
 
+            # Register database in central registry
+            self._register_database()
+
             self._initialized = True
 
     # All vec0 virtual tables and their primary key columns
@@ -1133,6 +1136,49 @@ class Database:
             conn.commit()
             logger.debug(f"Stored workspace path in _meta: {workspace_path}")
 
+    def _register_database(self) -> None:
+        """Register this database in the central registry.
+
+        Maintains ~/.claudia/memory/registry.json with all known databases,
+        their workspace paths, and last-seen timestamps. Used by the visualizer
+        and /databases command to enumerate databases.
+        """
+        registry_path = Path.home() / ".claudia" / "memory" / "registry.json"
+
+        try:
+            if registry_path.exists():
+                with open(registry_path) as f:
+                    registry = json.load(f)
+            else:
+                registry = {"databases": []}
+
+            # Find or create entry for this database path
+            db_str = str(self.db_path)
+            entry = next(
+                (d for d in registry["databases"] if d["path"] == db_str), None
+            )
+
+            workspace = os.environ.get("CLAUDIA_WORKSPACE_PATH", "")
+            name = self.db_path.stem  # e.g., "6af67351bcfa" or "claudia"
+
+            if entry:
+                entry["workspace"] = workspace or entry.get("workspace", "")
+                entry["last_seen"] = datetime.now().isoformat()
+            else:
+                registry["databases"].append({
+                    "path": db_str,
+                    "workspace": workspace,
+                    "name": name,
+                    "registered_at": datetime.now().isoformat(),
+                    "last_seen": datetime.now().isoformat(),
+                })
+
+            registry_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(registry_path, "w") as f:
+                json.dump(registry, f, indent=2)
+        except Exception as e:
+            logger.debug(f"Registry update failed (non-fatal): {e}")
+
     def execute(
         self, sql: str, params: Tuple = (), fetch: bool = False
     ) -> Optional[List[sqlite3.Row]]:
@@ -1213,9 +1259,13 @@ class Database:
         rows = self.query(table, columns, where, where_params, limit=1)
         return rows[0] if rows else None
 
-    def backup(self) -> Path:
+    def backup(self, label: str = None) -> Path:
         """Create a backup of the database using SQLite's online backup API.
 
+        Args:
+            label: Optional label for categorized backups (e.g., "daily", "weekly",
+                   "pre-migration"). Labeled backups have independent retention counts.
+
         Returns:
             Path to the created backup file
         """
@@ -1223,7 +1273,10 @@ class Database:
 
         config = get_config()
         timestamp = datetime.now().strftime("%Y-%m-%d-%H%M%S")
-        backup_path = Path(f"{self.db_path}.backup-{timestamp}.db")
+        if label:
+            backup_path = Path(f"{self.db_path}.backup-{label}-{timestamp}.db")
+        else:
+            backup_path = Path(f"{self.db_path}.backup-{timestamp}.db")
 
         # Create backup using SQLite's built-in backup API
         backup_conn = sqlite3.connect(str(backup_path))
@@ -1232,12 +1285,30 @@ class Database:
         finally:
             backup_conn.close()
 
+        # Verify backup integrity
+        try:
+            verify_conn = sqlite3.connect(str(backup_path), timeout=5)
+            result = verify_conn.execute("PRAGMA integrity_check").fetchone()
+            verify_conn.close()
+            if result and result[0] != "ok":
+                logger.error(f"Backup verification FAILED: {result}")
+                backup_path.unlink(missing_ok=True)
+                raise RuntimeError(f"Backup integrity check failed: {result}")
+        except sqlite3.Error as e:
+            logger.warning(f"Backup verification could not run: {e}")
+
         logger.info(f"Database backed up to {backup_path}")
 
-        # Rolling retention: delete oldest backups beyond retention count
-        pattern = f"{self.db_path}.backup-*.db"
-        backups = sorted(glob.glob(pattern))
-        while len(backups) > config.backup_retention_count:
+        # Rolling retention (per-label if labeled)
+        if label:
+            pattern = f"{self.db_path}.backup-{label}-*.db"
+            retention = self._get_label_retention(label)
+        else:
+            pattern = f"{self.db_path}.backup-*.db"
+            retention = config.backup_retention_count
+
+        backups = sorted(glob.glob(pattern), key=os.path.getmtime)
+        while len(backups) > retention:
             oldest = backups.pop(0)
             try:
                 Path(oldest).unlink()
@@ -1247,6 +1318,15 @@ class Database:
 
         return backup_path
 
+    def _get_label_retention(self, label: str) -> int:
+        """Get retention count for a labeled backup category."""
+        config = get_config()
+        retention_map = {
+            "daily": config.backup_daily_retention,
+            "weekly": config.backup_weekly_retention,
+        }
+        return retention_map.get(label, config.backup_retention_count)
+
     def close(self) -> None:
         """Close the thread-local connection"""
         if hasattr(self._local, "connection") and self._local.connection: