cinchdb 0.1.0__py3-none-any.whl

cinchdb/cli/commands/remote.py

@@ -0,0 +1,144 @@
+"""Remote configuration management commands."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from typing import Optional
+
+from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+from cinchdb.config import RemoteConfig
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("add")
+def add_remote(
+    ctx: typer.Context,
+    alias: Optional[str] = typer.Argument(None, help="Alias for the remote"),
+    url: str = typer.Option(None, "--url", "-u", help="Remote API URL"),
+    key: str = typer.Option(None, "--key", "-k", help="API key"),
+):
+    """Add a remote CinchDB instance configuration."""
+    alias = validate_required_arg(alias, "alias", ctx)
+    
+    if not url:
+        console.print("[red]❌ Error: --url is required[/red]")
+        raise typer.Exit(1)
+    
+    if not key:
+        console.print("[red]❌ Error: --key is required[/red]")
+        raise typer.Exit(1)
+    
+    config, config_data = get_config_with_data()
+    
+    # Check if alias already exists
+    if alias in config_data.remotes:
+        console.print(f"[yellow]⚠️  Remote '{alias}' already exists. Updating...[/yellow]")
+    
+    # Add or update the remote
+    config_data.remotes[alias] = RemoteConfig(url=url.rstrip("/"), key=key)
+    config.save(config_data)
+    
+    console.print(f"[green]✓ Remote '{alias}' configured successfully[/green]")
+
+
+@app.command("list")
+def list_remotes():
+    """List all configured remote instances."""
+    config, config_data = get_config_with_data()
+    
+    if not config_data.remotes:
+        console.print("[yellow]No remotes configured[/yellow]")
+        return
+    
+    table = Table(title="Configured Remotes")
+    table.add_column("Alias", style="cyan")
+    table.add_column("URL", style="green")
+    table.add_column("Active", style="yellow")
+    
+    for alias, remote in config_data.remotes.items():
+        is_active = "✓" if alias == config_data.active_remote else ""
+        table.add_row(alias, remote.url, is_active)
+    
+    console.print(table)
+
+
+@app.command("remove")
+def remove_remote(
+    ctx: typer.Context,
+    alias: Optional[str] = typer.Argument(None, help="Alias of the remote to remove"),
+):
+    """Remove a remote configuration."""
+    alias = validate_required_arg(alias, "alias", ctx)
+    
+    config, config_data = get_config_with_data()
+    
+    if alias not in config_data.remotes:
+        console.print(f"[red]❌ Remote '{alias}' not found[/red]")
+        raise typer.Exit(1)
+    
+    # Remove the remote
+    del config_data.remotes[alias]
+    
+    # If this was the active remote, clear it
+    if config_data.active_remote == alias:
+        config_data.active_remote = None
+    
+    config.save(config_data)
+    console.print(f"[green]✓ Remote '{alias}' removed[/green]")
+
+
+@app.command("use")
+def use_remote(
+    ctx: typer.Context,
+    alias: Optional[str] = typer.Argument(None, help="Alias of the remote to use"),
+):
+    """Set the active remote instance."""
+    alias = validate_required_arg(alias, "alias", ctx)
+    
+    config, config_data = get_config_with_data()
+    
+    if alias not in config_data.remotes:
+        console.print(f"[red]❌ Remote '{alias}' not found[/red]")
+        raise typer.Exit(1)
+    
+    config_data.active_remote = alias
+    config.save(config_data)
+    
+    console.print(f"[green]✓ Now using remote '{alias}'[/green]")
+    console.print(f"[dim]URL: {config_data.remotes[alias].url}[/dim]")
+
+
+@app.command("clear")
+def clear_remote():
+    """Clear the active remote (switch back to local mode)."""
+    config, config_data = get_config_with_data()
+    
+    if not config_data.active_remote:
+        console.print("[yellow]No active remote set[/yellow]")
+        return
+    
+    config_data.active_remote = None
+    config.save(config_data)
+    
+    console.print("[green]✓ Cleared active remote. Now using local mode.[/green]")
+
+
+@app.command("show")
+def show_remote():
+    """Show the currently active remote."""
+    config, config_data = get_config_with_data()
+    
+    if not config_data.active_remote:
+        console.print("[yellow]No active remote. Using local mode.[/yellow]")
+        return
+    
+    alias = config_data.active_remote
+    if alias not in config_data.remotes:
+        console.print(f"[red]❌ Active remote '{alias}' not found in configuration[/red]")
+        return
+    
+    remote = config_data.remotes[alias]
+    console.print(f"[green]Active remote:[/green] {alias}")
+    console.print(f"[dim]URL: {remote.url}[/dim]")

cinchdb/cli/commands/table.py

@@ -0,0 +1,289 @@
+"""Table management commands for CinchDB CLI."""
+
+import typer
+from typing import List, Optional
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.managers.table import TableManager
+from cinchdb.managers.change_applier import ChangeApplier
+from cinchdb.models import Column, ForeignKeyRef
+from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+
+app = typer.Typer(help="Table management commands", invoke_without_command=True)
+console = Console()
+
+
+@app.callback()
+def callback(ctx: typer.Context):
+    """Show help when no subcommand is provided."""
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+        raise typer.Exit(0)
+
+
+@app.command(name="list")
+def list_tables():
+    """List all tables in the current branch."""
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    table_mgr = TableManager(config.project_dir, db_name, branch_name, "main")
+    tables = table_mgr.list_tables()
+
+    if not tables:
+        console.print("[yellow]No tables found[/yellow]")
+        return
+
+    # Create a table
+    table = RichTable(
+        title=f"Tables db={db_name} branch={branch_name}", title_justify="left"
+    )
+    table.add_column("Name", style="cyan")
+    table.add_column("Columns", style="green")
+    table.add_column("Created", style="yellow")
+
+    for tbl in tables:
+        # Count user-defined columns (exclude automatic ones)
+        user_columns = len(
+            [c for c in tbl.columns if c.name not in ["id", "created_at", "updated_at"]]
+        )
+        tbl.columns[0].name  # Placeholder - we don't track table creation time
+        table.add_row(tbl.name, str(user_columns), "-")
+
+    console.print(table)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the table"),
+    columns: Optional[List[str]] = typer.Argument(
+        None, help="Column definitions (format: name:type[:nullable][:fk=table[.column][:action]])"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Create a new table.
+
+    Column format: name:type[:nullable][:fk=table[.column][:action]]
+    Types: TEXT, INTEGER, REAL, BLOB, NUMERIC
+    FK Actions: CASCADE, SET NULL, RESTRICT, NO ACTION
+
+    Examples:
+        cinch table create users name:TEXT email:TEXT:nullable age:INTEGER:nullable
+        cinch table create posts title:TEXT content:TEXT author_id:TEXT:fk=users
+        cinch table create comments content:TEXT post_id:TEXT:fk=posts.id:cascade
+    """
+    name = validate_required_arg(name, "name", ctx)
+    if not columns:
+        console.print(ctx.get_help())
+        console.print("\n[red]❌ Error: Missing argument 'COLUMNS'.[/red]")
+        raise typer.Exit(1)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    # Parse columns
+    parsed_columns = []
+    for col_def in columns:
+        parts = col_def.split(":")
+        if len(parts) < 2:
+            console.print(f"[red]❌ Invalid column definition: '{col_def}'[/red]")
+            console.print("[yellow]Format: name:type[:nullable][:fk=table[.column][:action]][/yellow]")
+            raise typer.Exit(1)
+
+        col_name = parts[0]
+        col_type = parts[1].upper()
+        nullable = False
+        foreign_key = None
+        
+        # Parse additional parts
+        for i in range(2, len(parts)):
+            part = parts[i]
+            if part.lower() == "nullable":
+                nullable = True
+            elif part.startswith("fk="):
+                # Parse foreign key definition
+                fk_def = part[3:]  # Remove "fk=" prefix
+                
+                # Handle actions with spaces (e.g., "set null", "no action")
+                # Check for known actions at the end
+                fk_action = "RESTRICT"  # Default
+                for action in ["cascade", "set null", "restrict", "no action"]:
+                    if fk_def.lower().endswith("." + action):
+                        fk_action = action.upper()
+                        # Remove the action part from fk_def
+                        fk_def = fk_def[:-len("." + action)]
+                        break
+                
+                # Now split the remaining parts
+                fk_parts = fk_def.split(".")
+                
+                if len(fk_parts) == 1:
+                    # Just table name, column defaults to "id"
+                    fk_table = fk_parts[0]
+                    fk_column = "id"
+                elif len(fk_parts) == 2:
+                    # table.column format
+                    fk_table = fk_parts[0]
+                    fk_column = fk_parts[1]
+                else:
+                    console.print(f"[red]❌ Invalid foreign key format: '{fk_def}'[/red]")
+                    console.print("[yellow]Format: fk=table[.column][:action][/yellow]")
+                    raise typer.Exit(1)
+                
+                foreign_key = ForeignKeyRef(
+                    table=fk_table,
+                    column=fk_column,
+                    on_delete=fk_action,
+                    on_update="RESTRICT"  # Default to RESTRICT for updates
+                )
+
+        if col_type not in ["TEXT", "INTEGER", "REAL", "BLOB", "NUMERIC"]:
+            console.print(f"[red]❌ Invalid type: '{col_type}'[/red]")
+            console.print(
+                "[yellow]Valid types: TEXT, INTEGER, REAL, BLOB, NUMERIC[/yellow]"
+            )
+            raise typer.Exit(1)
+
+        parsed_columns.append(Column(
+            name=col_name, 
+            type=col_type, 
+            nullable=nullable,
+            foreign_key=foreign_key
+        ))
+
+    try:
+        table_mgr = TableManager(config.project_dir, db_name, branch_name, "main")
+        table_mgr.create_table(name, parsed_columns)
+        console.print(
+            f"[green]✅ Created table '{name}' with {len(parsed_columns)} columns[/green]"
+        )
+
+        # Changes are automatically applied to all tenants by the manager
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the table to delete"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force deletion without confirmation"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Delete a table."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    # Confirmation
+    if not force:
+        confirm = typer.confirm(f"Are you sure you want to delete table '{name}'?")
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    try:
+        table_mgr = TableManager(config.project_dir, db_name, branch_name, "main")
+        table_mgr.delete_table(name)
+        console.print(f"[green]✅ Deleted table '{name}'[/green]")
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def copy(
+    ctx: typer.Context,
+    source: Optional[str] = typer.Argument(None, help="Source table name"),
+    target: Optional[str] = typer.Argument(None, help="Target table name"),
+    data: bool = typer.Option(
+        True, "--data/--no-data", help="Copy data along with structure"
+    ),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Copy a table to a new table."""
+    source = validate_required_arg(source, "source", ctx)
+    target = validate_required_arg(target, "target", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        table_mgr = TableManager(config.project_dir, db_name, branch_name, "main")
+        table_mgr.copy_table(source, target, copy_data=data)
+        console.print(f"[green]✅ Copied table '{source}' to '{target}'[/green]")
+
+        if apply:
+            # Apply to all tenants
+            applier = ChangeApplier(config.project_dir, db_name, branch_name)
+            applied = applier.apply_all_unapplied()
+            if applied > 0:
+                console.print("[green]✅ Applied changes to all tenants[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def info(
+    ctx: typer.Context, name: Optional[str] = typer.Argument(None, help="Table name")
+):
+    """Show detailed information about a table."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        table_mgr = TableManager(config.project_dir, db_name, branch_name, "main")
+        table = table_mgr.get_table(name)
+
+        # Display info
+        console.print(f"\n[bold]Table: {table.name}[/bold]")
+        console.print(f"Database: {db_name}")
+        console.print(f"Branch: {branch_name}")
+        console.print("Tenant: main")
+
+        # Display columns
+        console.print("\n[bold]Columns:[/bold]")
+        col_table = RichTable()
+        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("Default", style="blue")
+
+        for col in table.columns:
+            nullable = "Yes" if col.nullable else "No"
+            pk = "Yes" if col.primary_key else "No"
+            default = col.default or "-"
+            col_table.add_row(col.name, col.type, nullable, pk, default)
+
+        console.print(col_table)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)

