bubble-analysis 0.2.0__py3-none-any.whl

bubble/__init__.py

@@ -0,0 +1,3 @@
+"""Bubble: Exception flow analysis for Python codebases."""
+
+__version__ = "0.2.0"

bubble/cache.py

@@ -0,0 +1,207 @@
+"""File-level caching for extraction results."""
+
+from __future__ import annotations
+
+import hashlib
+import sqlite3
+from dataclasses import asdict
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import msgpack  # type: ignore[import-untyped]
+
+from bubble import __version__
+from bubble.models import (
+    CallSite,
+    CatchSite,
+    ClassDef,
+    Entrypoint,
+    FunctionDef,
+    GlobalHandler,
+    ImportInfo,
+    RaiseSite,
+)
+
+if TYPE_CHECKING:
+    from bubble.extractor import FileExtraction
+
+CACHE_VERSION = "3"
+CACHE_FILENAME = "cache.sqlite"
+
+
+class FileCache:
+    """SQLite-backed cache for file extraction results."""
+
+    def __init__(self, cache_dir: Path) -> None:
+        self.cache_dir = cache_dir
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = cache_dir / CACHE_FILENAME
+        self.db = self._open_db()
+
+    def _open_db(self) -> sqlite3.Connection:
+        db = sqlite3.connect(self.db_path, check_same_thread=False)
+        db.execute("PRAGMA journal_mode=WAL")
+        db.execute("PRAGMA synchronous=NORMAL")
+
+        db.executescript("""
+            CREATE TABLE IF NOT EXISTS cache_meta (
+                key TEXT PRIMARY KEY,
+                value TEXT
+            );
+            CREATE TABLE IF NOT EXISTS file_cache (
+                file_path TEXT PRIMARY KEY,
+                mtime_ns INTEGER,
+                size INTEGER,
+                content_hash TEXT,
+                extraction BLOB
+            );
+            CREATE INDEX IF NOT EXISTS idx_file_cache_mtime ON file_cache(mtime_ns);
+        """)
+
+        if not self._validate_version(db):
+            self._clear(db)
+            self._set_version(db)
+
+        return db
+
+    def _validate_version(self, db: sqlite3.Connection) -> bool:
+        row = db.execute("SELECT value FROM cache_meta WHERE key = 'version'").fetchone()
+        if row is None or row[0] != CACHE_VERSION:
+            return False
+
+        row = db.execute("SELECT value FROM cache_meta WHERE key = 'flow_version'").fetchone()
+        if row is None or row[0] != __version__:
+            return False
+
+        return True
+
+    def _set_version(self, db: sqlite3.Connection) -> None:
+        db.execute(
+            "INSERT OR REPLACE INTO cache_meta (key, value) VALUES ('version', ?)",
+            (CACHE_VERSION,),
+        )
+        db.execute(
+            "INSERT OR REPLACE INTO cache_meta (key, value) VALUES ('flow_version', ?)",
+            (__version__,),
+        )
+        db.commit()
+
+    def _clear(self, db: sqlite3.Connection) -> None:
+        db.execute("DELETE FROM file_cache")
+        db.execute("DELETE FROM cache_meta")
+        db.commit()
+
+    def get(self, file_path: Path) -> FileExtraction | None:
+        """Get cached extraction if still valid."""
+        try:
+            stat = file_path.stat()
+        except OSError:
+            return None
+
+        row = self.db.execute(
+            "SELECT mtime_ns, size, extraction FROM file_cache WHERE file_path = ?",
+            (str(file_path),),
+        ).fetchone()
+
+        if row is None:
+            return None
+
+        cached_mtime, cached_size, extraction_blob = row
+        if stat.st_mtime_ns != cached_mtime or stat.st_size != cached_size:
+            return None
+
+        return self._deserialize(extraction_blob)
+
+    def put(self, file_path: Path, extraction: FileExtraction) -> None:
+        """Cache an extraction result."""
+        try:
+            stat = file_path.stat()
+            content_hash = hashlib.sha256(file_path.read_bytes()).hexdigest()
+        except OSError:
+            return
+
+        self.db.execute(
+            """INSERT OR REPLACE INTO file_cache
+               (file_path, mtime_ns, size, content_hash, extraction)
+               VALUES (?, ?, ?, ?, ?)""",
+            (
+                str(file_path),
+                stat.st_mtime_ns,
+                stat.st_size,
+                content_hash,
+                self._serialize(extraction),
+            ),
+        )
+        self.db.commit()
+
+    def _serialize(self, extraction: FileExtraction) -> bytes:
+        def class_to_dict(c: ClassDef) -> dict[str, Any]:
+            d = asdict(c)
+            d["abstract_methods"] = list(c.abstract_methods)
+            return d
+
+        data = {
+            "functions": [asdict(f) for f in extraction.functions],
+            "classes": [class_to_dict(c) for c in extraction.classes],
+            "raise_sites": [asdict(r) for r in extraction.raise_sites],
+            "catch_sites": [asdict(c) for c in extraction.catch_sites],
+            "call_sites": [asdict(c) for c in extraction.call_sites],
+            "imports": [asdict(i) for i in extraction.imports],
+            "entrypoints": [asdict(e) for e in extraction.entrypoints],
+            "global_handlers": [asdict(g) for g in extraction.global_handlers],
+            "import_map": extraction.import_map,
+            "return_types": extraction.return_types,
+            "detected_frameworks": list(extraction.detected_frameworks),
+        }
+        return msgpack.packb(data)  # type: ignore[no-any-return]
+
+    def _deserialize(self, blob: bytes) -> FileExtraction:
+        """Deserialize msgpack blob to FileExtraction. Types from msgpack are dynamic."""
+        from bubble.extractor import FileExtraction as FE
+
+        raw: Any = msgpack.unpackb(blob)
+        data: dict[str, list[dict[str, Any]] | dict[str, str]] = raw
+        result = FE()
+
+        funcs: list[dict[str, Any]] = data["functions"]  # type: ignore[assignment]
+        result.functions = [FunctionDef(**f) for f in funcs]
+
+        classes: list[dict[str, Any]] = data["classes"]  # type: ignore[assignment]
+        for c in classes:
+            if "abstract_methods" in c:
+                c["abstract_methods"] = set(c["abstract_methods"])
+        result.classes = [ClassDef(**c) for c in classes]
+
+        raises: list[dict[str, Any]] = data["raise_sites"]  # type: ignore[assignment]
+        result.raise_sites = [RaiseSite(**r) for r in raises]
+
+        catches: list[dict[str, Any]] = data["catch_sites"]  # type: ignore[assignment]
+        result.catch_sites = [CatchSite(**c) for c in catches]
+
+        calls: list[dict[str, Any]] = data["call_sites"]  # type: ignore[assignment]
+        result.call_sites = [CallSite(**c) for c in calls]
+
+        imports: list[dict[str, Any]] = data["imports"]  # type: ignore[assignment]
+        result.imports = [ImportInfo(**i) for i in imports]
+
+        eps: list[dict[str, Any]] = data["entrypoints"]  # type: ignore[assignment]
+        result.entrypoints = [Entrypoint(**e) for e in eps]
+
+        handlers: list[dict[str, Any]] = data["global_handlers"]  # type: ignore[assignment]
+        result.global_handlers = [GlobalHandler(**g) for g in handlers]
+
+        result.import_map = data["import_map"]  # type: ignore[assignment]
+        result.return_types = data["return_types"]  # type: ignore[assignment]
+        result.detected_frameworks = set(data.get("detected_frameworks", []))  # type: ignore[arg-type]
+
+        return result
+
+    def stats(self) -> dict[str, int]:
+        """Return cache statistics."""
+        count = self.db.execute("SELECT COUNT(*) FROM file_cache").fetchone()[0]
+        size = self.db_path.stat().st_size if self.db_path.exists() else 0
+        return {"file_count": count, "size_bytes": size}
+
+    def close(self) -> None:
+        """Close the database connection."""
+        self.db.close()

