Fix all remaining TODO items

namespace.py:
- create_collection: Persists config to KV storage
- get_collection: Loads from storage if not in cache
- list_collections: Scans storage prefix for all collections
- delete_collection: Removes config and all vectors from storage

database.py:
- stats(): Returns placeholder dict (accurate count needs FFI)
- checkpoint(): Safely calls FFI if available, no-op otherwise

Collections now persist across db close/reopen.

Author: sushanthpy

src/toondb/database.py

@@ -1566,10 +1566,11 @@ def stats(self) -> dict:
             >>> print(f"Keys: {stats.get('keys_count', 'N/A')}")
             >>> print(f"Bytes written: {stats.get('bytes_written', 0)}")
         """
-        # TODO: Add FFI binding for stats
-        # For now, return placeholder that won't crash
+        # Note: Accurate key count would require FFI binding to storage engine stats
+        # For now, return placeholder values that won't crash
+        # (scan_prefix requires 2+ byte prefix, so empty prefix scan won't work)
         return {
-            "keys_count": 0,
+            "keys_count": -1,  # -1 indicates "unknown" - would need FFI for real count
             "bytes_written": 0,
             "bytes_read": 0,
             "transactions_committed": 0,
@@ -1601,9 +1602,19 @@ def checkpoint(self) -> None:
                 db.put(record.key, record.value)
             db.checkpoint()  # Ensure all data is durable
         """
-        # TODO: Add FFI binding for checkpoint
-        # For now, this is a no-op as data is auto-flushed
-        pass
+        # Call FFI checkpoint if available
+        # Note: _lib and _ptr may not exist in all connection modes
+        lib = getattr(self, '_lib', None)
+        ptr = getattr(self, '_ptr', None)
+        if lib is not None and ptr is not None:
+            try:
+                checkpoint_fn = getattr(lib, 'toondb_checkpoint', None)
+                if checkpoint_fn:
+                    checkpoint_fn(ptr)
+            except Exception:
+                # Non-fatal: checkpoint may not be supported
+                pass
+        # In modes without FFI, data is auto-flushed on transaction commit
 
     def _check_open(self) -> None:
         """Check that database is open."""

src/toondb/namespace.py

@@ -893,11 +893,19 @@ def create_collection(
                 **kwargs,
             )
 
-        # Check if exists
+        # Check if exists in memory
         if config.name in self._collections:
             raise CollectionExistsError(config.name, self._name)
 
-        # TODO: Create via storage layer
+        # Check if exists in storage
+        config_key = f"{self._name}/_collections/{config.name}".encode()
+        if self._db.get(config_key) is not None:
+            raise CollectionExistsError(config.name, self._name)
+        
+        # Persist config to storage
+        self._db.put(config_key, json.dumps(config.to_dict()).encode())
+        
+        # Create and cache collection handle
         collection = Collection(self, config)
         self._collections[config.name] = collection
 
@@ -919,7 +927,15 @@ def get_collection(self, name: str) -> Collection:
         if name in self._collections:
             return self._collections[name]
 
-        # TODO: Load from storage
+        # Try loading from storage
+        config_key = f"{self._name}/_collections/{name}".encode()
+        data = self._db.get(config_key)
+        if data is not None:
+            config = CollectionConfig.from_dict(json.loads(data.decode()))
+            collection = Collection(self, config)
+            self._collections[name] = collection
+            return collection
+        
         raise CollectionNotFoundError(name, self._name)
 
     def collection(self, name: str) -> Collection:
@@ -928,16 +944,37 @@ def collection(self, name: str) -> Collection:
 
     def list_collections(self) -> List[str]:
         """List all collections in this namespace."""
-        # TODO: Load from storage
-        return list(self._collections.keys())
+        # Scan storage for all collection configs
+        prefix = f"{self._name}/_collections/".encode()
+        names = set(self._collections.keys())  # Start with cached
+        
+        with self._db.transaction() as txn:
+            for key, _ in txn.scan_prefix(prefix):
+                name = key.decode().split("/")[-1]
+                names.add(name)
+        
+        return sorted(names)
 
     def delete_collection(self, name: str) -> bool:
-        """Delete a collection."""
-        if name not in self._collections:
+        """Delete a collection and all its data."""
+        # Check if exists (load from storage if needed)
+        config_key = f"{self._name}/_collections/{name}".encode()
+        if name not in self._collections and self._db.get(config_key) is None:
             raise CollectionNotFoundError(name, self._name)
 
-        del self._collections[name]
-        # TODO: Delete from storage
+        # Remove from cache
+        if name in self._collections:
+            del self._collections[name]
+        
+        # Delete config from storage
+        self._db.delete(config_key)
+        
+        # Delete all vectors in collection
+        vectors_prefix = f"{self._name}/collections/{name}/vectors/".encode()
+        with self._db.transaction() as txn:
+            for key, _ in txn.scan_prefix(vectors_prefix):
+                txn.delete(key)
+        
         return True
 
     # ========================================================================