cinchdb 0.1.10__tar.gz → 0.1.11__tar.gz

{cinchdb-0.1.10 → cinchdb-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.10
+Version: 0.1.11
 Summary: A Git-like SQLite database management system with branching and multi-tenancy
 Project-URL: Homepage, https://github.com/russellromney/cinchdb
 Project-URL: Documentation, https://russellromney.github.io/cinchdb
@@ -58,10 +58,7 @@ cinch branch merge-into-main feature
 cinch tenant create customer_a
 cinch query "SELECT * FROM users" --tenant customer_a
 
-# Coming soon 
-# Connect to remote CinchDB instance
-cinch remote add production https://your-cinchdb-server.com your-api-key
-cinch remote use production
+# Future: Remote connectivity planned for production deployment
 
 # Autogenerate Python SDK from database
 cinch codegen generate python cinchdb_models/
@@ -75,9 +72,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **Multi-tenant isolation** - shared schema, isolated data per tenant
 - **Automatic change tracking** - all schema changes tracked and mergeable
 - **Safe structure changes** - change merges happen atomically with zero rollback risk (seriously)
-- **Remote connectivity** - Connect to hosted CinchDB instances
-- **Type-safe SDK** - Python and TypeScript SDKs with full type safety
-- **Remote-capable** - coming soon - CLI and SDK can connect to remote instances
+- **Type-safe Python SDK** - Python SDK with full type safety
 - **SDK generation from database schema** - Generate a typesafe SDK from your database models for CRUD operations
 
 ## Installation
@@ -149,37 +144,11 @@ results = db.insert("posts", *post_list)
 db.update("posts", post_id, {"content": "Updated content"})
 ```
 
-### Remote Connection
-
-Coming soon.
-
-```python
-# Connect to remote instance
-db = cinchdb.connect("myapp", url="https://your-cinchdb-server.com", api_key="your-api-key")
-
-# Same interface as local
-results = db.query("SELECT * FROM users")
-user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
-```
-
-## Remote Access - coming soon 
-
-Connect to a remote CinchDB instance:
-
-```bash
-cinch remote add production https://your-cinchdb-server.com your-api-key
-cinch remote use production
-# Now all commands will use the remote instance
-```
-
-Interactive docs at `/docs`, health check at `/health`.
 
 ## Architecture
 
-- **Python SDK**: Core functionality (local + remote)
-- **CLI**: Full-featured command-line interface  
-- **Remote Access**: Connect to hosted CinchDB instances
-- **TypeScript SDK**: Browser and Node.js client
+- **Python SDK**: Core functionality for local development
+- **CLI**: Full-featured command-line interface
 
 ## Development
 

{cinchdb-0.1.10 → cinchdb-0.1.11}/README.md

@@ -31,10 +31,7 @@ cinch branch merge-into-main feature
 cinch tenant create customer_a
 cinch query "SELECT * FROM users" --tenant customer_a
 
-# Coming soon 
-# Connect to remote CinchDB instance
-cinch remote add production https://your-cinchdb-server.com your-api-key
-cinch remote use production
+# Future: Remote connectivity planned for production deployment
 
 # Autogenerate Python SDK from database
 cinch codegen generate python cinchdb_models/
@@ -48,9 +45,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **Multi-tenant isolation** - shared schema, isolated data per tenant
 - **Automatic change tracking** - all schema changes tracked and mergeable
 - **Safe structure changes** - change merges happen atomically with zero rollback risk (seriously)
-- **Remote connectivity** - Connect to hosted CinchDB instances
-- **Type-safe SDK** - Python and TypeScript SDKs with full type safety
-- **Remote-capable** - coming soon - CLI and SDK can connect to remote instances
+- **Type-safe Python SDK** - Python SDK with full type safety
 - **SDK generation from database schema** - Generate a typesafe SDK from your database models for CRUD operations
 
 ## Installation
@@ -122,37 +117,11 @@ results = db.insert("posts", *post_list)
 db.update("posts", post_id, {"content": "Updated content"})
 ```
 
-### Remote Connection
-
-Coming soon.
-
-```python
-# Connect to remote instance
-db = cinchdb.connect("myapp", url="https://your-cinchdb-server.com", api_key="your-api-key")
-
-# Same interface as local
-results = db.query("SELECT * FROM users")
-user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
-```
-
-## Remote Access - coming soon 
-
-Connect to a remote CinchDB instance:
-
-```bash
-cinch remote add production https://your-cinchdb-server.com your-api-key
-cinch remote use production
-# Now all commands will use the remote instance
-```
-
-Interactive docs at `/docs`, health check at `/health`.
 
 ## Architecture
 
-- **Python SDK**: Core functionality (local + remote)
-- **CLI**: Full-featured command-line interface  
-- **Remote Access**: Connect to hosted CinchDB instances
-- **TypeScript SDK**: Browser and Node.js client
+- **Python SDK**: Core functionality for local development
+- **CLI**: Full-featured command-line interface
 
 ## Development
 

{cinchdb-0.1.10 → cinchdb-0.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinchdb"
-version = "0.1.10"
+version = "0.1.11"
 description = "A Git-like SQLite database management system with branching and multi-tenancy"
 readme = "README.md"
 requires-python = ">=3.10"

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/cli/commands/column.py

@@ -41,14 +41,14 @@ def list_columns(
         col_table.add_column("Name", style="cyan")
         col_table.add_column("Type", style="green")
         col_table.add_column("Nullable", style="yellow")
-        col_table.add_column("Primary Key", style="red")
+        col_table.add_column("Unique", style="red")
         col_table.add_column("Default", style="blue")
 
         for col in columns:
             nullable = "Yes" if col.nullable else "No"
-            pk = "Yes" if col.primary_key else "No"
+            unique = "Yes" if col.unique else "No"
             default = col.default or "-"
-            col_table.add_row(col.name, col.type, nullable, pk, default)
+            col_table.add_row(col.name, col.type, nullable, unique, default)
 
         console.print(col_table)
 
@@ -217,7 +217,6 @@ def info(
         console.print(f"Table: {table}")
         console.print(f"Type: {column.type}")
         console.print(f"Nullable: {'Yes' if column.nullable else 'No'}")
-        console.print(f"Primary Key: {'Yes' if column.primary_key else 'No'}")
         console.print(f"Unique: {'Yes' if column.unique else 'No'}")
         console.print(f"Default: {column.default or 'None'}")
 

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/cli/commands/database.py

@@ -75,43 +75,18 @@ def create(
 
     config, config_data = get_config_with_data()
 
-    # Create database directory structure
-    db_path = config.project_dir / ".cinchdb" / "databases" / name
-    if db_path.exists():
+    # Use the ProjectInitializer to create the database properly
+    from cinchdb.core.initializer import ProjectInitializer
+    
+    initializer = ProjectInitializer(config.project_dir)
+    
+    try:
+        # Create database using initializer (lazy by default)
+        initializer.init_database(name, description=description, lazy=True)
+    except FileExistsError:
         console.print(f"[red]❌ Database '{name}' already exists[/red]")
         raise typer.Exit(1)
 
-    # Create the database structure
-    db_path.mkdir(parents=True)
-    branches_dir = db_path / "branches"
-    branches_dir.mkdir()
-
-    # Create main branch
-    main_branch = branches_dir / "main"
-    main_branch.mkdir()
-
-    # Create main tenant
-    tenants_dir = main_branch / "tenants"
-    tenants_dir.mkdir()
-    main_tenant = tenants_dir / "main.db"
-    main_tenant.touch()
-
-    # Create branch metadata
-    import json
-    from datetime import datetime, timezone
-
-    metadata = {
-        "name": "main",
-        "parent": None,
-        "created_at": datetime.now(timezone.utc).isoformat(),
-    }
-    with open(main_branch / "metadata.json", "w") as f:
-        json.dump(metadata, f, indent=2)
-
-    # Create empty changes file
-    with open(main_branch / "changes.json", "w") as f:
-        json.dump([], f)
-
     console.print(f"[green]✅ Created database '{name}'[/green]")
 
     if switch:
@@ -134,11 +109,15 @@ def delete(
         raise typer.Exit(1)
 
     config, config_data = get_config_with_data()
-    db_path = config.project_dir / ".cinchdb" / "databases" / name
-
-    if not db_path.exists():
-        console.print(f"[red]❌ Database '{name}' does not exist[/red]")
-        raise typer.Exit(1)
+    
+    # Check if database exists in metadata
+    from cinchdb.infrastructure.metadata_db import MetadataDB
+    
+    with MetadataDB(config.project_dir) as metadata_db:
+        db_info = metadata_db.get_database(name)
+        if not db_info:
+            console.print(f"[red]❌ Database '{name}' does not exist[/red]")
+            raise typer.Exit(1)
 
     # Confirmation
     if not force:
@@ -147,10 +126,17 @@ def delete(
             console.print("[yellow]Cancelled[/yellow]")
             raise typer.Exit(0)
 
-    # Delete the database
+    # Delete the database from metadata and filesystem if materialized
     import shutil
-
-    shutil.rmtree(db_path)
+    
+    with MetadataDB(config.project_dir) as metadata_db:
+        # Delete from metadata
+        metadata_db.delete_database(db_info['id'])
+    
+    # Delete physical files if they exist
+    db_path = config.project_dir / ".cinchdb" / "databases" / name
+    if db_path.exists():
+        shutil.rmtree(db_path)
 
     # If this was the active database, switch to main
     if config_data.active_database == name:
@@ -168,31 +154,40 @@ def info(
     config, config_data = get_config_with_data()
     db_name = name or config_data.active_database
 
-    db_path = config.project_dir / ".cinchdb" / "databases" / db_name
-    if not db_path.exists():
-        console.print(f"[red]❌ Database '{db_name}' does not exist[/red]")
-        raise typer.Exit(1)
-
-    # Count branches
-    branches_path = db_path / "branches"
-    branch_count = len(list(branches_path.iterdir())) if branches_path.exists() else 0
+    # Check if database exists in metadata
+    from cinchdb.infrastructure.metadata_db import MetadataDB
+    
+    with MetadataDB(config.project_dir) as metadata_db:
+        db_info = metadata_db.get_database(db_name)
+        if not db_info:
+            console.print(f"[red]❌ Database '{db_name}' does not exist[/red]")
+            raise typer.Exit(1)
+        
+        # Get branch info from metadata
+        branches = metadata_db.list_branches(db_info['id'])
+        branch_count = len(branches)
 
     # Get active branch
     active_branch = config_data.active_branch
-
+    
     # Display info
     console.print(f"\n[bold]Database: {db_name}[/bold]")
-    console.print(f"Location: {db_path}")
+    console.print(f"Status: {'Materialized' if db_info.get('materialized') else 'Lazy (not materialized)'}")
     console.print(f"Branches: {branch_count}")
     console.print(f"Active Branch: {active_branch}")
     console.print(f"Protected: {'Yes' if db_name == 'main' else 'No'}")
+    
+    # Show description if present
+    if db_info.get('description'):
+        console.print(f"Description: {db_info['description']}")
 
     # List branches
     if branch_count > 0:
         console.print("\n[bold]Branches:[/bold]")
-        for branch_dir in sorted(branches_path.iterdir()):
-            if branch_dir.is_dir():
-                branch_name = branch_dir.name
+        with MetadataDB(config.project_dir) as metadata_db:
+            branches = metadata_db.list_branches(db_info['id'])
+            for branch in sorted(branches, key=lambda x: x['name']):
+                branch_name = branch['name']
                 is_active = " (active)" if branch_name == active_branch else ""
                 console.print(f"  - {branch_name}{is_active}")
 
@@ -208,11 +203,14 @@ def switch(
     name = validate_required_arg(name, "name", ctx)
     config, config_data = get_config_with_data()
 
-    # Check if database exists
-    db_path = config.project_dir / ".cinchdb" / "databases" / name
-    if not db_path.exists():
-        console.print(f"[red]❌ Database '{name}' does not exist[/red]")
-        raise typer.Exit(1)
+    # Check if database exists in metadata
+    from cinchdb.infrastructure.metadata_db import MetadataDB
+    
+    with MetadataDB(config.project_dir) as metadata_db:
+        db_info = metadata_db.get_database(name)
+        if not db_info:
+            console.print(f"[red]❌ Database '{name}' does not exist[/red]")
+            raise typer.Exit(1)
 
     # Switch
     set_active_database(config, name)

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/cli/commands/table.py

@@ -277,14 +277,14 @@ def info(
         col_table.add_column("Name", style="cyan")
         col_table.add_column("Type", style="green")
         col_table.add_column("Nullable", style="yellow")
-        col_table.add_column("Primary Key", style="red")
+        col_table.add_column("Unique", style="red")
         col_table.add_column("Default", style="blue")
 
         for col in table.columns:
             nullable = "Yes" if col.nullable else "No"
-            pk = "Yes" if col.primary_key else "No"
+            unique = "Yes" if col.unique else "No"
             default = col.default or "-"
-            col_table.add_row(col.name, col.type, nullable, pk, default)
+            col_table.add_row(col.name, col.type, nullable, unique, default)
 
         console.print(col_table)
 

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/cli/main.py

@@ -13,7 +13,6 @@ from cinchdb.cli.commands import (
     column,
     view,
     codegen,
-    remote,
     index,
 )
 
@@ -45,7 +44,6 @@ app.add_typer(column.app, name="column", help="Column management commands")
 app.add_typer(view.app, name="view", help="View management commands")
 app.add_typer(index.app, name="index", help="Index management commands")
 app.add_typer(codegen.app, name="codegen", help="Code generation commands")
-app.add_typer(remote.app, name="remote", help="Remote instance management")
 
 
 # Add query as direct command instead of subtyper
@@ -59,15 +57,11 @@ def query(
     limit: Optional[int] = typer.Option(
         None, "--limit", "-l", help="Limit number of rows"
     ),
-    local: bool = typer.Option(False, "--local", "-L", help="Force local connection"),
-    remote: Optional[str] = typer.Option(
-        None, "--remote", "-r", help="Use specific remote alias"
-    ),
 ):
     """Execute a SQL query."""
     from cinchdb.cli.commands.query import execute_query
 
-    execute_query(sql, tenant, format, limit, force_local=local, remote_alias=remote)
+    execute_query(sql, tenant, format, limit)
 
 
 @app.command()

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/cli/utils.py

@@ -13,6 +13,29 @@ from cinchdb.core.database import CinchDB
 console = Console()
 
 
+def handle_cli_error(func):
+    """Decorator to handle CLI errors with consistent formatting.
+    
+    Args:
+        func: The function to wrap
+    """
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as error:
+            error_msg = str(error)
+            if "not found" in error_msg.lower():
+                console.print(f"[yellow]⚠️  {error_msg}[/yellow]")
+            elif "already exists" in error_msg.lower():
+                console.print(f"[yellow]⚠️  {error_msg}[/yellow]")
+            elif "invalid" in error_msg.lower():
+                console.print(f"[red]❌ {error_msg}[/red]")
+            else:
+                console.print(f"[red]❌ Error: {error_msg}[/red]")
+            raise typer.Exit(1)
+    return wrapper
+
+
 def get_config_with_data():
     """Get config and load data from current directory.
 

{cinchdb-0.1.10 → cinchdb-0.1.11}/src/cinchdb/core/database.py

@@ -86,6 +86,9 @@ class CinchDB:
             self.api_url = None
             self.api_key = None
             self.is_local = True
+            
+            # Auto-materialize lazy database if needed
+            self._materialize_database_if_lazy()
         elif api_url is not None and api_key is not None:
             # Remote connection
             self.project_dir = None
@@ -111,6 +114,23 @@ class CinchDB:
         self._merge_manager: Optional["MergeManager"] = None
         self._index_manager: Optional["IndexManager"] = None
 
+    def _materialize_database_if_lazy(self) -> None:
+        """Auto-materialize a lazy database if accessing it."""
+        if not self.is_local:
+            return
+            
+        # Check if this is a lazy database using metadata DB
+        from cinchdb.infrastructure.metadata_db import MetadataDB
+        
+        with MetadataDB(self.project_dir) as metadata_db:
+            db_info = metadata_db.get_database(self.database)
+        
+        if db_info and not db_info['materialized']:
+            # Database exists in metadata but not materialized
+            from cinchdb.core.initializer import ProjectInitializer
+            initializer = ProjectInitializer(self.project_dir)
+            initializer.materialize_database(self.database)
+
     @property
     def session(self):
         """Get or create HTTP session for remote connections."""
@@ -561,6 +581,122 @@ class CinchDB:
                 changes.append(Change(**data))
             return changes
 
+    def optimize_tenant(self, tenant_name: str = None, force: bool = False) -> bool:
+        """Optimize a tenant's storage with VACUUM and page size adjustment.
+
+        Args:
+            tenant_name: Name of the tenant to optimize (default: current tenant)
+            force: If True, always perform optimization
+
+        Returns:
+            True if optimization was performed, False otherwise
+            
+        Examples:
+            # Optimize current tenant
+            db.optimize_tenant()
+            
+            # Optimize specific tenant
+            db.optimize_tenant("store_west")
+            
+            # Force optimization even if not needed
+            db.optimize_tenant(force=True)
+        """
+        if self.is_local:
+            tenant_to_optimize = tenant_name or self.tenant
+            return self.tenants.optimize_tenant_storage(tenant_to_optimize, force=force)
+        else:
+            raise NotImplementedError("Remote tenant optimization not implemented")
+
+    def get_tenant_size(self, tenant_name: str = None) -> dict:
+        """Get storage size information for a tenant.
+        
+        Args:
+            tenant_name: Name of tenant (default: current tenant)
+            
+        Returns:
+            Dictionary with size information:
+            - name: Tenant name
+            - materialized: Whether tenant is materialized
+            - size_bytes: Size in bytes (0 if lazy)
+            - size_kb: Size in KB
+            - size_mb: Size in MB
+            - page_size: SQLite page size (if materialized)
+            - page_count: Number of pages (if materialized)
+            
+        Examples:
+            # Get size of current tenant
+            size = db.get_tenant_size()
+            print(f"Current tenant uses {size['size_mb']:.2f} MB")
+            
+            # Get size of specific tenant
+            size = db.get_tenant_size("store_west")
+            if size['materialized']:
+                print(f"Page size: {size['page_size']} bytes")
+        """
+        if self.is_local:
+            tenant_to_check = tenant_name or self.tenant
+            return self.tenants.get_tenant_size(tenant_to_check)
+        else:
+            raise NotImplementedError("Remote tenant size query not implemented")
+    
+    def get_storage_info(self) -> dict:
+        """Get storage size information for all tenants in current branch.
+        
+        Returns:
+            Dictionary with:
+            - tenants: List of individual tenant size info (sorted by size)
+            - total_size_bytes: Total size of all materialized tenants
+            - total_size_mb: Total size in MB
+            - lazy_count: Number of lazy tenants
+            - materialized_count: Number of materialized tenants
+            
+        Examples:
+            # Get storage overview
+            info = db.get_storage_info()
+            print(f"Total storage: {info['total_size_mb']:.2f} MB")
+            print(f"Materialized tenants: {info['materialized_count']}")
+            print(f"Lazy tenants: {info['lazy_count']}")
+            
+            # List largest tenants
+            for tenant in info['tenants'][:5]:  # Top 5
+                if tenant['materialized']:
+                    print(f"{tenant['name']}: {tenant['size_mb']:.2f} MB")
+        """
+        if self.is_local:
+            return self.tenants.get_all_tenant_sizes()
+        else:
+            raise NotImplementedError("Remote storage info not implemented")
+    
+    def optimize_all_tenants(self, force: bool = False) -> dict:
+        """Optimize storage for all tenants in current branch.
+
+        This is designed to be called periodically to:
+        - Reclaim unused space with VACUUM
+        - Adjust page sizes as databases grow
+        - Keep small databases compact
+
+        Args:
+            force: If True, optimize all tenants regardless of size
+
+        Returns:
+            Dictionary with optimization results:
+            - optimized: List of tenant names that were optimized
+            - skipped: List of tenant names that were skipped
+            - errors: List of tuples (tenant_name, error_message)
+            
+        Examples:
+            # Run periodic optimization
+            results = db.optimize_all_tenants()
+            print(f"Optimized {len(results['optimized'])} tenants")
+            
+            # Force optimization of all tenants
+            results = db.optimize_all_tenants(force=True)
+        """
+        if self.is_local:
+            return self.tenants.optimize_all_tenants(force=force)
+        else:
+            raise NotImplementedError("Remote tenant optimization not implemented")
+
     def close(self):
         """Close any open connections."""
         if not self.is_local and self._session:
@@ -632,17 +768,6 @@ def connect_api(
 
     Returns:
         CinchDB connection instance for remote API
-
-    Examples:
-        # Connect to remote API
-        db = connect_api("https://api.example.com", "your-api-key", "mydb")
-
-        # Connect to specific branch
-        db = connect_api("https://api.example.com", "your-api-key", "mydb", "dev")
-
-        # Use with context manager
-        with connect_api("https://api.example.com", "key", "mydb") as db:
-            results = db.query("SELECT * FROM users")
     """
     return CinchDB(
         database=database,
@@ -651,3 +776,5 @@ def connect_api(
         api_url=api_url,
         api_key=api_key,
     )
+
+