cinchdb 0.1.0__py3-none-any.whl

cinchdb/cli/commands/view.py

@@ -0,0 +1,189 @@
+"""View management commands for CinchDB CLI."""
+
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.table import Table as RichTable
+
+from cinchdb.managers.view import ViewModel
+from cinchdb.managers.change_applier import ChangeApplier
+from cinchdb.cli.utils import get_config_with_data, validate_required_arg
+
+app = typer.Typer(help="View 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_views():
+    """List all views in the current branch."""
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    view_mgr = ViewModel(config.project_dir, db_name, branch_name, "main")
+    views = view_mgr.list_views()
+
+    if not views:
+        console.print("[yellow]No views found[/yellow]")
+        return
+
+    # Create a table
+    table = RichTable(
+        title=f"Views db={db_name} branch={branch_name}", title_justify="left"
+    )
+    table.add_column("Name", style="cyan")
+    table.add_column("SQL Length", style="green")
+    table.add_column("Created", style="yellow")
+
+    for view in views:
+        sql_length = len(view.sql_statement) if view.sql_statement else 0
+        table.add_row(view.name, str(sql_length), "-")
+
+    console.print(table)
+
+
+@app.command()
+def create(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the view"),
+    sql: Optional[str] = typer.Argument(None, help="SQL query for the view"),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Create a new view.
+
+    Examples:
+        cinch view create active_users "SELECT * FROM users WHERE is_active = 1"
+        cinch view create user_stats "SELECT age, COUNT(*) as count FROM users GROUP BY age"
+    """
+    name = validate_required_arg(name, "name", ctx)
+    sql = validate_required_arg(sql, "sql", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        view_mgr = ViewModel(config.project_dir, db_name, branch_name, "main")
+        view_mgr.create_view(name, sql)
+        console.print(f"[green]✅ Created view '{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 update(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the view to update"),
+    sql: Optional[str] = typer.Argument(None, help="New SQL query for the view"),
+    apply: bool = typer.Option(
+        True, "--apply/--no-apply", help="Apply changes to all tenants"
+    ),
+):
+    """Update an existing view's SQL."""
+    name = validate_required_arg(name, "name", ctx)
+    sql = validate_required_arg(sql, "sql", ctx)
+    config, config_data = get_config_with_data()
+    db_name = config_data.active_database
+    branch_name = config_data.active_branch
+
+    try:
+        view_mgr = ViewModel(config.project_dir, db_name, branch_name, "main")
+        view_mgr.update_view(name, sql)
+        console.print(f"[green]✅ Updated view '{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 delete(
+    ctx: typer.Context,
+    name: Optional[str] = typer.Argument(None, help="Name of the view 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 view."""
+    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 view '{name}'?")
+        if not confirm:
+            console.print("[yellow]Cancelled[/yellow]")
+            raise typer.Exit(0)
+
+    try:
+        view_mgr = ViewModel(config.project_dir, db_name, branch_name, "main")
+        view_mgr.delete_view(name)
+        console.print(f"[green]✅ Deleted view '{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 info(
+    ctx: typer.Context, name: Optional[str] = typer.Argument(None, help="View name")
+):
+    """Show detailed information about a view."""
+    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:
+        view_mgr = ViewModel(config.project_dir, db_name, branch_name, "main")
+        view = view_mgr.get_view(name)
+
+        # Display info
+        console.print(f"\n[bold]View: {view.name}[/bold]")
+        console.print(f"Database: {db_name}")
+        console.print(f"Branch: {branch_name}")
+        console.print("Tenant: main")
+        console.print("\n[bold]SQL:[/bold]")
+        console.print(view.sql_statement)
+
+    except ValueError as e:
+        console.print(f"[red]❌ {e}[/red]")
+        raise typer.Exit(1)

cinchdb/cli/handlers/__init__.py

@@ -0,0 +1,5 @@
+"""CLI handlers for unified local/remote operations."""
+
+from .codegen_handler import CodegenHandler
+
+__all__ = ["CodegenHandler"]

cinchdb/cli/handlers/codegen_handler.py

@@ -0,0 +1,189 @@
+"""Unified codegen handler for local and remote operations."""
+
+import requests
+from pathlib import Path
+from typing import Dict, Any, Optional, List
+from rich.console import Console
+
+from ...managers import CodegenManager
+
+console = Console()
+
+
+class CodegenHandler:
+    """Handles both local and remote code generation operations."""
+
+    def __init__(
+        self,
+        config_data: Dict[str, Any],
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        force_local: bool = False,
+    ):
+        """Initialize the handler.
+
+        Args:
+            config_data: Configuration data from config.toml
+            api_url: Optional API URL for remote generation
+            api_key: Optional API key for remote generation
+            force_local: Force local generation even if API configured
+        """
+        self.config_data = config_data
+        self.force_local = force_local
+
+        # Determine if we should use remote API
+        self.api_url = api_url or config_data.get("api", {}).get("url")
+        self.api_key = api_key or config_data.get("api", {}).get("key")
+        self.is_remote = bool(self.api_url and self.api_key and not force_local)
+
+    def generate_models(
+        self,
+        language: str,
+        output_dir: Path,
+        database: str,
+        branch: str,
+        tenant: str = "main",
+        include_tables: bool = True,
+        include_views: bool = True,
+        project_root: Optional[Path] = None,
+    ) -> Dict[str, Any]:
+        """Generate models using local or remote approach.
+
+        Returns:
+            Dict with generation results in consistent format
+        """
+        if self.is_remote:
+            return self._generate_remote(
+                language=language,
+                output_dir=output_dir,
+                database=database,
+                branch=branch,
+                tenant=tenant,
+                include_tables=include_tables,
+                include_views=include_views,
+            )
+        else:
+            return self._generate_local(
+                language=language,
+                output_dir=output_dir,
+                database=database,
+                branch=branch,
+                tenant=tenant,
+                include_tables=include_tables,
+                include_views=include_views,
+                project_root=project_root,
+            )
+
+    def _generate_local(
+        self,
+        language: str,
+        output_dir: Path,
+        database: str,
+        branch: str,
+        tenant: str = "main",
+        include_tables: bool = True,
+        include_views: bool = True,
+        project_root: Optional[Path] = None,
+    ) -> Dict[str, Any]:
+        """Generate models locally using CodegenManager."""
+        if not project_root:
+            raise ValueError("project_root is required for local generation")
+
+        manager = CodegenManager(
+            project_root=project_root, database=database, branch=branch, tenant=tenant
+        )
+
+        return manager.generate_models(
+            language=language,
+            output_dir=output_dir,
+            include_tables=include_tables,
+            include_views=include_views,
+        )
+
+    def _generate_remote(
+        self,
+        language: str,
+        output_dir: Path,
+        database: str,
+        branch: str,
+        tenant: str = "main",
+        include_tables: bool = True,
+        include_views: bool = True,
+    ) -> Dict[str, Any]:
+        """Generate models remotely using API."""
+        try:
+            # Prepare request payload
+            payload = {
+                "language": language,
+                "include_tables": include_tables,
+                "include_views": include_views,
+            }
+
+            # Prepare query parameters - database and branch required, tenant not needed for codegen
+            params = {"database": database, "branch": branch}
+
+            # Make API request to generate files endpoint (returns JSON content)
+            response = requests.post(
+                f"{self.api_url}/api/v1/codegen/generate/files",
+                json=payload,
+                params=params,
+                headers={"Authorization": f"Bearer {self.api_key}"},
+            )
+            response.raise_for_status()
+
+            # Parse response
+            result = response.json()
+            files_data = result["files"]
+
+            # Create output directory
+            output_dir.mkdir(parents=True, exist_ok=True)
+
+            # Write files to local filesystem
+            files_generated = []
+            for file_info in files_data:
+                file_path = output_dir / file_info["filename"]
+                file_path.write_text(file_info["content"])
+                files_generated.append(file_info["filename"])
+
+            # Return consistent format matching local generation
+            return {
+                "files_generated": files_generated,
+                "tables_processed": result.get("tables_processed", []),
+                "views_processed": result.get("views_processed", []),
+                "output_dir": str(output_dir),
+                "language": language,
+                "remote": True,
+            }
+
+        except requests.RequestException as e:
+            raise RuntimeError(f"Remote codegen failed: {e}")
+        except KeyError as e:
+            raise RuntimeError(f"Invalid API response format: missing {e}")
+
+    def get_supported_languages(self, project_root: Optional[Path] = None) -> List[str]:
+        """Get supported languages from local or remote source."""
+        if self.is_remote:
+            try:
+                response = requests.get(
+                    f"{self.api_url}/api/v1/codegen/languages",
+                    headers={"Authorization": f"Bearer {self.api_key}"},
+                )
+                response.raise_for_status()
+                result = response.json()
+                return [lang["name"] for lang in result["languages"]]
+            except requests.RequestException:
+                # Fall back to local if remote fails
+                pass
+
+        # Use local manager for supported languages
+        if not project_root:
+            # Return hardcoded list if no project available
+            return ["python"]
+
+        manager = CodegenManager(
+            project_root=project_root,
+            database=self.config_data.get("active_database", "main"),
+            branch=self.config_data.get("active_branch", "main"),
+            tenant="main",
+        )
+        return manager.get_supported_languages()

cinchdb/cli/main.py

@@ -0,0 +1,137 @@
+"""Main CLI entry point for CinchDB."""
+
+import typer
+from typing import Optional
+from pathlib import Path
+
+# Import command groups
+from cinchdb.cli.commands import (
+    database,
+    branch,
+    tenant,
+    table,
+    column,
+    view,
+    codegen,
+    remote,
+)
+
+app = typer.Typer(
+    name="cinch",
+    help="CinchDB - A Git-like SQLite database management system",
+    add_completion=False,
+    invoke_without_command=True,
+)
+
+
+@app.callback()
+def main(ctx: typer.Context):
+    """
+    CinchDB - A Git-like SQLite database management system
+    """
+    if ctx.invoked_subcommand is None:
+        # No subcommand was invoked, show help
+        print(ctx.get_help())
+        raise typer.Exit(0)
+
+
+# Add command groups
+app.add_typer(database.app, name="db", help="Database management commands")
+app.add_typer(branch.app, name="branch", help="Branch management commands")
+app.add_typer(tenant.app, name="tenant", help="Tenant management commands")
+app.add_typer(table.app, name="table", help="Table management commands")
+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(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
+@app.command()
+def query(
+    sql: str = typer.Argument(..., help="SQL query to execute"),
+    tenant: Optional[str] = typer.Option("main", "--tenant", "-t", help="Tenant name"),
+    format: Optional[str] = typer.Option(
+        "table", "--format", "-f", help="Output format (table, json, csv)"
+    ),
+    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)
+
+
+@app.command()
+def init(
+    path: Optional[Path] = typer.Argument(
+        None, help="Directory to initialize project in (default: current directory)"
+    ),
+):
+    """Initialize a new CinchDB project."""
+    from cinchdb.config import Config
+
+    project_path = path or Path.cwd()
+
+    try:
+        config = Config(project_path)
+        config.init_project()
+        typer.secho(
+            f"✅ Initialized CinchDB project in {project_path}", fg=typer.colors.GREEN
+        )
+    except FileExistsError:
+        typer.secho(f"❌ Project already exists in {project_path}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+@app.command()
+def version():
+    """Show CinchDB version."""
+    from cinchdb import __version__
+
+    typer.echo(f"CinchDB version {__version__}")
+
+
+@app.command()
+def status():
+    """Show CinchDB status including configuration and environment variables."""
+    from cinchdb.cli.utils import get_config_with_data, show_env_config
+    from rich.console import Console
+    from rich.table import Table as RichTable
+    
+    console = Console()
+    
+    # Show project configuration
+    try:
+        config, config_data = get_config_with_data()
+        
+        console.print("\n[bold]CinchDB Status[/bold]")
+        console.print(f"Project: {config.project_dir}")
+        console.print(f"Active Database: {config_data.active_database}")
+        console.print(f"Active Branch: {config_data.active_branch}")
+        
+        if config_data.active_remote:
+            console.print(f"Active Remote: {config_data.active_remote}")
+            if config_data.active_remote in config_data.remotes:
+                remote = config_data.remotes[config_data.active_remote]
+                console.print(f"  URL: {remote.url}")
+                console.print(f"  Key: ***{remote.key[-8:] if len(remote.key) > 8 else '*' * len(remote.key)}")
+        else:
+            console.print("Active Remote: [dim]None (local mode)[/dim]")
+        
+        # Show environment variables
+        show_env_config()
+        
+    except Exception as e:
+        console.print(f"[red]❌ Error: {e}[/red]")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

cinchdb/cli/utils.py

@@ -0,0 +1,182 @@
+"""Utility functions for CLI commands."""
+
+import os
+import typer
+from pathlib import Path
+from typing import Optional
+from rich.console import Console
+
+from cinchdb.config import Config
+from cinchdb.core.path_utils import get_project_root
+from cinchdb.core.database import CinchDB
+
+console = Console()
+
+
+def get_config_with_data():
+    """Get config and load data from current directory.
+
+    Returns:
+        tuple: (config, config_data)
+    """
+    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)
+
+    config = Config(project_root)
+    try:
+        config_data = config.load()
+    except FileNotFoundError:
+        console.print("[red]❌ Config file not found. Run 'cinch init' first.[/red]")
+        raise typer.Exit(1)
+
+    return config, config_data
+
+
+def get_config_dict():
+    """Get config data as dictionary, including API configuration if present.
+
+    Returns:
+        dict: Configuration data
+    """
+    config, config_data = get_config_with_data()
+
+    # Convert config_data to dict-like structure for handlers
+    config_dict = {
+        "active_database": getattr(config_data, "active_database", None),
+        "active_branch": getattr(config_data, "active_branch", "main"),
+        "project_root": config.project_dir,
+    }
+
+    # Add API configuration if present in raw config
+    if hasattr(config_data, "api") and config_data.api:
+        config_dict["api"] = {
+            "url": getattr(config_data.api, "url", None),
+            "key": getattr(config_data.api, "key", None),
+        }
+
+    return config_dict
+
+
+def set_active_database(config: Config, database: str):
+    """Set the active database in config."""
+    config_data = config.load()
+    config_data.active_database = database
+    config.save(config_data)
+
+
+def set_active_branch(config: Config, branch: str):
+    """Set the active branch in config."""
+    config_data = config.load()
+    config_data.active_branch = branch
+    config.save(config_data)
+
+
+def validate_required_arg(
+    value: Optional[str], arg_name: str, ctx: typer.Context
+) -> str:
+    """Validate a required argument and show help if missing.
+
+    Args:
+        value: The argument value
+        arg_name: Name of the argument (for error message)
+        ctx: Typer context
+
+    Returns:
+        The validated value
+
+    Raises:
+        typer.Exit: If value is None
+    """
+    if value is None:
+        console.print(ctx.get_help())
+        console.print(f"\n[red]❌ Error: Missing argument '{arg_name.upper()}'.[/red]")
+        raise typer.Exit(1)
+    return value
+
+
+def get_cinchdb_instance(
+    database: Optional[str] = None,
+    branch: Optional[str] = None,
+    tenant: str = "main",
+    force_local: bool = False,
+    remote_alias: Optional[str] = None,
+) -> CinchDB:
+    """Get a CinchDB instance configured for local or remote access.
+
+    Args:
+        database: Database name (uses active database if None)
+        branch: Branch name (uses active branch if None)
+        tenant: Tenant name (default: main)
+        force_local: Force local connection even if remote is configured
+        remote_alias: Use specific remote alias (overrides active remote)
+
+    Returns:
+        CinchDB instance
+
+    Raises:
+        typer.Exit: If configuration is invalid
+    """
+    config, config_data = get_config_with_data()
+    
+    # Use provided or active database/branch
+    database = database or config_data.active_database
+    branch = branch or config_data.active_branch
+    
+    # Determine if we should use remote connection
+    use_remote = False
+    remote_config = None
+    
+    if not force_local:
+        if remote_alias:
+            # Use specific remote alias
+            if remote_alias not in config_data.remotes:
+                console.print(f"[red]❌ Remote '{remote_alias}' not found[/red]")
+                raise typer.Exit(1)
+            remote_config = config_data.remotes[remote_alias]
+            use_remote = True
+        elif config_data.active_remote:
+            # Use active remote
+            if config_data.active_remote not in config_data.remotes:
+                console.print(f"[red]❌ Active remote '{config_data.active_remote}' not found[/red]")
+                raise typer.Exit(1)
+            remote_config = config_data.remotes[config_data.active_remote]
+            use_remote = True
+    
+    if use_remote and remote_config:
+        # Create remote connection
+        return CinchDB(
+            database=database,
+            branch=branch,
+            tenant=tenant,
+            api_url=remote_config.url,
+            api_key=remote_config.key,
+        )
+    else:
+        # Create local connection
+        return CinchDB(
+            database=database,
+            branch=branch,
+            tenant=tenant,
+            project_dir=config.project_dir,
+        )
+
+
+def show_env_config():
+    """Display active environment variable configuration."""
+    env_vars = {
+        "CINCHDB_PROJECT_DIR": os.environ.get("CINCHDB_PROJECT_DIR"),
+        "CINCHDB_DATABASE": os.environ.get("CINCHDB_DATABASE"),
+        "CINCHDB_BRANCH": os.environ.get("CINCHDB_BRANCH"),
+        "CINCHDB_REMOTE_URL": os.environ.get("CINCHDB_REMOTE_URL"),
+        "CINCHDB_API_KEY": "***" if "CINCHDB_API_KEY" in os.environ else None,
+    }
+    
+    active = {k: v for k, v in env_vars.items() if v}
+    if active:
+        console.print("\n[yellow]Active environment variables:[/yellow]")
+        for key, value in active.items():
+            console.print(f"  {key}={value}")
+    else:
+        console.print("\n[dim]No CinchDB environment variables set[/dim]")