recce-cloud 1.32.0__py3-none-any.whl → 1.33.1__py3-none-any.whl

recce_cloud/commands/__init__.py

@@ -0,0 +1 @@
+# CLI commands - presentation layer

recce_cloud/commands/diagnostics.py

@@ -0,0 +1,174 @@
+"""
+Diagnostics CLI commands.
+
+This module contains CLI presentation logic for diagnostic commands,
+delegating business logic to the diagnostic service.
+"""
+
+import json
+import sys
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+
+from recce_cloud.services.diagnostic_service import (
+    CheckStatus,
+    DiagnosticResults,
+    DiagnosticService,
+)
+
+
+class DiagnosticRenderer:
+    """Renders diagnostic results to the console."""
+
+    def __init__(self, console: Console):
+        self.console = console
+
+    def render_header(self) -> None:
+        """Render the diagnostic header."""
+        header = Panel(
+            "[bold]🩺 Recce Doctor[/bold]\n[dim]Checking your Recce Cloud setup...[/dim]",
+            expand=False,
+            padding=(0, 3),
+        )
+        self.console.print()
+        self.console.print(header)
+        self.console.print()
+        self.console.print("━" * 65)
+        self.console.print()
+
+    def render_login_check(self, results: DiagnosticResults) -> None:
+        """Render the login status check."""
+        self.console.print("[bold]1. Login Status[/bold] ($ recce-cloud login)")
+        check = results.login
+
+        if check.passed:
+            email = check.details.get("email", "Unknown")
+            self.console.print(f"[green]✓[/green] Logged in as [cyan]{email}[/cyan]")
+        else:
+            self._render_failure(check)
+
+        self.console.print()
+
+    def render_project_binding_check(self, results: DiagnosticResults) -> None:
+        """Render the project binding check."""
+        self.console.print("[bold]2. Project Binding[/bold] ($ recce-cloud init)")
+        check = results.project_binding
+
+        if check.passed:
+            org = check.details.get("org")
+            project = check.details.get("project")
+            source = check.details.get("source")
+            source_label = " (via env vars)" if source == "env_vars" else ""
+            self.console.print(f"[green]✓[/green] Bound to [cyan]{org}/{project}[/cyan]{source_label}")
+        else:
+            self._render_failure(check)
+
+        self.console.print()
+
+    def render_production_check(self, results: DiagnosticResults) -> None:
+        """Render the production metadata check."""
+        self.console.print("[bold]3. Production Metadata[/bold]")
+        check = results.production_metadata
+
+        if check.status == CheckStatus.SKIP:
+            self.console.print(f"[yellow]⚠[/yellow] {check.message}")
+        elif check.passed:
+            session_name = check.details.get("session_name", "(unnamed)")
+            relative_time = check.details.get("relative_time")
+            time_str = f" (uploaded {relative_time})" if relative_time else ""
+            self.console.print(f'[green]✓[/green] Found production session "[cyan]{session_name}[/cyan]"{time_str}')
+        else:
+            self._render_failure(check)
+
+        self.console.print()
+
+    def render_dev_session_check(self, results: DiagnosticResults) -> None:
+        """Render the dev session check."""
+        self.console.print("[bold]4. Dev Session[/bold]")
+        check = results.dev_session
+
+        if check.status == CheckStatus.SKIP:
+            self.console.print(f"[yellow]⚠[/yellow] {check.message}")
+        elif check.passed:
+            session_name = check.details.get("session_name", "(unnamed)")
+            relative_time = check.details.get("relative_time")
+            time_str = f" (uploaded {relative_time})" if relative_time else ""
+            self.console.print(f'[green]✓[/green] Found dev session "[cyan]{session_name}[/cyan]"{time_str}')
+        else:
+            self._render_failure(check)
+
+    def render_summary(self, results: DiagnosticResults) -> None:
+        """Render the summary section."""
+        self.console.print()
+        self.console.print("━" * 65)
+        self.console.print()
+
+        if results.all_passed:
+            self.console.print("[green]✓ All checks passed![/green] Your Recce setup is ready.")
+            self.console.print()
+            self.console.print("Next step:")
+            self.console.print("  $ recce-cloud review --session-name <session_name>")
+        else:
+            self.console.print(
+                f"[yellow]⚠ {results.passed_count}/{results.total_count} checks passed.[/yellow] "
+                "See above for remediation steps."
+            )
+
+    def render_all(self, results: DiagnosticResults) -> None:
+        """Render all diagnostic results."""
+        self.render_header()
+        self.render_login_check(results)
+        self.render_project_binding_check(results)
+        self.render_production_check(results)
+        self.render_dev_session_check(results)
+        self.render_summary(results)
+
+    def _render_failure(self, check) -> None:
+        """Render a failed check with its suggestion."""
+        self.console.print(f"[red]✗[/red] {check.message}")
+        if check.suggestion:
+            self.console.print()
+            self.console.print("[dim]→ To fix:[/dim]")
+            for line in check.suggestion.split("\n"):
+                self.console.print(f"  {line}")
+
+
+@click.command()
+@click.option(
+    "--json",
+    "output_json",
+    is_flag=True,
+    help="Output in JSON format for scripting",
+)
+def doctor(output_json: bool) -> None:
+    """
+    Check Recce Cloud setup and configuration.
+
+    Validates login status, project binding, and session availability.
+    Provides actionable suggestions when issues are found.
+
+    \b
+    Examples:
+      # Check setup status
+      recce-cloud doctor
+
+      # Machine-readable output
+      recce-cloud doctor --json
+    """
+    console = Console()
+
+    # Run diagnostic checks
+    service = DiagnosticService()
+    results = service.run_all_checks()
+
+    # Output results
+    if output_json:
+        console.print(json.dumps(results.to_dict(), indent=2, default=str))
+    else:
+        renderer = DiagnosticRenderer(console)
+        renderer.render_all(results)
+
+    # Exit with appropriate code
+    sys.exit(0 if results.all_passed else 1)

