decompressed-cli 0.1.0__tar.gz

decompressed_cli-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: decompressed-cli
+Version: 0.1.0
+Summary: CLI for Decompressed - Git-like version control for vector datasets
+Author-email: Decompressed <support@decompressed.io>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: decompressed-sdk>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+
+# Decompressed CLI
+
+Git-like version control for vector datasets.
+
+## Installation
+
+```bash
+pip install decompressed-cli
+```
+
+Or install from source:
+```bash
+cd sdk/cli
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Configure your API key
+dcp config set api_key YOUR_API_KEY
+dcp config set base_url https://api.decompressed.io
+
+# List your datasets
+dcp datasets list
+
+# Get dataset info
+dcp datasets info my-dataset
+
+# Version control commands
+dcp log my-dataset                    # Show version history
+dcp checkout my-dataset --version 3   # Pin to version 3
+dcp commit my-dataset -m "Added data" # Create new version
+dcp tag my-dataset v3 production      # Tag version as 'production'
+dcp diff my-dataset 2 3               # Compare versions
+
+# Data commands
+dcp pull my-dataset -o ./data/        # Download dataset
+dcp push ./vectors.npy my-dataset     # Upload/append vectors
+```
+
+## Commands
+
+### Configuration
+- `dcp config set <key> <value>` - Set config value
+- `dcp config get <key>` - Get config value
+- `dcp config list` - List all config
+
+### Datasets
+- `dcp datasets list` - List all datasets
+- `dcp datasets info <dataset>` - Show dataset details
+- `dcp datasets delete <dataset>` - Delete a dataset
+
+### Versioning
+- `dcp log <dataset>` - Show version history
+- `dcp checkout <dataset> --version <n>` - Pin to specific version
+- `dcp commit <dataset> -m <message>` - Commit pending changes
+- `dcp tag <dataset> <version> <name>` - Create named ref
+- `dcp diff <dataset> <v1> <v2>` - Compare two versions
+
+### Data
+- `dcp pull <dataset> -o <path>` - Download dataset vectors
+- `dcp push <file> <dataset>` - Upload/append vectors
+
+## Configuration
+
+Config is stored in `~/.decompressed/config.json`:
+
+```json
+{
+  "api_key": "dcp_xxx",
+  "base_url": "https://api.decompressed.io"
+}
+```

decompressed_cli-0.1.0/README.md

@@ -0,0 +1,74 @@
+# Decompressed CLI
+
+Git-like version control for vector datasets.
+
+## Installation
+
+```bash
+pip install decompressed-cli
+```
+
+Or install from source:
+```bash
+cd sdk/cli
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Configure your API key
+dcp config set api_key YOUR_API_KEY
+dcp config set base_url https://api.decompressed.io
+
+# List your datasets
+dcp datasets list
+
+# Get dataset info
+dcp datasets info my-dataset
+
+# Version control commands
+dcp log my-dataset                    # Show version history
+dcp checkout my-dataset --version 3   # Pin to version 3
+dcp commit my-dataset -m "Added data" # Create new version
+dcp tag my-dataset v3 production      # Tag version as 'production'
+dcp diff my-dataset 2 3               # Compare versions
+
+# Data commands
+dcp pull my-dataset -o ./data/        # Download dataset
+dcp push ./vectors.npy my-dataset     # Upload/append vectors
+```
+
+## Commands
+
+### Configuration
+- `dcp config set <key> <value>` - Set config value
+- `dcp config get <key>` - Get config value
+- `dcp config list` - List all config
+
+### Datasets
+- `dcp datasets list` - List all datasets
+- `dcp datasets info <dataset>` - Show dataset details
+- `dcp datasets delete <dataset>` - Delete a dataset
+
+### Versioning
+- `dcp log <dataset>` - Show version history
+- `dcp checkout <dataset> --version <n>` - Pin to specific version
+- `dcp commit <dataset> -m <message>` - Commit pending changes
+- `dcp tag <dataset> <version> <name>` - Create named ref
+- `dcp diff <dataset> <v1> <v2>` - Compare two versions
+
+### Data
+- `dcp pull <dataset> -o <path>` - Download dataset vectors
+- `dcp push <file> <dataset>` - Upload/append vectors
+
+## Configuration
+
+Config is stored in `~/.decompressed/config.json`:
+
+```json
+{
+  "api_key": "dcp_xxx",
+  "base_url": "https://api.decompressed.io"
+}
+```

