cinchdb 0.1.5__tar.gz → 0.1.7__tar.gz

{cinchdb-0.1.5 → cinchdb-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinchdb
-Version: 0.1.5
+Version: 0.1.7
 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
@@ -31,9 +31,9 @@ Description-Content-Type: text/markdown
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
+CinchDB is for projects that need fast queries, isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
 
-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.
+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 pydantic, requests, and Typer, it makes for a perfect local development database that can be controlled programmatically.
 
@@ -58,6 +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
@@ -76,7 +77,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **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** - CLI and SDK can connect to remote instances
+- **Remote-capable** - coming soon - 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
@@ -128,13 +129,30 @@ db.create_table("posts", [
 # Query data
 results = db.query("SELECT * FROM posts WHERE title LIKE ?", ["%python%"])
 
-# CRUD operations
+# CRUD operations - single insert
 post_id = db.insert("posts", {"title": "Hello World", "content": "First post"})
+
+# Batch insert - multiple records at once
+posts = db.insert("posts",
+    {"title": "First", "content": "Content 1"},
+    {"title": "Second", "content": "Content 2"},
+    {"title": "Third", "content": "Content 3"}
+)
+
+# Or with a list using star expansion
+post_list = [
+    {"title": "Post A", "content": "Content A"},
+    {"title": "Post B", "content": "Content B"}
+]
+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")
@@ -144,7 +162,7 @@ results = db.query("SELECT * FROM users")
 user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
 ```
 
-## Remote Access
+## Remote Access - coming soon 
 
 Connect to a remote CinchDB instance:
 

{cinchdb-0.1.5 → cinchdb-0.1.7}/README.md

@@ -4,9 +4,9 @@
 
 NOTE: CinchDB is in early alpha. This is project to test out an idea. Do not use this in production.
 
-CinchDB is for projects that need fast queries, data isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
+CinchDB is for projects that need fast queries, isolated data per-tenant [or even per-user](https://turso.tech/blog/give-each-of-your-users-their-own-sqlite-database-b74445f4), and a branchable database that makes it easy to merge changes between branches.
 
-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.
+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 pydantic, requests, and Typer, it makes for a perfect local development database that can be controlled programmatically.
 
@@ -31,6 +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
@@ -49,7 +50,7 @@ CinchDB combines SQLite with Git-like workflows for database schema management:
 - **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** - CLI and SDK can connect to remote instances
+- **Remote-capable** - coming soon - 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
@@ -101,13 +102,30 @@ db.create_table("posts", [
 # Query data
 results = db.query("SELECT * FROM posts WHERE title LIKE ?", ["%python%"])
 
-# CRUD operations
+# CRUD operations - single insert
 post_id = db.insert("posts", {"title": "Hello World", "content": "First post"})
+
+# Batch insert - multiple records at once
+posts = db.insert("posts",
+    {"title": "First", "content": "Content 1"},
+    {"title": "Second", "content": "Content 2"},
+    {"title": "Third", "content": "Content 3"}
+)
+
+# Or with a list using star expansion
+post_list = [
+    {"title": "Post A", "content": "Content A"},
+    {"title": "Post B", "content": "Content B"}
+]
+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")
@@ -117,7 +135,7 @@ results = db.query("SELECT * FROM users")
 user_id = db.insert("users", {"username": "alice", "email": "alice@example.com"})
 ```
 
-## Remote Access
+## Remote Access - coming soon 
 
 Connect to a remote CinchDB instance:
 

{cinchdb-0.1.5 → cinchdb-0.1.7}/pyproject.toml

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

cinchdb-0.1.7/src/cinchdb/cli/commands/__init__.py

@@ -0,0 +1,16 @@
+"""CLI command modules."""
+
+from . import database, branch, tenant, table, column, view, query, codegen, remote, index
+
+__all__ = [
+    "database",
+    "branch", 
+    "tenant",
+    "table",
+    "column",
+    "view",
+    "query",
+    "codegen",
+    "remote",
+    "index",
+]

cinchdb-0.1.7/src/cinchdb/cli/commands/index.py

@@ -0,0 +1,186 @@
+"""Index management commands for CinchDB CLI."""
+
+import typer
+from typing import List, Optional
+from rich import print
+from rich.table import Table
+from rich.console import Console
+
+from cinchdb.config import Config
+from cinchdb.managers.index import IndexManager
+from cinchdb.cli.utils import handle_cli_error
+
+app = typer.Typer(help="Manage database indexes")
+console = Console()
+
+
+@app.command("create")
+@handle_cli_error
+def create_index(
+    table: str = typer.Argument(..., help="Table name"),
+    columns: List[str] = typer.Argument(..., help="Column names to index"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Index name"),
+    unique: bool = typer.Option(False, "--unique", "-u", help="Create unique index"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Create an index on a table.
+    
+    Indexes are created at the branch level and apply to all tenants.
+    
+    Examples:
+        cinch index create users email
+        cinch index create orders user_id created_at --name idx_user_orders
+        cinch index create products sku --unique
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        index_name = manager.create_index(table, columns, name, unique)
+        
+        unique_text = "[green]UNIQUE[/green] " if unique else ""
+        columns_text = ", ".join(columns)
+        print(f"✓ Created {unique_text}index [bold cyan]{index_name}[/bold cyan] on {table}({columns_text})")
+        
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("drop")
+@handle_cli_error
+def drop_index(
+    name: str = typer.Argument(..., help="Index name"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Drop an index.
+    
+    Indexes are managed at the branch level.
+    
+    Example:
+        cinch index drop idx_users_email
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        manager.drop_index(name)
+        print(f"✓ Dropped index [bold cyan]{name}[/bold cyan]")
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+@handle_cli_error
+def list_indexes(
+    table: Optional[str] = typer.Argument(None, help="Table name to filter indexes"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """List indexes for a table or all tables.
+    
+    Indexes are managed at the branch level and apply to all tenants.
+    
+    Examples:
+        cinch index list
+        cinch index list users
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    indexes = manager.list_indexes(table)
+    
+    if not indexes:
+        if table:
+            print(f"No indexes found for table [cyan]{table}[/cyan]")
+        else:
+            print("No indexes found")
+        return
+    
+    # Create table for display
+    table_obj = Table(title=f"Indexes{f' for {table}' if table else ''}")
+    table_obj.add_column("Name", style="cyan")
+    table_obj.add_column("Table", style="yellow")
+    table_obj.add_column("Columns", style="green")
+    table_obj.add_column("Unique", style="magenta")
+    
+    for idx in indexes:
+        columns_str = ", ".join(idx["columns"])
+        unique_str = "✓" if idx["unique"] else ""
+        table_obj.add_row(
+            idx["name"],
+            idx["table"],
+            columns_str,
+            unique_str
+        )
+    
+    console.print(table_obj)
+
+
+@app.command("info")
+@handle_cli_error
+def index_info(
+    name: str = typer.Argument(..., help="Index name"),
+    database: Optional[str] = typer.Option(None, "--database", "-d", help="Database name"),
+    branch: Optional[str] = typer.Option(None, "--branch", "-b", help="Branch name"),
+):
+    """Show detailed information about an index.
+    
+    Example:
+        cinch index info idx_users_email
+    """
+    config = Config()
+    project_config = config.load()
+    
+    # Use provided values or defaults
+    database = database or project_config.active_database
+    branch = branch or project_config.active_branch
+    
+    manager = IndexManager(config.base_dir, database, branch)
+    
+    try:
+        info = manager.get_index_info(name)
+        
+        print(f"\nIndex: [bold cyan]{info['name']}[/bold cyan]")
+        print(f"Table: [yellow]{info['table']}[/yellow]")
+        print(f"Columns: [green]{', '.join(info['columns'])}[/green]")
+        print(f"Unique: [magenta]{'Yes' if info['unique'] else 'No'}[/magenta]")
+        print(f"Partial: [blue]{'Yes' if info.get('partial') else 'No'}[/blue]")
+        
+        if info.get('sql'):
+            print(f"\nSQL Definition:")
+            print(f"[dim]{info['sql']}[/dim]")
+            
+        if info.get('columns_info'):
+            print(f"\nColumn Details:")
+            for col in info['columns_info']:
+                print(f"  - Position {col['position']}: {col['column_name']}")
+                
+    except ValueError as e:
+        print(f"[red]✗ Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()

{cinchdb-0.1.5 → cinchdb-0.1.7}/src/cinchdb/cli/main.py

@@ -14,6 +14,7 @@ from cinchdb.cli.commands import (
     view,
     codegen,
     remote,
+    index,
 )
 
 app = typer.Typer(
@@ -42,6 +43,7 @@ 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(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")
 

{cinchdb-0.1.5 → cinchdb-0.1.7}/src/cinchdb/core/database.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
     from cinchdb.managers.tenant import TenantManager
     from cinchdb.managers.codegen import CodegenManager
     from cinchdb.managers.merge_manager import MergeManager
+    from cinchdb.managers.index import IndexManager
 
 
 class CinchDB:
@@ -108,6 +109,7 @@ class CinchDB:
         self._tenant_manager: Optional["TenantManager"] = None
         self._codegen_manager: Optional["CodegenManager"] = None
         self._merge_manager: Optional["MergeManager"] = None
+        self._index_manager: Optional["IndexManager"] = None
 
     @property
     def session(self):
@@ -303,6 +305,21 @@ class CinchDB:
             self._merge_manager = MergeManager(self.project_dir, self.database)
         return self._merge_manager
 
+    @property
+    def indexes(self) -> "IndexManager":
+        """Access index operations (local only)."""
+        if not self.is_local:
+            raise RuntimeError(
+                "Direct manager access not available for remote connections"
+            )
+        if self._index_manager is None:
+            from cinchdb.managers.index import IndexManager
+
+            self._index_manager = IndexManager(
+                self.project_dir, self.database, self.branch
+            )
+        return self._index_manager
+
     # Convenience methods for common operations
 
     def query(
@@ -363,23 +380,37 @@ class CinchDB:
                 "POST", "/tables", json={"name": name, "columns": columns_data}
             )
 
-    def insert(self, table: str, data: Dict[str, Any]) -> Dict[str, Any]:
-        """Insert a record into a table.
+    def insert(self, table: str, *data: Dict[str, Any]) -> Dict[str, Any] | List[Dict[str, Any]]:
+        """Insert one or more records into a table.
 
         Args:
             table: Table name
-            data: Record data as dictionary
+            *data: One or more record data dictionaries
 
         Returns:
-            Inserted record with generated fields (id, created_at, updated_at)
+            Single record dict if one record inserted, list of dicts if multiple
 
         Examples:
-            # Simple insert
+            # Single insert
             db.insert("users", {"name": "John", "email": "john@example.com"})
             
-            # Insert with custom ID
-            db.insert("products", {"id": "prod-123", "name": "Widget", "price": 9.99})
+            # Multiple inserts using star expansion
+            db.insert("users", 
+                {"name": "John", "email": "john@example.com"},
+                {"name": "Jane", "email": "jane@example.com"},
+                {"name": "Bob", "email": "bob@example.com"}
+            )
+            
+            # Or with a list using star expansion
+            users = [
+                {"name": "Alice", "email": "alice@example.com"},
+                {"name": "Charlie", "email": "charlie@example.com"}
+            ]
+            db.insert("users", *users)
         """
+        if not data:
+            raise ValueError("At least one record must be provided")
+            
         if self.is_local:
             # Initialize data manager if needed
             if self._data_manager is None:
@@ -387,14 +418,31 @@ class CinchDB:
                 self._data_manager = DataManager(
                     self.project_dir, self.database, self.branch, self.tenant
                 )
-            # Use the new create_from_dict method
-            return self._data_manager.create_from_dict(table, data)
+            
+            # Single record
+            if len(data) == 1:
+                return self._data_manager.create_from_dict(table, data[0])
+            
+            # Multiple records - batch insert
+            results = []
+            for record in data:
+                result = self._data_manager.create_from_dict(table, record)
+                results.append(result)
+            return results
         else:
-            # Remote insert - use new data CRUD endpoint
-            result = self._make_request(
-                "POST", f"/tables/{table}/data", json={"data": data}
-            )
-            return result
+            # Remote insert
+            if len(data) == 1:
+                # Single record - use existing endpoint
+                result = self._make_request(
+                    "POST", f"/tables/{table}/data", json={"data": data[0]}
+                )
+                return result
+            else:
+                # Multiple records - use bulk endpoint
+                result = self._make_request(
+                    "POST", f"/tables/{table}/data/bulk", json={"records": list(data)}
+                )
+                return result
 
     def update(self, table: str, id: str, data: Dict[str, Any]) -> Dict[str, Any]:
         """Update a record in a table.
@@ -429,6 +477,52 @@ class CinchDB:
             # Remote delete
             self._make_request("DELETE", f"/tables/{table}/data/{id}")
 
+    def create_index(
+        self,
+        table: str,
+        columns: List[str],
+        name: Optional[str] = None,
+        unique: bool = False,
+    ) -> str:
+        """Create an index on a table at the branch level.
+        
+        Indexes are created for the current branch and apply to all tenants.
+
+        Args:
+            table: Table name
+            columns: List of column names to index
+            name: Optional index name (auto-generated if not provided)
+            unique: Whether to create a unique index
+
+        Returns:
+            str: Name of the created index
+
+        Examples:
+            # Simple index on one column
+            db.create_index("users", ["email"])
+            
+            # Unique compound index
+            db.create_index("orders", ["user_id", "order_number"], unique=True)
+            
+            # Named index
+            db.create_index("products", ["category", "price"], name="idx_category_price")
+        """
+        if self.is_local:
+            return self.indexes.create_index(table, columns, name, unique)
+        else:
+            # Remote index creation
+            result = self._make_request(
+                "POST",
+                "/indexes",
+                json={
+                    "table": table,
+                    "columns": columns,
+                    "name": name,
+                    "unique": unique,
+                },
+            )
+            return result.get("name")
+
     def list_changes(self) -> List["Change"]:
         """List all changes for the current branch.
 

cinchdb-0.1.7/src/cinchdb/managers/index.py

@@ -0,0 +1,300 @@
+"""Index management for CinchDB."""
+
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+import sqlite3
+import json
+from datetime import datetime, timezone
+import uuid
+
+from cinchdb.core.connection import DatabaseConnection
+from cinchdb.core.path_utils import get_tenant_db_path
+from cinchdb.models.change import Change, ChangeType
+
+
+class IndexManager:
+    """Manages database indexes for CinchDB tables at the branch level."""
+
+    def __init__(
+        self, project_dir: Path, database: str, branch: str
+    ):
+        """Initialize IndexManager.
+
+        Args:
+            project_dir: Path to the project directory
+            database: Database name
+            branch: Branch name
+        """
+        self.project_dir = Path(project_dir)
+        self.database = database
+        self.branch = branch
+
+    def create_index(
+        self,
+        table: str,
+        columns: List[str],
+        name: Optional[str] = None,
+        unique: bool = False,
+        if_not_exists: bool = True,
+    ) -> str:
+        """Create an index on a table.
+
+        Args:
+            table: Table name
+            columns: List of column names to index
+            name: Optional index name (auto-generated if not provided)
+            unique: Whether to create a unique index
+            if_not_exists: Whether to use IF NOT EXISTS clause
+
+        Returns:
+            str: Name of the created index
+
+        Raises:
+            ValueError: If table doesn't exist or columns are invalid
+        """
+        if not columns:
+            raise ValueError("At least one column must be specified for the index")
+
+        # Generate index name if not provided
+        if not name:
+            column_str = "_".join(columns)
+            unique_prefix = "uniq_" if unique else "idx_"
+            name = f"{unique_prefix}{table}_{column_str}"
+
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            # Verify table exists
+            result = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name=?",
+                [table]
+            )
+            if not result.fetchone():
+                raise ValueError(f"Table '{table}' does not exist")
+            
+            # Verify columns exist
+            result = conn.execute(f"PRAGMA table_info({table})")
+            existing_columns = {row[1] for row in result.fetchall()}
+            
+            invalid_columns = set(columns) - existing_columns
+            if invalid_columns:
+                raise ValueError(
+                    f"Columns {invalid_columns} do not exist in table '{table}'"
+                )
+            
+            # Build and execute CREATE INDEX statement
+            unique_clause = "UNIQUE " if unique else ""
+            if_not_exists_clause = "IF NOT EXISTS " if if_not_exists else ""
+            column_list = ", ".join(columns)
+            
+            sql = f"CREATE {unique_clause}INDEX {if_not_exists_clause}{name} ON {table} ({column_list})"
+            
+            try:
+                result = conn.execute(sql)
+                conn.commit()
+            except sqlite3.Error as e:
+                if "already exists" in str(e):
+                    if not if_not_exists:
+                        raise ValueError(f"Index '{name}' already exists")
+                else:
+                    raise
+        
+        # Track the change
+        self._track_change(
+            ChangeType.CREATE_INDEX,
+            name,
+            {"table": table, "columns": columns, "unique": unique}
+        )
+        
+        return name
+
+    def drop_index(self, name: str, if_exists: bool = True) -> None:
+        """Drop an index.
+
+        Args:
+            name: Index name
+            if_exists: Whether to use IF EXISTS clause
+
+        Raises:
+            ValueError: If index doesn't exist and if_exists is False
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Check if index exists
+            result = conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='index' AND name=?",
+                [name]
+            )
+            exists = result.fetchone() is not None
+            
+            if not exists and not if_exists:
+                raise ValueError(f"Index '{name}' does not exist")
+            
+            if exists:
+                if_exists_clause = "IF EXISTS " if if_exists else ""
+                sql = f"DROP INDEX {if_exists_clause}{name}"
+                
+                result = conn.execute(sql)
+                conn.commit()
+                
+                # Track the change
+                self._track_change(ChangeType.DROP_INDEX, name, {})
+
+    def list_indexes(self, table: Optional[str] = None) -> List[Dict[str, Any]]:
+        """List indexes for a table or all tables.
+
+        Args:
+            table: Optional table name to filter indexes
+
+        Returns:
+            List of index information dictionaries
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        indexes = []
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Get all indexes (excluding SQLite internal indexes)
+            if table:
+                result = conn.execute(
+                    """
+                    SELECT name, tbl_name, sql 
+                    FROM sqlite_master 
+                    WHERE type='index' 
+                    AND tbl_name=? 
+                    AND sql IS NOT NULL
+                    """,
+                    [table]
+                )
+            else:
+                result = conn.execute(
+                    """
+                    SELECT name, tbl_name, sql 
+                    FROM sqlite_master 
+                    WHERE type='index' 
+                    AND sql IS NOT NULL
+                    """
+                )
+            
+            for row in result.fetchall():
+                index_name, table_name, sql = row
+                
+                # Parse unique from SQL
+                is_unique = "CREATE UNIQUE INDEX" in sql.upper()
+                
+                # Get indexed columns
+                pragma_result = conn.execute(f"PRAGMA index_info({index_name})")
+                columns = [info[2] for info in pragma_result.fetchall()]
+                
+                indexes.append({
+                    "name": index_name,
+                    "table": table_name,
+                    "columns": columns,
+                    "unique": is_unique,
+                    "sql": sql
+                })
+        
+        return indexes
+
+    def get_index_info(self, name: str) -> Dict[str, Any]:
+        """Get detailed information about a specific index.
+
+        Args:
+            name: Index name
+
+        Returns:
+            Dictionary with index information
+
+        Raises:
+            ValueError: If index doesn't exist
+        """
+        # Get connection to main tenant database (indexes are branch-level)
+        db_path = get_tenant_db_path(
+            self.project_dir, self.database, self.branch, "main"
+        )
+        
+        with DatabaseConnection(db_path) as conn:
+            
+            # Get index info
+            result = conn.execute(
+                """
+                SELECT name, tbl_name, sql 
+                FROM sqlite_master 
+                WHERE type='index' 
+                AND name=?
+                """,
+                [name]
+            )
+            
+            row = result.fetchone()
+            if not row:
+                raise ValueError(f"Index '{name}' does not exist")
+            
+            index_name, table_name, sql = row
+            
+            # Parse unique from SQL
+            is_unique = "CREATE UNIQUE INDEX" in (sql or "").upper()
+            
+            # Get indexed columns with more details
+            pragma_result = conn.execute(f"PRAGMA index_info({index_name})")
+            columns_info = []
+            for info in pragma_result.fetchall():
+                columns_info.append({
+                    "position": info[0],
+                    "column_id": info[1],
+                    "column_name": info[2]
+                })
+            
+            # Get index statistics
+            xinfo_result = conn.execute(f"PRAGMA index_xinfo({index_name})")
+            extended_info = xinfo_result.fetchall()
+            
+            return {
+                "name": index_name,
+                "table": table_name,
+                "columns": [col["column_name"] for col in columns_info],
+                "columns_info": columns_info,
+                "unique": is_unique,
+                "sql": sql,
+                "partial": sql and "WHERE" in sql.upper() if sql else False
+            }
+
+    def _track_change(
+        self, change_type: ChangeType, entity_name: str, metadata: Dict[str, Any]
+    ) -> None:
+        """Track a change for this branch.
+
+        Args:
+            change_type: Type of change
+            entity_name: Name of the entity being changed
+            metadata: Additional metadata about the change
+        """
+        # Import here to avoid circular dependency
+        from cinchdb.managers.change_tracker import ChangeTracker
+        
+        tracker = ChangeTracker(self.project_dir, self.database, self.branch)
+        
+        change = Change(
+            id=str(uuid.uuid4()),
+            type=change_type,
+            entity_type="index",
+            entity_name=entity_name,
+            branch=self.branch,
+            metadata=metadata,
+            applied=True,
+            created_at=datetime.now(timezone.utc),
+        )
+        
+        tracker.add_change(change)

cinchdb-0.1.5/src/cinchdb/cli/commands/__init__.py

@@ -1 +0,0 @@
-"""CLI command modules."""