recce_cloud/config/__init__.py

@@ -0,0 +1,19 @@
+"""
+Configuration module for Recce Cloud CLI.
+
+This module provides project binding and configuration resolution.
+"""
+
+from recce_cloud.config.project_config import (
+    clear_project_binding,
+    get_project_binding,
+    save_project_binding,
+)
+from recce_cloud.config.resolver import resolve_config
+
+__all__ = [
+    "clear_project_binding",
+    "get_project_binding",
+    "resolve_config",
+    "save_project_binding",
+]

recce_cloud/config/project_config.py

@@ -0,0 +1,187 @@
+"""
+Project configuration management for .recce/config.
+
+This module manages local project binding stored in the project directory.
+"""
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+RECCE_CONFIG_DIR = ".recce"
+RECCE_CONFIG_FILE = "config"
+
+
+def get_config_path(project_dir: Optional[str] = None) -> Path:
+    """
+    Get the path to the local config file.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        Path to .recce/config file.
+    """
+    base_dir = Path(project_dir) if project_dir else Path.cwd()
+    return base_dir / RECCE_CONFIG_DIR / RECCE_CONFIG_FILE
+
+
+def get_config_dir(project_dir: Optional[str] = None) -> Path:
+    """
+    Get the path to the .recce directory.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        Path to .recce directory.
+    """
+    base_dir = Path(project_dir) if project_dir else Path.cwd()
+    return base_dir / RECCE_CONFIG_DIR
+
+
+def load_config(project_dir: Optional[str] = None) -> Dict[str, Any]:
+    """
+    Load configuration from .recce/config.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        Configuration dictionary, or empty dict if file doesn't exist.
+    """
+    config_path = get_config_path(project_dir)
+    if not config_path.exists():
+        return {}
+
+    with open(config_path, "r", encoding="utf-8") as f:
+        config = yaml.safe_load(f)
+        return config if config else {}
+
+
+def save_config(config: Dict[str, Any], project_dir: Optional[str] = None) -> None:
+    """
+    Save configuration to .recce/config.
+
+    Args:
+        config: Configuration dictionary to save.
+        project_dir: Project directory path. Defaults to current directory.
+    """
+    config_dir = get_config_dir(project_dir)
+    config_path = get_config_path(project_dir)
+
+    # Ensure .recce directory exists
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    with open(config_path, "w", encoding="utf-8") as f:
+        yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+
+def get_project_binding(project_dir: Optional[str] = None) -> Optional[Dict[str, Any]]:
+    """
+    Get the current project binding from .recce/config.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        Dictionary with org, project, bound_at, bound_by fields,
+        or None if not bound.
+    """
+    config = load_config(project_dir)
+    cloud_config = config.get("cloud", {})
+
+    if not cloud_config.get("org") or not cloud_config.get("project"):
+        return None
+
+    return {
+        "org": cloud_config.get("org"),
+        "project": cloud_config.get("project"),
+        "bound_at": cloud_config.get("bound_at"),
+        "bound_by": cloud_config.get("bound_by"),
+    }
+
+
+def save_project_binding(
+    org: str,
+    project: str,
+    bound_by: Optional[str] = None,
+    project_dir: Optional[str] = None,
+) -> None:
+    """
+    Save project binding to .recce/config.
+
+    Args:
+        org: Organization name/slug.
+        project: Project name/slug.
+        bound_by: Email of user who created the binding.
+        project_dir: Project directory path. Defaults to current directory.
+    """
+    config = load_config(project_dir)
+
+    config["version"] = 1
+    config["cloud"] = {
+        "org": org,
+        "project": project,
+        "bound_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    if bound_by:
+        config["cloud"]["bound_by"] = bound_by
+
+    save_config(config, project_dir)
+
+
+def clear_project_binding(project_dir: Optional[str] = None) -> bool:
+    """
+    Clear project binding from .recce/config.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        True if binding was cleared, False if no binding existed.
+    """
+    config = load_config(project_dir)
+
+    if "cloud" not in config:
+        return False
+
+    del config["cloud"]
+    save_config(config, project_dir)
+    return True
+
+
+def add_to_gitignore(project_dir: Optional[str] = None) -> bool:
+    """
+    Add .recce/ to .gitignore if not already present.
+
+    Args:
+        project_dir: Project directory path. Defaults to current directory.
+
+    Returns:
+        True if .gitignore was modified, False otherwise.
+    """
+    base_dir = Path(project_dir) if project_dir else Path.cwd()
+    gitignore_path = base_dir / ".gitignore"
+
+    # Check if .recce/ is already in .gitignore
+    if gitignore_path.exists():
+        with open(gitignore_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            if ".recce/" in content or ".recce" in content:
+                return False
+
+    # Append .recce/ to .gitignore
+    with open(gitignore_path, "a", encoding="utf-8") as f:
+        if gitignore_path.exists():
+            # Check if file ends with newline
+            with open(gitignore_path, "r", encoding="utf-8") as rf:
+                content = rf.read()
+                if content and not content.endswith("\n"):
+                    f.write("\n")
+        f.write("\n# Recce Cloud local config\n.recce/\n")
+
+    return True

recce_cloud/config/resolver.py

@@ -0,0 +1,137 @@
+"""
+Configuration resolver for Recce Cloud CLI.
+
+Resolves org/project configuration from multiple sources with priority:
+1. CLI flags (--org, --project)
+2. Environment variables (RECCE_ORG, RECCE_PROJECT)
+3. Local config file (.recce/config)
+4. Error (no configuration found)
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+from recce_cloud.config.project_config import get_project_binding
+
+
+@dataclass
+class ResolvedConfig:
+    """Resolved configuration with source information."""
+
+    org: str
+    project: str
+    source: str  # "cli", "env", "config"
+
+
+class ConfigurationError(Exception):
+    """Raised when configuration cannot be resolved."""
+
+    pass
+
+
+def resolve_config(
+    cli_org: Optional[str] = None,
+    cli_project: Optional[str] = None,
+    project_dir: Optional[str] = None,
+) -> ResolvedConfig:
+    """
+    Resolve org/project configuration from multiple sources.
+
+    Priority order:
+    1. CLI flags (--org, --project) - highest priority
+    2. Environment variables (RECCE_ORG, RECCE_PROJECT)
+    3. Local config file (.recce/config)
+    4. Error if nothing found
+
+    Args:
+        cli_org: Organization from CLI flag.
+        cli_project: Project from CLI flag.
+        project_dir: Project directory for local config lookup.
+
+    Returns:
+        ResolvedConfig with org, project, and source.
+
+    Raises:
+        ConfigurationError: If org/project cannot be resolved.
+    """
+    # Priority 1: CLI flags
+    if cli_org and cli_project:
+        return ResolvedConfig(org=cli_org, project=cli_project, source="cli")
+
+    # Priority 2: Environment variables
+    env_org = os.environ.get("RECCE_ORG")
+    env_project = os.environ.get("RECCE_PROJECT")
+    if env_org and env_project:
+        return ResolvedConfig(org=env_org, project=env_project, source="env")
+
+    # Priority 3: Local config file
+    binding = get_project_binding(project_dir)
+    if binding:
+        return ResolvedConfig(
+            org=binding["org"],
+            project=binding["project"],
+            source="config",
+        )
+
+    # Priority 4: Error
+    raise ConfigurationError(
+        "No project configured. Run 'recce-cloud init' to bind this directory to a project, "
+        "or use --org and --project flags."
+    )
+
+
+def resolve_org(
+    cli_org: Optional[str] = None,
+    project_dir: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Resolve organization from multiple sources.
+
+    Args:
+        cli_org: Organization from CLI flag.
+        project_dir: Project directory for local config lookup.
+
+    Returns:
+        Organization name/slug, or None if not found.
+    """
+    if cli_org:
+        return cli_org
+
+    env_org = os.environ.get("RECCE_ORG")
+    if env_org:
+        return env_org
+
+    binding = get_project_binding(project_dir)
+    if binding:
+        return binding["org"]
+
+    return None
+
+
+def resolve_project(
+    cli_project: Optional[str] = None,
+    project_dir: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Resolve project from multiple sources.
+
+    Args:
+        cli_project: Project from CLI flag.
+        project_dir: Project directory for local config lookup.
+
+    Returns:
+        Project name/slug, or None if not found.
+    """
+    if cli_project:
+        return cli_project
+
+    env_project = os.environ.get("RECCE_PROJECT")
+    if env_project:
+        return env_project
+
+    binding = get_project_binding(project_dir)
+    if binding:
+        return binding["project"]
+
+    return None

recce_cloud/services/__init__.py

@@ -0,0 +1 @@
+# Services layer for business logic