decompressed_cli-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "decompressed-cli"
+version = "0.1.0"
+description = "CLI for Decompressed - Git-like version control for vector datasets"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Decompressed", email = "support@decompressed.io"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "decompressed-sdk>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+dcp = "decompressed_cli.main:app"
+
+[tool.setuptools.packages.find]
+where = ["src"]

decompressed_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

decompressed_cli-0.1.0/src/decompressed_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Decompressed CLI - Git-like version control for vector datasets."""
+
+__version__ = "0.1.0"

decompressed_cli-0.1.0/src/decompressed_cli/commands/__init__.py

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

decompressed_cli-0.1.0/src/decompressed_cli/commands/config_cmd.py

@@ -0,0 +1,70 @@
+"""Configuration commands."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..config import load_config, set_config_value, get_config_value, CONFIG_FILE
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Config key (api_key, base_url)"),
+    value: str = typer.Argument(..., help="Config value"),
+):
+    """Set a configuration value."""
+    valid_keys = ["api_key", "base_url"]
+    if key not in valid_keys:
+        console.print(f"[red]Unknown config key: {key}[/red]")
+        console.print(f"Valid keys: {', '.join(valid_keys)}")
+        raise typer.Exit(1)
+    
+    set_config_value(key, value)
+    
+    # Mask API key in output
+    display_value = value[:8] + "..." if key == "api_key" and len(value) > 8 else value
+    console.print(f"[green]✓[/green] Set {key} = {display_value}")
+
+
+@app.command("get")
+def config_get(
+    key: str = typer.Argument(..., help="Config key to get"),
+):
+    """Get a configuration value."""
+    value = get_config_value(key)
+    if value is None:
+        console.print(f"[yellow]Not set:[/yellow] {key}")
+    else:
+        # Mask API key
+        display_value = value[:8] + "..." if key == "api_key" and len(str(value)) > 8 else value
+        console.print(f"{key} = {display_value}")
+
+
+@app.command("list")
+def config_list():
+    """List all configuration values."""
+    config = load_config()
+    
+    table = Table(title=f"Config ({CONFIG_FILE})")
+    table.add_column("Key", style="cyan")
+    table.add_column("Value", style="green")
+    
+    for key, value in config.items():
+        if value is None:
+            display_value = "[dim]not set[/dim]"
+        elif key == "api_key" and len(str(value)) > 8:
+            display_value = value[:8] + "..."
+        else:
+            display_value = str(value)
+        table.add_row(key, display_value)
+    
+    console.print(table)
+
+
+@app.command("path")
+def config_path():
+    """Show config file path."""
+    console.print(str(CONFIG_FILE))

decompressed_cli-0.1.0/src/decompressed_cli/commands/data_cmd.py