cinchdb/cli/commands/tenant.py

@@ -0,0 +1,173 @@
+"""Tenant management commands for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.config import Config
+from cinchdb.core.path_utils import get_project_root
+from cinchdb.managers.tenant import TenantManager
+from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+
+app = typer.Typer(help="Tenant management commands", invoke_without_command=True)
+console = Console()
+
+
+@app.callback()
+def callback(ctx: typer.Context):
+    """Show help when no subcommand is provided."""
+    if ctx.invoked_subcommand is None:
+        console.print(ctx.get_help())
+        raise typer.Exit(0)
+
+
+def get_config() -> Config:
+    """Get config from current directory."""
+    project_root = get_project_root(Path.cwd())
+    if not project_root:
+        console.print("[red]❌ Not in a CinchDB project directory[/red]")
+        raise typer.Exit(1)
+    return Config(project_root)
+
+
+@app.command(name="list")
+def list_tenants():
+    """List all tenants in the current branch."""
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+    tenants = tenant_mgr.list_tenants()
+
+    if not tenants:
+        console.print("[yellow]No tenants found[/yellow]")
+        return
+
+    # Create a table
+    table = RichTable(
+        title=f"Tenants db={db_name} branch={branch_name}", title_justify="left"
+    )
+    table.add_column("Name", style="cyan")
+    table.add_column("Protected", style="yellow")
+
+    for tenant in tenants:
+        is_protected = "✓" if tenant.is_main else ""
+        table.add_row(tenant.name, is_protected)
+
+    console.print(table)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the tenant to create"),
+    description: Optional[str] = typer.Option(
+        None, "--description", "-d", help="Tenant description"
+    ),
+):
+    """Create a new tenant."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+        tenant_mgr.create_tenant(name, description)
+        console.print(f"[green]✅ Created tenant '{name}'[/green]")
+        console.print("[yellow]Note: Tenant has same schema as main tenant[/yellow]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def delete(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the tenant to delete"),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force deletion without confirmation"
+    ),
+):
+    """Delete a tenant."""
+    name = validate_required_arg(name, "name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    if name == "main":
+        console.print("[red]❌ Cannot delete the main tenant[/red]")
+        raise typer.Exit(1)
+
+    # Confirmation
+    if not force:
+        confirm = typer.confirm(f"Are you sure you want to delete tenant '{name}'?")
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    try:
+        tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+        tenant_mgr.delete_tenant(name)
+        console.print(f"[green]✅ Deleted tenant '{name}'[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def copy(
+    ctx: typer.Context,
+    source: Optional[str] = typer.Argument(None, help="Source tenant name"),
+    target: Optional[str] = typer.Argument(None, help="Target tenant name"),
+    description: Optional[str] = typer.Option(
+        None, "--description", "-d", help="Target tenant description"
+    ),
+):
+    """Copy a tenant to a new tenant (including data)."""
+    source = validate_required_arg(source, "source", ctx)
+    target = validate_required_arg(target, "target", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+        tenant_mgr.copy_tenant(source, target, description)
+        console.print(f"[green]✅ Copied tenant '{source}' to '{target}'[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def rename(
+    ctx: typer.Context,
+    old_name: Optional[str] = typer.Argument(None, help="Current tenant name"),
+    new_name: Optional[str] = typer.Argument(None, help="New tenant name"),
+):
+    """Rename a tenant."""
+    old_name = validate_required_arg(old_name, "old_name", ctx)
+    new_name = validate_required_arg(new_name, "new_name", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    if old_name == "main":
+        console.print("[red]❌ Cannot rename the main tenant[/red]")
+        raise typer.Exit(1)
+
+    try:
+        tenant_mgr = TenantManager(config.project_dir, db_name, branch_name)
+        tenant_mgr.rename_tenant(old_name, new_name)
+        console.print(f"[green]✅ Renamed tenant '{old_name}' to '{new_name}'[/green]")
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)