cinchdb 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

{cinchdb-0.1.1.dist-info → cinchdb-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.1
+Version: 0.1.2
 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
@@ -18,14 +18,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
-Requires-Dist: fastapi>=0.115.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: python-multipart>=0.0.12
 Requires-Dist: requests>=2.28.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: toml>=0.10.0
 Requires-Dist: typer>=0.9.0
-Requires-Dist: uvicorn>=0.32.0
 Description-Content-Type: text/markdown
 
 # CinchDB
@@ -38,7 +35,7 @@ CinchDB is for projects that need fast queries, data isolated data per-tenant [o
 
 On a meta level, I made this because I wanted a database structure that I felt comfortable letting AI agents take full control over, safely, and I didn't want to run my own Postgres instance somewhere or pay for it on e.g. Neon - I don't need hyperscaling, I just need super fast queries.
 
-Because it's so lightweight and its only dependencies are FastAPI, pydantic, requests, and Typer, it is super cheap to run on a small VM like from [Fly.io](https://fly.io) and I don't need to SSH into it to make changes - I can just store an API key in my local projects and hit the remote instance.
+Because it's so lightweight and its only dependencies are pydantic, requests, and Typer, it makes for a perfect local development database that can be controlled programmatically.
 
 
 ```bash
@@ -61,9 +58,9 @@ cinch branch merge-into-main feature
 cinch tenant create customer_a
 cinch query "SELECT * FROM users" --tenant customer_a
 
-# API server
-uv pip install cinchdb[server]
-cinch-server serve
+# Connect to remote CinchDB instance
+cinch remote add production https://your-cinchdb-server.com your-api-key
+cinch remote use production
 
 # Autogenerate Python SDK from database
 cinch codegen generate python cinchdb_models/
@@ -77,9 +74,9 @@ 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 deployment** - FastAPI server with UUID authentication
+- **Remote connectivity** - Connect to hosted CinchDB instances
 - **Type-safe SDK** - Python and TypeScript SDKs with full type safety
-- **API server for remote hosting** - Useful for running many web projects
+- **Remote-capable** - CLI and SDK can connect to remote instances
 - **SDK generation from database schema** - Generate a typesafe SDK from your database models for CRUD operations
 
 ## Installation
@@ -136,24 +133,25 @@ post_id = db.insert("posts", {"title": "Hello World", "content": "First post"})
 db.update("posts", post_id, {"content": "Updated content"})
 ```
 
-### Remote API
+### Remote Connection
 
 ```python
-# Connect to remote API
-db = cinchdb.connect_api("https://api.example.com", "your-api-key", "myapp")
+# 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"})
 ```
 
-## API Server
+## Remote Access
 
-Start the server:
+Connect to a remote CinchDB instance:
 
 ```bash
-cinch-server serve --create-key
-# Creates API key (works after shutdown as well) and starts server on http://localhost:8000
+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`.
@@ -162,7 +160,7 @@ Interactive docs at `/docs`, health check at `/health`.
 
 - **Python SDK**: Core functionality (local + remote)
 - **CLI**: Full-featured command-line interface  
-- **FastAPI Server**: REST API with authentication
+- **Remote Access**: Connect to hosted CinchDB instances
 - **TypeScript SDK**: Browser and Node.js client
 
 ## Development

{cinchdb-0.1.1.dist-info → cinchdb-0.1.2.dist-info}/RECORD

@@ -1,22 +1,6 @@
 cinchdb/__init__.py,sha256=NZdSzfhRguSBTjJ2dcESOQYy53OZEuBndlB7U08GMY0,179
 cinchdb/__main__.py,sha256=OpkDqn9zkTZhhYgvv_grswWLAHKbmxs4M-8C6Z5HfWY,85
 cinchdb/config.py,sha256=Exzf0hCJgcg0PRRQz8EG7XFipx6fIVKO7IsQhpc0Q4o,6187
-cinchdb/api/__init__.py,sha256=5AHDlOXOxxzyI8pW7puntIILp8E7HOy4D62odLN518w,79
-cinchdb/api/app.py,sha256=iL9tYWYpJAAOzH9UHNbpl82Ibwz_zBCqxDXqARmxjbc,2172
-cinchdb/api/auth.py,sha256=uxRWWRjE6sQWNPH6BBsdHT_PlWN_iYr_hh76tVG9fTY,8167
-cinchdb/api/main.py,sha256=FpqhO7zTgh-r6y14mL0Cp-fGQ0TMmxPKCF7cNjDiCcw,4509
-cinchdb/api/routers/__init__.py,sha256=o4xLUjKRKYnBU-RQiDXQotKml0lZEwIudU5S5bW4gt8,323
-cinchdb/api/routers/auth.py,sha256=6Si_iQtDwj487Hv87AoV4vMWAJFnvd5JsFXghYqA7ao,3842
-cinchdb/api/routers/branches.py,sha256=gEYBDqvwSzt5uSSVDo_mo2ysLfUqaavyDClpzRfYTyA,11537
-cinchdb/api/routers/codegen.py,sha256=As9zfBmT7SMx1lrQfRg8TGofcRSOo_r77fCLmxuYkI4,5069
-cinchdb/api/routers/columns.py,sha256=bWMIInp0Ma9KPp7PHFSr25ROWNKjOkwl9KNc3bQeqMo,8313
-cinchdb/api/routers/data.py,sha256=rYnh6TwgLArA85AalOydg4txoXD0UWEItAvISuRVTao,14923
-cinchdb/api/routers/databases.py,sha256=RyetGWqlnW7H7sCB4hOqWIPz-6cmJfI3f3KsIb4IX40,5282
-cinchdb/api/routers/projects.py,sha256=70nwkXjGiK_pfTr6hv50viOjvQgv5yfC50mEgTByClE,3847
-cinchdb/api/routers/query.py,sha256=UEtdKLIeo5OjOHfJl3IU3q2o69NOAX0pCyOwb7ivquQ,5120
-cinchdb/api/routers/tables.py,sha256=Dg0ANMEVHXZyIO-mJBQCnJKfdRORKFqKaunLfJ_cTlo,10403
-cinchdb/api/routers/tenants.py,sha256=1xukbM5avvkr1CMuq1pr78CNyE_9xk2Yg35mZFDvl-c,5692
-cinchdb/api/routers/views.py,sha256=pzovkLttjEAg0ecvPwaN5qFgBqNhD0_g0sqq9UNYAmc,6051
 cinchdb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cinchdb/cli/main.py,sha256=_vBSigtAcYgGBB4qRt2p3ZH8QZ4Osk5rLRe5cOD5ryU,4335
 cinchdb/cli/utils.py,sha256=Alh3plAiVOGSk_ETqTmh2rYHHFULelizsQOR4e-_KJw,5661
@@ -62,8 +46,8 @@ cinchdb/models/view.py,sha256=q6j-jYzFJuhRJO87rKt6Uv8hOizHQx8xwoPKoH6XnNY,530
 cinchdb/utils/__init__.py,sha256=1mBU1H2C9urYA8Z_v5BTdAfDe0mQ6GMAK0AM3zRPv5k,487
 cinchdb/utils/name_validator.py,sha256=sOeufsnIH2b7I9C3xUkQdmNv8NgnReVb6BVJkczwbeE,3955
 cinchdb/utils/sql_validator.py,sha256=7STxsVO7bD4gZ8mfimQSt4_Yfckw62plUS_X_xJ48Vo,5427
-cinchdb-0.1.1.dist-info/METADATA,sha256=45UJWJpH-sxzqdK1Z48065DJuFtEWv44KcQqp-ohe4c,5878
-cinchdb-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-cinchdb-0.1.1.dist-info/entry_points.txt,sha256=Zzlwp632_jT5OZBkrewvH3-RWUJ9E5vD_BNme6J-A1I,83
-cinchdb-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-cinchdb-0.1.1.dist-info/RECORD,,
+cinchdb-0.1.2.dist-info/METADATA,sha256=JpVRmU-ESHcuOVkon7bhSDSxy08wnEunEkKivHSVG24,5802
+cinchdb-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cinchdb-0.1.2.dist-info/entry_points.txt,sha256=VBOIzvnGbkKudMCCmNORS3885QSyjZUVKJQ-Syqa62w,47
+cinchdb-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+cinchdb-0.1.2.dist-info/RECORD,,

{cinchdb-0.1.1.dist-info → cinchdb-0.1.2.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 cinch = cinchdb.cli.main:app
-cinch-server = cinchdb.api.main:cli

cinchdb/api/__init__.py

@@ -1,5 +0,0 @@
-"""CinchDB API package."""
-
-from cinchdb.api.app import app
-
-__all__ = ["app"]

cinchdb/api/app.py

@@ -1,76 +0,0 @@
-"""FastAPI application for CinchDB."""
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from contextlib import asynccontextmanager
-
-from cinchdb import __version__
-from cinchdb.api.routers import (
-    auth,
-    projects,
-    databases,
-    branches,
-    tenants,
-    tables,
-    columns,
-    views,
-    query,
-    data,
-    codegen,
-)
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Application lifespan events."""
-    # Startup
-    print(f"Starting CinchDB API v{__version__}")
-    yield
-    # Shutdown
-    print("Shutting down CinchDB API")
-
-
-# Create FastAPI app
-app = FastAPI(
-    title="CinchDB API",
-    description="Git-like SQLite database management system",
-    version=__version__,
-    lifespan=lifespan,
-    docs_url="/docs",
-    redoc_url="/redoc",
-    openapi_url="/openapi.json",
-)
-
-# Configure CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Configure appropriately for production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Include routers
-app.include_router(auth.router, prefix="/api/v1/auth", tags=["auth"])
-app.include_router(projects.router, prefix="/api/v1/projects", tags=["projects"])
-app.include_router(databases.router, prefix="/api/v1/databases", tags=["databases"])
-app.include_router(branches.router, prefix="/api/v1/branches", tags=["branches"])
-app.include_router(tenants.router, prefix="/api/v1/tenants", tags=["tenants"])
-app.include_router(tables.router, prefix="/api/v1/tables", tags=["tables"])
-app.include_router(columns.router, prefix="/api/v1/columns", tags=["columns"])
-app.include_router(views.router, prefix="/api/v1/views", tags=["views"])
-app.include_router(query.router, prefix="/api/v1/query", tags=["query"])
-app.include_router(data.router, prefix="/api/v1/tables", tags=["data"])
-app.include_router(codegen.router, prefix="/api/v1/codegen", tags=["codegen"])
-
-
-@app.get("/")
-async def root():
-    """Root endpoint."""
-    return {"name": "CinchDB API", "version": __version__, "status": "running"}
-
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint."""
-    return {"status": "healthy"}

cinchdb/api/auth.py

@@ -1,290 +0,0 @@
-"""Authentication and API key management for CinchDB API."""
-
-import uuid
-from datetime import datetime, timezone
-from typing import Optional, List, Literal
-from pathlib import Path
-
-from fastapi import HTTPException, Security, Depends, Query
-from fastapi.security import APIKeyHeader
-from pydantic import BaseModel, Field
-
-from cinchdb.config import Config
-from cinchdb.core.path_utils import get_project_root
-
-
-# API Key header
-api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
-
-
-class APIKey(BaseModel):
-    """API key model."""
-
-    key: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    name: str
-    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
-    permissions: Literal["read", "write"] = "read"
-    branches: Optional[List[str]] = None  # None means all branches
-    active: bool = True
-
-
-class APIKeyManager:
-    """Manages API keys in the project configuration."""
-
-    def __init__(self, project_dir: Optional[Path] = None):
-        """Initialize API key manager.
-
-        Args:
-            project_dir: Project directory path
-        """
-        self.project_dir = project_dir or Path.cwd()
-        self.config = Config(self.project_dir)
-
-    def create_key(
-        self,
-        name: str,
-        permissions: Literal["read", "write"] = "read",
-        branches: Optional[List[str]] = None,
-    ) -> APIKey:
-        """Create a new API key.
-
-        Args:
-            name: Name for the API key
-            permissions: Permission level (read or write)
-            branches: List of allowed branches (None for all)
-
-        Returns:
-            Created API key
-        """
-        api_key = APIKey(name=name, permissions=permissions, branches=branches)
-
-        # Load config and add key
-        config_data = self.config.load()
-        if not config_data.api_keys:
-            config_data.api_keys = {}
-
-        config_data.api_keys[api_key.key] = {
-            "name": api_key.name,
-            "created_at": api_key.created_at.isoformat(),
-            "permissions": api_key.permissions,
-            "branches": api_key.branches,
-            "active": api_key.active,
-        }
-
-        self.config.save(config_data)
-        return api_key
-
-    def get_key(self, key: str) -> Optional[APIKey]:
-        """Get an API key by its value.
-
-        Args:
-            key: API key string
-
-        Returns:
-            API key if found and active, None otherwise
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return None
-
-        key_data = config_data.api_keys[key]
-        if not key_data.get("active", True):
-            return None
-
-        return APIKey(
-            key=key,
-            name=key_data["name"],
-            created_at=datetime.fromisoformat(key_data["created_at"]),
-            permissions=key_data.get("permissions", "read"),
-            branches=key_data.get("branches"),
-            active=key_data.get("active", True),
-        )
-
-    def list_keys(self) -> List[APIKey]:
-        """List all API keys.
-
-        Returns:
-            List of API keys
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys:
-            return []
-
-        keys = []
-        for key, key_data in config_data.api_keys.items():
-            keys.append(
-                APIKey(
-                    key=key,
-                    name=key_data["name"],
-                    created_at=datetime.fromisoformat(key_data["created_at"]),
-                    permissions=key_data.get("permissions", "read"),
-                    branches=key_data.get("branches"),
-                    active=key_data.get("active", True),
-                )
-            )
-
-        return keys
-
-    def revoke_key(self, key: str) -> bool:
-        """Revoke an API key.
-
-        Args:
-            key: API key to revoke
-
-        Returns:
-            True if revoked, False if not found
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return False
-
-        config_data.api_keys[key]["active"] = False
-        self.config.save(config_data)
-        return True
-
-    def delete_key(self, key: str) -> bool:
-        """Delete an API key.
-
-        Args:
-            key: API key to delete
-
-        Returns:
-            True if deleted, False if not found
-        """
-        config_data = self.config.load()
-        if not config_data.api_keys or key not in config_data.api_keys:
-            return False
-
-        del config_data.api_keys[key]
-        self.config.save(config_data)
-        return True
-
-
-class AuthContext(BaseModel):
-    """Authentication context for requests."""
-
-    api_key: APIKey
-    project_dir: Path
-
-
-async def get_current_project(project_dir: Optional[str] = None) -> Path:
-    """Get the current project directory.
-
-    Args:
-        project_dir: Optional project directory path
-
-    Returns:
-        Project directory path
-
-    Raises:
-        HTTPException: If project not found
-    """
-    if project_dir:
-        path = Path(project_dir)
-        if not path.exists() or not (path / ".cinchdb").exists():
-            raise HTTPException(status_code=404, detail="Project not found")
-        return path
-
-    # Try to find project from current directory
-    project_root = get_project_root(Path.cwd())
-    if not project_root:
-        raise HTTPException(
-            status_code=404,
-            detail="No CinchDB project found. Specify project_dir parameter.",
-        )
-
-    return project_root
-
-
-async def verify_api_key(
-    api_key_header: Optional[str] = Security(api_key_header),
-    api_key_query: Optional[str] = Query(None, alias="api_key"),
-    project_dir: Path = Depends(get_current_project),
-) -> AuthContext:
-    """Verify API key and return auth context.
-
-    Args:
-        api_key_header: API key from header
-        api_key_query: API key from query parameter
-        project_dir: Project directory
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If authentication fails
-    """
-    # Check header first, then query parameter
-    api_key = api_key_header or api_key_query
-    
-    if not api_key:
-        raise HTTPException(
-            status_code=401,
-            detail="API key required",
-            headers={"WWW-Authenticate": "ApiKey"},
-        )
-
-    manager = APIKeyManager(project_dir)
-    key_obj = manager.get_key(api_key)
-
-    if not key_obj:
-        raise HTTPException(
-            status_code=401,
-            detail="Invalid API key",
-            headers={"WWW-Authenticate": "ApiKey"},
-        )
-
-    return AuthContext(api_key=key_obj, project_dir=project_dir)
-
-
-async def require_write_permission(
-    auth: AuthContext = Depends(verify_api_key), branch: Optional[str] = None
-) -> AuthContext:
-    """Require write permission for the request.
-
-    Args:
-        auth: Authentication context
-        branch: Optional branch name to check
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If permission denied
-    """
-    if auth.api_key.permissions != "write":
-        raise HTTPException(status_code=403, detail="Write permission required")
-
-    # Check branch-specific permissions
-    if branch and auth.api_key.branches and branch not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{branch}'"
-        )
-
-    return auth
-
-
-async def require_read_permission(
-    auth: AuthContext = Depends(verify_api_key), branch: Optional[str] = None
-) -> AuthContext:
-    """Require read permission for the request.
-
-    Args:
-        auth: Authentication context
-        branch: Optional branch name to check
-
-    Returns:
-        Authentication context
-
-    Raises:
-        HTTPException: If permission denied
-    """
-    # All valid API keys have at least read permission
-
-    # Check branch-specific permissions
-    if branch and auth.api_key.branches and branch not in auth.api_key.branches:
-        raise HTTPException(
-            status_code=403, detail=f"Access denied for branch '{branch}'"
-        )
-
-    return auth

cinchdb/api/main.py

@@ -1,137 +0,0 @@
-"""Main entry point for CinchDB API server."""
-
-import uvicorn
-from pathlib import Path
-from typing import Optional
-
-import typer
-from rich.console import Console
-
-from cinchdb.api.auth import APIKeyManager
-from cinchdb.core.path_utils import get_project_root
-
-
-cli = typer.Typer(
-    name="cinch-server",
-    help="CinchDB API server",
-    add_completion=False,
-)
-console = Console()
-
-
-@cli.command()
-def serve(
-    host: str = typer.Option("0.0.0.0", "--host", "-h", help="Host to bind to"),
-    port: int = typer.Option(8000, "--port", "-p", help="Port to bind to"),
-    reload: bool = typer.Option(False, "--reload", "-r", help="Enable auto-reload"),
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-    create_key: bool = typer.Option(
-        False, "--create-key", help="Create an API key on startup"
-    ),
-):
-    """Start the CinchDB API server."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        console.print("[yellow]Run 'cinch init' to create a project[/yellow]")
-        raise typer.Exit(1)
-
-    console.print("[green]Starting CinchDB API server[/green]")
-    console.print(f"Project: {project_path}")
-    console.print(f"Host: {host}:{port}")
-
-    # Create API key if requested
-    if create_key:
-        manager = APIKeyManager(project_path)
-        api_key = manager.create_key("Initial API Key", permissions="write")
-        console.print("\n[bold green]Created API key:[/bold green]")
-        console.print(f"[yellow]Key: {api_key.key}[/yellow]")
-        console.print(f"[yellow]Permissions: {api_key.permissions}[/yellow]")
-        console.print("\n[bold]Save this key - it won't be shown again![/bold]\n")
-
-    # Start server
-    uvicorn.run(
-        "cinchdb.api.app:app", host=host, port=port, reload=reload, log_level="info"
-    )
-
-
-@cli.command()
-def create_key(
-    name: str = typer.Argument(..., help="Name for the API key"),
-    permissions: str = typer.Option(
-        "read", "--permissions", "-p", help="Permissions (read/write)"
-    ),
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-):
-    """Create a new API key."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        raise typer.Exit(1)
-
-    if permissions not in ["read", "write"]:
-        console.print("[red]❌ Invalid permissions. Must be 'read' or 'write'[/red]")
-        raise typer.Exit(1)
-
-    manager = APIKeyManager(project_path)
-    api_key = manager.create_key(name, permissions=permissions)
-
-    console.print(f"[green]✅ Created API key '{name}'[/green]")
-    console.print(f"[yellow]Key: {api_key.key}[/yellow]")
-    console.print(f"[yellow]Permissions: {api_key.permissions}[/yellow]")
-    console.print("\n[bold]Save this key - it won't be shown again![/bold]")
-
-
-@cli.command()
-def list_keys(
-    project_dir: Optional[Path] = typer.Option(
-        None, "--project-dir", "-d", help="Project directory"
-    ),
-):
-    """List all API keys."""
-    # Find project directory
-    if project_dir:
-        project_path = Path(project_dir)
-    else:
-        project_path = get_project_root(Path.cwd())
-
-    if not project_path or not (project_path / ".cinchdb").exists():
-        console.print("[red]❌ No CinchDB project found[/red]")
-        raise typer.Exit(1)
-
-    manager = APIKeyManager(project_path)
-    keys = manager.list_keys()
-
-    if not keys:
-        console.print("[yellow]No API keys found[/yellow]")
-        return
-
-    console.print("\n[bold]API Keys:[/bold]")
-    for key in keys:
-        status = "[green]Active[/green]" if key.active else "[red]Revoked[/red]"
-        branches = (
-            f"Branches: {', '.join(key.branches)}" if key.branches else "All branches"
-        )
-        console.print(f"\n{key.name} - {status}")
-        console.print(f"  Key: {key.key}")
-        console.print(f"  Permissions: {key.permissions}")
-        console.print(f"  {branches}")
-        console.print(f"  Created: {key.created_at}")
-
-
-if __name__ == "__main__":
-    cli()

cinchdb/api/routers/__init__.py

@@ -1,25 +0,0 @@
-"""API routers package."""
-
-from cinchdb.api.routers import (
-    auth,
-    projects,
-    databases,
-    branches,
-    tenants,
-    tables,
-    columns,
-    views,
-    query,
-)
-
-__all__ = [
-    "auth",
-    "projects",
-    "databases",
-    "branches",
-    "tenants",
-    "tables",
-    "columns",
-    "views",
-    "query",
-]