@@ -0,0 +1,161 @@
+"""Data pull/push commands."""
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from pathlib import Path
+from typing import Optional
+
+from ..config import get_client
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+def pull(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    output: Path = typer.Option(
+        Path("./"), "--output", "-o", help="Output directory"
+    ),
+    version: Optional[int] = typer.Option(
+        None, "--version", "-v", help="Specific version (default: latest)"
+    ),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+    format: str = typer.Option("npy", "--format", "-f", help="Output format (npy, csv)"),
+):
+    """
+    Download dataset vectors to local files.
+    
+    Example:
+        dcp pull my-dataset -o ./data/
+        dcp pull my-dataset --version 3 -o ./data/
+    """
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        target_version = version or ds.current_version
+        output.mkdir(parents=True, exist_ok=True)
+        
+        console.print(f"Pulling {dataset} v{target_version}...")
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Downloading blocks...", total=None)
+            
+            block_count = 0
+            vector_count = 0
+            
+            for block in client.datasets.iter_blocks(
+                dataset, 
+                project=project,
+                version=target_version,
+                include_metadata=True,
+                prefetch=True,
+            ):
+                block_count += 1
+                vector_count += block.num_vectors
+                progress.update(
+                    task, 
+                    description=f"Block {block.block_index + 1}/{block.total_blocks} ({vector_count:,} vectors)"
+                )
+                
+                # Save block
+                import numpy as np
+                block_file = output / f"{block.block_id}.npy"
+                np.save(block_file, block.vectors)
+                
+                # Save metadata if present
+                if block.metadata and any(block.metadata):
+                    import json
+                    meta_file = output / f"{block.block_id}_metadata.json"
+                    with open(meta_file, "w") as f:
+                        json.dump(block.metadata, f)
+        
+        console.print(f"\n[green]✓[/green] Downloaded {vector_count:,} vectors in {block_count} blocks")
+        console.print(f"  Output: {output.absolute()}")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def push(
+    file: Path = typer.Argument(..., help="File to upload (.npy, .csv, .parquet)"),
+    dataset: str = typer.Argument(..., help="Dataset name (creates new or appends)"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+    message: str = typer.Option(None, "--message", "-m", help="Version message"),
+    compression: str = typer.Option(None, "--compression", "-c", help="Compression (fp16, int8)"),
+):
+    """
+    Upload vectors to a dataset (creates new or appends).
+    
+    Example:
+        dcp push ./vectors.npy my-dataset
+        dcp push ./vectors.npy my-dataset -m "Added January data"
+    """
+    try:
+        if not file.exists():
+            console.print(f"[red]Error:[/red] File not found: {file}")
+            raise typer.Exit(1)
+        
+        client = get_client()
+        
+        # Check if dataset exists
+        try:
+            existing = client.datasets.get(dataset, project=project)
+            is_append = True
+            console.print(f"Appending to existing dataset: {dataset} (v{existing.current_version})")
+        except Exception:
+            is_append = False
+            console.print(f"Creating new dataset: {dataset}")
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Uploading...", total=None)
+            
+            if is_append:
+                progress.update(task, description="Appending vectors...")
+                result = client.datasets.append(
+                    file,
+                    dataset,
+                    project=project,
+                    compression=compression,
+                    description=message,
+                )
+                new_version = result.new_version
+            else:
+                progress.update(task, description="Uploading new dataset...")
+                result = client.datasets.upload(
+                    file,
+                    dataset,
+                    project=project,
+                    compression=compression,
+                )
+                new_version = 1
+        
+        console.print(f"\n[green]✓[/green] {'Appended to' if is_append else 'Created'} {dataset}")
+        console.print(f"  Version: v{new_version}")
+        if message:
+            console.print(f"  Message: {message}")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+# Register commands on the app
+app.command("pull")(pull)
+app.command("push")(push)

decompressed_cli-0.1.0/src/decompressed_cli/commands/datasets_cmd.py

@@ -0,0 +1,104 @@
+"""Dataset management commands."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+from ..config import get_client
+
+app = typer.Typer(no_args_is_help=True)
+console = Console()
+
+
+@app.command("list")
+def list_datasets():
+    """List all datasets."""
+    try:
+        client = get_client()
+        datasets = client.datasets.list()
+        
+        if not datasets:
+            console.print("[yellow]No datasets found.[/yellow]")
+            return
+        
+        table = Table(title="Datasets")
+        table.add_column("Name", style="cyan")
+        table.add_column("ID", style="dim")
+        table.add_column("Vectors", justify="right")
+        table.add_column("Dims", justify="right")
+        table.add_column("Version", justify="right", style="green")
+        
+        for ds in datasets:
+            table.add_row(
+                ds.name,
+                ds.id[:8] + "...",
+                f"{ds.num_vectors:,}" if ds.num_vectors else "-",
+                str(ds.dimensions) if ds.dimensions else "-",
+                f"v{ds.current_version}" if ds.current_version else "-",
+            )
+        
+        console.print(table)
+        console.print(f"\n[dim]{len(datasets)} dataset(s)[/dim]")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("info")
+def info(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+):
+    """Show detailed dataset information."""
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        panel_content = f"""[cyan]Name:[/cyan] {ds.name}
+[cyan]ID:[/cyan] {ds.id}
+[cyan]Vectors:[/cyan] {ds.num_vectors:,} vectors
+[cyan]Dimensions:[/cyan] {ds.dimensions}
+[cyan]Current Version:[/cyan] v{ds.current_version}
+[cyan]Created:[/cyan] {ds.created_at or 'Unknown'}
+[cyan]Updated:[/cyan] {ds.updated_at or 'Unknown'}"""
+        
+        console.print(Panel(panel_content, title=f"Dataset: {ds.name}", border_style="green"))
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command("delete")
+def delete(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+):
+    """Delete a dataset."""
+    try:
+        client = get_client()
+        
+        if not force:
+            confirm = typer.confirm(f"Delete dataset '{dataset}'? This cannot be undone")
+            if not confirm:
+                console.print("[yellow]Cancelled.[/yellow]")
+                raise typer.Exit(0)
+        
+        client.datasets.delete(dataset, project=project, delete_file=True)
+        console.print(f"[green]✓[/green] Deleted dataset: {dataset}")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)

decompressed_cli-0.1.0/src/decompressed_cli/commands/versions_cmd.py

@@ -0,0 +1,204 @@
+"""Version control commands - the core git-like functionality."""
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from typing import Optional
+
+from ..config import get_client
+
+console = Console()
+
+
+def log(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+    limit: int = typer.Option(20, "--limit", "-n", help="Number of versions to show"),
+):
+    """Show version history for a dataset (like git log)."""
+    try:
+        client = get_client()
+        events = client.datasets.history(dataset, limit=limit)
+        
+        if not events:
+            console.print("[yellow]No version history found.[/yellow]")
+            return
+        
+        console.print(f"[bold]Version history for {dataset}[/bold]\n")
+        
+        for event in events:
+            # Format like git log
+            version_str = f"v{event.version}" if event.version else "?"
+            
+            console.print(f"[yellow]commit {version_str}[/yellow]")
+            if event.created_at:
+                console.print(f"Date:   {event.created_at}")
+            if event.action:
+                console.print(f"Action: {event.action}")
+            if event.description:
+                console.print(f"\n    {event.description}")
+            console.print()
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def checkout(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    version: int = typer.Option(..., "--version", "-v", help="Version number to checkout"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+):
+    """
+    Pin to a specific dataset version (like git checkout).
+    
+    This sets the working version for subsequent operations.
+    """
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        # Verify version exists
+        pinned = ds.version(version)
+        info = pinned.info()
+        
+        # Handle both dict and dataclass responses
+        num_vectors = info.get('num_vectors') if isinstance(info, dict) else getattr(info, 'num_vectors', None)
+        num_blocks = info.get('num_blocks') if isinstance(info, dict) else getattr(info, 'num_blocks', None)
+        
+        console.print(f"[green]✓[/green] Checked out {dataset} @ v{version}")
+        console.print(f"  Vectors: {num_vectors:,}" if num_vectors else "  Vectors: unknown")
+        console.print(f"  Blocks: {num_blocks}" if num_blocks else "  Blocks: unknown")
+        
+        # Note: In a full implementation, we'd store this in local state
+        console.print(f"\n[dim]Tip: Use --version {version} in other commands to use this version[/dim]")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def commit(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    message: str = typer.Option(..., "--message", "-m", help="Commit message"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+):
+    """
+    Commit pending changes to create a new version (like git commit).
+    
+    Note: In Decompressed, versions are created automatically when you
+    push data. This command is for adding a description to the current version.
+    """
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        # For now, just show current version info
+        # In a full implementation, this would finalize a draft version
+        console.print(f"[green]✓[/green] Current version: v{ds.current_version}")
+        console.print(f"  Message: {message}")
+        console.print(f"\n[dim]Note: Versions are created automatically when pushing data.[/dim]")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def tag(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    version: int = typer.Argument(..., help="Version number to tag"),
+    name: str = typer.Argument(..., help="Tag name (e.g., 'production', 'stable')"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+):
+    """
+    Create a named ref for a version (like git tag).
+    
+    Example: dcp tag my-dataset 3 production
+    """
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        # Get the version and promote it
+        pinned = ds.version(version)
+        pinned.promote(name)
+        
+        console.print(f"[green]✓[/green] Tagged {dataset} v{version} as '{name}'")
+        console.print(f"\n[dim]Access via: dataset.ref('{name}')[/dim]")
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def diff(
+    dataset: str = typer.Argument(..., help="Dataset name or ID"),
+    version1: int = typer.Argument(..., help="First version"),
+    version2: int = typer.Argument(..., help="Second version"),
+    project: str = typer.Option(None, "--project", "-p", help="Project name"),
+):
+    """
+    Compare two versions of a dataset (like git diff).
+    
+    Example: dcp diff my-dataset 2 3
+    """
+    try:
+        client = get_client()
+        ds = client.datasets.get(dataset, project=project)
+        
+        # Get info for both versions
+        v1 = ds.version(version1)
+        v2 = ds.version(version2)
+        
+        info1 = v1.info()
+        info2 = v2.info()
+        
+        # Helper to get value from dict or dataclass
+        def get_val(info, key, default=0):
+            if isinstance(info, dict):
+                return info.get(key, default)
+            return getattr(info, key, default) or default
+        
+        console.print(f"[bold]Comparing {dataset}: v{version1} → v{version2}[/bold]\n")
+        
+        table = Table()
+        table.add_column("Metric", style="cyan")
+        table.add_column(f"v{version1}", justify="right")
+        table.add_column(f"v{version2}", justify="right")
+        table.add_column("Change", justify="right")
+        
+        # Vectors
+        v1_vecs = get_val(info1, "num_vectors", 0)
+        v2_vecs = get_val(info2, "num_vectors", 0)
+        vec_diff = v2_vecs - v1_vecs
+        vec_change = f"[green]+{vec_diff:,}[/green]" if vec_diff > 0 else f"[red]{vec_diff:,}[/red]" if vec_diff < 0 else "0"
+        table.add_row("Vectors", f"{v1_vecs:,}", f"{v2_vecs:,}", vec_change)
+        
+        # Blocks
+        v1_blocks = get_val(info1, "num_blocks", 0)
+        v2_blocks = get_val(info2, "num_blocks", 0)
+        block_diff = v2_blocks - v1_blocks
+        block_change = f"[green]+{block_diff}[/green]" if block_diff > 0 else f"[red]{block_diff}[/red]" if block_diff < 0 else "0"
+        table.add_row("Blocks", str(v1_blocks), str(v2_blocks), block_change)
+        
+        console.print(table)
+        
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)

decompressed_cli-0.1.0/src/decompressed_cli/config.py

@@ -0,0 +1,74 @@
+"""Configuration management for Decompressed CLI."""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+CONFIG_DIR = Path.home() / ".decompressed"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULT_CONFIG = {
+    "api_key": None,
+    "base_url": "http://localhost:8000",
+}
+
+
+def ensure_config_dir() -> None:
+    """Ensure config directory exists."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> Dict[str, Any]:
+    """Load config from file, creating defaults if needed."""
+    ensure_config_dir()
+    
+    if not CONFIG_FILE.exists():
+        save_config(DEFAULT_CONFIG)
+        return DEFAULT_CONFIG.copy()
+    
+    try:
+        with open(CONFIG_FILE, "r") as f:
+            config = json.load(f)
+        # Merge with defaults for any missing keys
+        for key, value in DEFAULT_CONFIG.items():
+            if key not in config:
+                config[key] = value
+        return config
+    except (json.JSONDecodeError, IOError):
+        return DEFAULT_CONFIG.copy()
+
+
+def save_config(config: Dict[str, Any]) -> None:
+    """Save config to file."""
+    ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+def get_config_value(key: str) -> Optional[Any]:
+    """Get a single config value."""
+    config = load_config()
+    return config.get(key)
+
+
+def set_config_value(key: str, value: Any) -> None:
+    """Set a single config value."""
+    config = load_config()
+    config[key] = value
+    save_config(config)
+
+
+def get_client():
+    """Get configured SDK client."""
+    from decompressed_sdk import DecompressedClient
+    
+    config = load_config()
+    api_key = config.get("api_key")
+    base_url = config.get("base_url", "http://localhost:8000")
+    
+    if not api_key:
+        raise ValueError(
+            "API key not configured. Run: dcp config set api_key YOUR_KEY"
+        )
+    
+    return DecompressedClient(base_url=base_url, api_key=api_key)

decompressed_cli-0.1.0/src/decompressed_cli/main.py

@@ -0,0 +1,46 @@
+"""Main CLI entry point."""
+
+import typer
+from rich.console import Console
+
+from . import __version__
+from .commands import config_cmd, datasets_cmd, versions_cmd, data_cmd
+
+app = typer.Typer(
+    name="dcp",
+    help="Decompressed CLI - Git-like version control for vector datasets",
+    no_args_is_help=True,
+)
+console = Console()
+
+# Register command groups
+app.add_typer(config_cmd.app, name="config", help="Manage CLI configuration")
+app.add_typer(datasets_cmd.app, name="datasets", help="Manage datasets")
+app.add_typer(data_cmd.app, name="data", help="Pull/push data (alias)")
+
+# Register top-level versioning commands
+app.command("log")(versions_cmd.log)
+app.command("checkout")(versions_cmd.checkout)
+app.command("commit")(versions_cmd.commit)
+app.command("tag")(versions_cmd.tag)
+app.command("diff")(versions_cmd.diff)
+
+# Shortcuts for common operations
+app.command("pull")(data_cmd.pull)
+app.command("push")(data_cmd.push)
+
+
+@app.command()
+def version():
+    """Show CLI version."""
+    console.print(f"dcp version {__version__}")
+
+
+@app.callback()
+def main_callback():
+    """Decompressed CLI - Git-like version control for vector datasets."""
+    pass
+
+
+if __name__ == "__main__":
+    app()

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: decompressed-cli
+Version: 0.1.0
+Summary: CLI for Decompressed - Git-like version control for vector datasets
+Author-email: Decompressed <support@decompressed.io>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: decompressed-sdk>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+
+# Decompressed CLI
+
+Git-like version control for vector datasets.
+
+## Installation
+
+```bash
+pip install decompressed-cli
+```
+
+Or install from source:
+```bash
+cd sdk/cli
+pip install -e .
+```
+
+## Quick Start
+
+```bash
+# Configure your API key
+dcp config set api_key YOUR_API_KEY
+dcp config set base_url https://api.decompressed.io
+
+# List your datasets
+dcp datasets list
+
+# Get dataset info
+dcp datasets info my-dataset
+
+# Version control commands
+dcp log my-dataset                    # Show version history
+dcp checkout my-dataset --version 3   # Pin to version 3
+dcp commit my-dataset -m "Added data" # Create new version
+dcp tag my-dataset v3 production      # Tag version as 'production'
+dcp diff my-dataset 2 3               # Compare versions
+
+# Data commands
+dcp pull my-dataset -o ./data/        # Download dataset
+dcp push ./vectors.npy my-dataset     # Upload/append vectors
+```
+
+## Commands
+
+### Configuration
+- `dcp config set <key> <value>` - Set config value
+- `dcp config get <key>` - Get config value
+- `dcp config list` - List all config
+
+### Datasets
+- `dcp datasets list` - List all datasets
+- `dcp datasets info <dataset>` - Show dataset details
+- `dcp datasets delete <dataset>` - Delete a dataset
+
+### Versioning
+- `dcp log <dataset>` - Show version history
+- `dcp checkout <dataset> --version <n>` - Pin to specific version
+- `dcp commit <dataset> -m <message>` - Commit pending changes
+- `dcp tag <dataset> <version> <name>` - Create named ref
+- `dcp diff <dataset> <v1> <v2>` - Compare two versions
+
+### Data
+- `dcp pull <dataset> -o <path>` - Download dataset vectors
+- `dcp push <file> <dataset>` - Upload/append vectors
+
+## Configuration
+
+Config is stored in `~/.decompressed/config.json`:
+
+```json
+{
+  "api_key": "dcp_xxx",
+  "base_url": "https://api.decompressed.io"
+}
+```

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+src/decompressed_cli/__init__.py
+src/decompressed_cli/config.py
+src/decompressed_cli/main.py
+src/decompressed_cli.egg-info/PKG-INFO
+src/decompressed_cli.egg-info/SOURCES.txt
+src/decompressed_cli.egg-info/dependency_links.txt
+src/decompressed_cli.egg-info/entry_points.txt
+src/decompressed_cli.egg-info/requires.txt
+src/decompressed_cli.egg-info/top_level.txt
+src/decompressed_cli/commands/__init__.py
+src/decompressed_cli/commands/config_cmd.py
+src/decompressed_cli/commands/data_cmd.py
+src/decompressed_cli/commands/datasets_cmd.py
+src/decompressed_cli/commands/versions_cmd.py

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dcp = decompressed_cli.main:app

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/requires.txt

@@ -0,0 +1,7 @@
+typer>=0.9.0
+rich>=13.0.0
+decompressed-sdk>=0.1.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0

decompressed_cli-0.1.0/src/decompressed_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+decompressed_cli