bubble/cli.py

@@ -0,0 +1,470 @@
+"""Command-line interface for bubble analysis.
+
+This module handles argument parsing only. Business logic lives in queries.py,
+output formatting lives in formatters.py.
+"""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from bubble import formatters, queries, timing
+from bubble.enums import OutputFormat, ResolutionMode
+from bubble.extractor import extract_from_directory
+from bubble.models import ProgramModel
+
+HELP_TEXT = """Exception flow analysis for Python codebases.
+
+**Quick start:**
+```
+bubble flask audit              # Check Flask routes for escaping exceptions
+bubble fastapi audit            # Check FastAPI routes for escaping exceptions
+bubble cli audit                # Check CLI scripts for escaping exceptions
+bubble escapes <function>       # Deep dive into one function
+```
+
+**Typical workflow:**
+```
+bubble flask entrypoints        # See what Flask routes exist
+bubble flask audit              # Find which have uncaught exceptions
+bubble escapes <function>       # Investigate a specific one
+bubble trace <function>         # Visualize the call tree
+```
+
+**Core commands (framework-agnostic):**
+```
+bubble raises <Exception>       # Where is this raised?
+bubble escapes <function>       # What can escape from this function?
+bubble callers <function>       # Who calls this?
+bubble catches <Exception>      # Where is this caught?
+bubble trace <function>         # Call tree visualization
+bubble exceptions               # Exception hierarchy
+bubble stats                    # Codebase statistics
+```
+
+**Framework-specific commands:**
+```
+bubble flask audit/entrypoints/routes-to
+bubble fastapi audit/entrypoints/routes-to
+bubble cli audit/entrypoints/scripts-to
+```
+
+**All commands support:** `-f json` for structured output
+"""
+
+app = typer.Typer(
+    name="bubble",
+    help=HELP_TEXT,
+    no_args_is_help=True,
+    rich_markup_mode="markdown",
+)
+
+console = Console()
+
+
+@app.callback()
+def main_callback(
+    enable_timing: Annotated[
+        bool,
+        typer.Option(
+            "--timing",
+            help="Show timing breakdown for performance analysis",
+        ),
+    ] = False,
+) -> None:
+    """Flow: Exception flow analysis for Python codebases."""
+    if enable_timing:
+        timing.enable(console)
+
+
+def _register_integration_subcommands() -> None:
+    """Register integration CLI subcommands."""
+    from bubble.integrations import get_registered_integrations, load_builtin_integrations
+
+    load_builtin_integrations()
+
+    for integration in get_registered_integrations():
+        app.add_typer(integration.cli_app, name=integration.name)
+
+
+_register_integration_subcommands()
+
+
+def build_model(directory: Path, use_cache: bool = True) -> ProgramModel:
+    """Build the program model from a directory."""
+    with console.status(f"[bold blue]Analyzing[/bold blue] {directory.name}/..."):
+        return extract_from_directory(directory, use_cache=use_cache)
+
+
+@app.command()
+def raises(
+    exception_type: Annotated[str, typer.Argument(help="Exception type to search for")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    include_subclasses: Annotated[
+        bool, typer.Option("--include-subclasses", "-s", help="Include subclasses")
+    ] = False,
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Find all places where an exception is raised."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_raises(model, exception_type, include_subclasses)
+    formatters.raises(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def exceptions(
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """List the exception hierarchy in the codebase."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_exceptions(model)
+    formatters.exceptions(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def stats(
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Show statistics about the codebase."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.get_stats(model)
+    formatters.stats(result, OutputFormat(output_format), console)
+
+
+@app.command()
+def callers(
+    function_name: Annotated[str, typer.Argument(help="Function name to find callers of")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    show_resolution: Annotated[
+        bool, typer.Option("--show-resolution", "-r", help="Show resolution details")
+    ] = False,
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Find all places where a function is called."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_callers(model, function_name)
+    formatters.callers(result, OutputFormat(output_format), directory, console, show_resolution)
+
+
+@app.command()
+def escapes(
+    function_name: Annotated[str, typer.Argument(help="Function or route to analyze")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+    strict: Annotated[
+        bool, typer.Option("--strict", help="High precision - only resolved calls")
+    ] = False,
+    aggressive: Annotated[
+        bool, typer.Option("--aggressive", help="High recall - include fuzzy matches")
+    ] = False,
+) -> None:
+    """Show which exceptions can escape from a function.
+
+    This is the core (framework-agnostic) version. For framework-aware auditing,
+    use the integration commands (e.g., flow flask audit).
+    """
+    from bubble.config import load_config
+
+    directory = directory.resolve()
+    config = load_config(directory)
+
+    if strict:
+        resolution_mode = ResolutionMode.STRICT
+    elif aggressive:
+        resolution_mode = ResolutionMode.AGGRESSIVE
+    else:
+        resolution_mode = ResolutionMode(config.resolution_mode)
+
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_escapes(model, function_name, resolution_mode=resolution_mode)
+    formatters.escapes(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def catches(
+    exception_type: Annotated[str, typer.Argument(help="Exception type to search for")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    include_subclasses: Annotated[
+        bool, typer.Option("--include-subclasses", "-s", help="Include subclasses")
+    ] = False,
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Find all places where an exception type is caught."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_catches(model, exception_type, include_subclasses)
+    formatters.catches(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def cache(
+    action: Annotated[str, typer.Argument(help="Action: clear or stats")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to manage cache for")
+    ] = Path("."),
+) -> None:
+    """Manage the extraction cache."""
+    from bubble.cache import FileCache
+
+    directory = directory.resolve()
+    cache_dir = directory / ".flow"
+    cache_file = cache_dir / "cache.sqlite"
+
+    if action == "clear":
+        if cache_file.exists():
+            cache_file.unlink()
+            console.print("[green]Cache cleared[/green]")
+        else:
+            console.print("[yellow]No cache to clear[/yellow]")
+
+    elif action == "stats":
+        if not cache_file.exists():
+            console.print("[yellow]No cache exists[/yellow]")
+            return
+
+        fc = FileCache(cache_dir)
+        stats_data = fc.stats()
+        fc.close()
+        formatters.cache_stats(stats_data["file_count"], stats_data["size_bytes"], console)
+
+    else:
+        console.print(f"[red]Unknown action: {action}[/red]")
+        console.print("Valid actions: clear, stats")
+        raise typer.Exit(1)
+
+
+@app.command()
+def trace(
+    function_name: Annotated[str, typer.Argument(help="Function or route to trace")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    depth: Annotated[int, typer.Option("--depth", help="Maximum call depth")] = 10,
+    show_all: Annotated[
+        bool, typer.Option("--all", "-a", help="Show all calls, not just exception-raising paths")
+    ] = False,
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Visualize exception flow as a call tree."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.trace_function(model, function_name, depth, show_all)
+    formatters.trace(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def subclasses(
+    class_name: Annotated[str, typer.Argument(help="Base class name to find subclasses of")],
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to analyze")
+    ] = Path("."),
+    output_format: Annotated[str, typer.Option("--format", "-f", help="Output format")] = "text",
+    no_cache: Annotated[bool, typer.Option("--no-cache", help="Disable caching")] = False,
+) -> None:
+    """Show all subclasses of a class and their abstract method implementations."""
+    directory = directory.resolve()
+    model = build_model(directory, use_cache=not no_cache)
+    result = queries.find_subclasses(model, class_name)
+    formatters.subclasses(result, OutputFormat(output_format), directory, console)
+
+
+@app.command()
+def init(
+    directory: Annotated[
+        Path, typer.Option("--directory", "-d", help="Directory to initialize")
+    ] = Path("."),
+) -> None:
+    """Initialize .flow/ directory with detector templates."""
+    directory = directory.resolve()
+    flow_dir = directory / ".flow"
+    detectors_dir = flow_dir / "detectors"
+
+    if flow_dir.exists():
+        console.print(f"[yellow].flow/ directory already exists at {flow_dir}[/yellow]")
+        console.print("[dim]Delete it first if you want to reinitialize.[/dim]")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]Initializing flow analysis for {directory.name}/[/bold]\n")
+
+    with console.status("[bold blue]Analyzing codebase patterns...[/bold blue]"):
+        model = build_model(directory, use_cache=False)
+
+    result = queries.get_init_info(model, directory.name)
+    formatters.init_result(result, console)
+
+    flow_dir.mkdir(parents=True, exist_ok=True)
+    detectors_dir.mkdir(parents=True, exist_ok=True)
+
+    config_content = f"""# Flow analysis configuration for {directory.name}
+version: "0.1"
+
+# Frameworks detected (used for default detectors)
+frameworks:
+{chr(10).join(f"  - {f.lower()}" for f in result.frameworks_detected) if result.frameworks_detected else "  # none detected"}
+
+# Directories to exclude from analysis
+exclude:
+  - __pycache__
+  - .venv
+  - venv
+  - site-packages
+  - node_modules
+  - .git
+  - dist
+  - build
+  - tests
+  - test
+
+# Base exception classes to track (add your custom exceptions here)
+exception_bases:
+  - Exception
+"""
+
+    (flow_dir / "config.yaml").write_text(config_content)
+    console.print("  [green]Created[/green] .flow/config.yaml")
+
+    example_detector = '''"""Example custom detector for project-specific patterns."""
+
+from bubble.protocols import EntrypointDetector
+from bubble.models import Entrypoint
+
+
+class ExampleCeleryTaskDetector(EntrypointDetector):
+    """Example: Detects Celery task decorators as entrypoints."""
+
+    def detect(self, source: str, file_path: str) -> list[Entrypoint]:
+        return []
+'''
+
+    (detectors_dir / "_example.py").write_text(example_detector)
+    console.print("  [green]Created[/green] .flow/detectors/_example.py")
+
+    readme_content = """# Custom Detectors
+
+Create Python files here to detect project-specific patterns.
+See _example.py for a template.
+"""
+
+    (detectors_dir / "README.md").write_text(readme_content)
+    console.print("  [green]Created[/green] .flow/detectors/README.md")
+
+    console.print()
+    console.print("[bold green]Initialization complete![/bold green]")
+    console.print()
+    console.print("[dim]Next steps:[/dim]")
+    console.print("  1. Review .flow/config.yaml")
+    console.print(
+        "  2. Run 'flow flask entrypoints' or 'flow fastapi entrypoints' to verify detection"
+    )
+    console.print()
+
+
+@app.command()
+def stubs(
+    action: Annotated[str, typer.Argument(help="Action: list, init, or validate")],
+    library: Annotated[str | None, typer.Argument(help="Library name for init action")] = None,
+    directory: Annotated[Path, typer.Option("--directory", "-d", help="Project directory")] = Path(
+        "."
+    ),
+) -> None:
+    """Manage exception stubs for external libraries."""
+    import shutil
+
+    from bubble.stubs import load_stubs, validate_stub_file
+
+    directory = directory.resolve()
+    builtin_dir = Path(__file__).parent / "stubs"
+    user_dir = directory / ".flow" / "stubs"
+
+    if action == "list":
+        stub_library = load_stubs(directory)
+        if not stub_library.stubs:
+            console.print("[yellow]No stubs loaded[/yellow]")
+            console.print()
+            console.print("[dim]Built-in stubs available:[/dim]")
+            if builtin_dir.exists():
+                for yaml_file in sorted(builtin_dir.glob("*.yaml")):
+                    console.print(f"  - {yaml_file.stem}")
+            return
+
+        console.print("\n[bold]Loaded exception stubs:[/bold]\n")
+        for module, functions in sorted(stub_library.stubs.items()):
+            exc_count = sum(len(excs) for excs in functions.values())
+            console.print(
+                f"  [cyan]{module}[/cyan]: {len(functions)} functions, {exc_count} exceptions"
+            )
+        console.print()
+
+    elif action == "init":
+        if not library:
+            console.print("[red]Library name required for init action[/red]")
+            console.print("[dim]Example: flow stubs init requests[/dim]")
+            raise typer.Exit(1)
+
+        source_file = builtin_dir / f"{library}.yaml"
+        if not source_file.exists():
+            console.print(f"[red]No built-in stub for '{library}'[/red]")
+            console.print("[dim]Available stubs:[/dim]")
+            if builtin_dir.exists():
+                for yaml_file in sorted(builtin_dir.glob("*.yaml")):
+                    console.print(f"  - {yaml_file.stem}")
+            raise typer.Exit(1)
+
+        user_dir.mkdir(parents=True, exist_ok=True)
+        dest_file = user_dir / f"{library}.yaml"
+        shutil.copy(source_file, dest_file)
+        console.print(f"[green]Copied {library}.yaml to .flow/stubs/[/green]")
+        console.print("[dim]Edit this file to customize exception declarations.[/dim]")
+
+    elif action == "validate":
+        errors_found = False
+        for stub_dir in [builtin_dir, user_dir]:
+            if stub_dir.exists():
+                for yaml_file in stub_dir.glob("*.yaml"):
+                    errors = validate_stub_file(yaml_file)
+                    if errors:
+                        errors_found = True
+                        console.print(f"[red]Errors in {yaml_file.name}:[/red]")
+                        for error in errors:
+                            console.print(f"  - {error}")
+                    else:
+                        console.print(f"[green]v[/green] {yaml_file.name}")
+
+        if not errors_found:
+            console.print("\n[green]All stub files are valid[/green]")
+
+    else:
+        console.print(f"[red]Unknown action: {action}[/red]")
+        console.print("Valid actions: list, init, validate")
+        raise typer.Exit(1)
+
+
+if __name__ == "__main__":
+    app()