scc-cli 1.5.3__py3-none-any.whl

scc_cli/commands/org/status_cmd.py

@@ -0,0 +1,157 @@
+"""Org status command for showing organization configuration status."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from rich.table import Table
+
+from ...cli_common import console, handle_errors
+from ...config import load_user_config
+from ...core.constants import CLI_VERSION
+from ...json_output import build_envelope
+from ...kinds import Kind
+from ...output_mode import json_output_mode, print_json, set_pretty_mode
+from ...remote import load_from_cache
+from ._builders import build_status_data
+
+
+@handle_errors
+def org_status_cmd(
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON envelope"),
+    pretty: bool = typer.Option(False, "--pretty", help="Pretty-print JSON (implies --json)"),
+) -> None:
+    """Show current organization configuration status.
+
+    Displays connection mode (standalone or organization), cache freshness,
+    version compatibility, and selected profile.
+
+    Examples:
+        scc org status
+        scc org status --json
+        scc org status --pretty
+    """
+    # --pretty implies --json
+    if pretty:
+        json_output = True
+        set_pretty_mode(True)
+
+    # Load configuration data
+    user_config = load_user_config()
+    org_config, cache_meta = load_from_cache()
+
+    # Build status data
+    status_data = build_status_data(user_config, org_config, cache_meta)
+
+    # JSON output mode
+    if json_output:
+        with json_output_mode():
+            envelope = build_envelope(Kind.ORG_STATUS, data=status_data)
+            print_json(envelope)
+            raise typer.Exit(0)
+
+    # Human-readable output
+    _render_status_human(status_data)
+    raise typer.Exit(0)
+
+
+def _render_status_human(status: dict[str, Any]) -> None:
+    """Render status data as human-readable Rich output.
+
+    Args:
+        status: Status data from build_status_data
+    """
+    # Mode header
+    mode = status["mode"]
+    if mode == "standalone":
+        console.print("\n[bold cyan]Organization Status[/bold cyan]")
+        console.print("  Mode: [yellow]Standalone[/yellow] (no organization configured)")
+        console.print("\n  [dim]Tip: Run 'scc setup' to connect to an organization[/dim]\n")
+        return
+
+    # Organization mode
+    console.print("\n[bold cyan]Organization Status[/bold cyan]")
+
+    # Create a table for organization info
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+
+    # Organization info
+    org = status.get("organization", {})
+    if org:
+        org_name = org.get("name") or "[not fetched]"
+        table.add_row("Organization", f"[bold]{org_name}[/bold]")
+        table.add_row("Source URL", org.get("source_url", "[not configured]"))
+
+    # Selected profile
+    profile = status.get("selected_profile")
+    if profile:
+        table.add_row("Selected Profile", f"[green]{profile}[/green]")
+    else:
+        table.add_row("Selected Profile", "[yellow]None[/yellow]")
+
+    # Available profiles
+    available = status.get("available_profiles", [])
+    if available:
+        table.add_row("Available Profiles", ", ".join(available))
+
+    console.print(table)
+
+    # Cache status
+    cache = status.get("cache")
+    if cache:
+        console.print("\n[bold]Cache Status[/bold]")
+        cache_table = Table(show_header=False, box=None, padding=(0, 2))
+        cache_table.add_column("Key", style="dim")
+        cache_table.add_column("Value")
+
+        if cache.get("valid"):
+            cache_table.add_row("Status", "[green]+ Fresh[/green]")
+        else:
+            cache_table.add_row("Status", "[yellow]! Expired[/yellow]")
+
+        if cache.get("fetched_at"):
+            cache_table.add_row("Fetched At", cache["fetched_at"])
+        if cache.get("expires_at"):
+            cache_table.add_row("Expires At", cache["expires_at"])
+
+        console.print(cache_table)
+    else:
+        console.print("\n[yellow]Cache:[/yellow] Not fetched yet")
+        console.print(
+            "  [dim]Run 'scc start' or 'scc doctor' to fetch the organization config[/dim]"
+        )
+
+    # Version compatibility
+    compat = status.get("version_compatibility")
+    if compat:
+        console.print("\n[bold]Version Compatibility[/bold]")
+        compat_table = Table(show_header=False, box=None, padding=(0, 2))
+        compat_table.add_column("Key", style="dim")
+        compat_table.add_column("Value")
+
+        if compat.get("compatible"):
+            compat_table.add_row("Status", "[green]+ Compatible[/green]")
+        else:
+            if compat.get("blocking_error"):
+                compat_table.add_row("Status", "[red]x Incompatible[/red]")
+                compat_table.add_row("Error", f"[red]{compat['blocking_error']}[/red]")
+            else:
+                compat_table.add_row("Status", "[yellow]! Warnings[/yellow]")
+
+        if compat.get("schema_version"):
+            compat_table.add_row("Schema Version", compat["schema_version"])
+        if compat.get("min_cli_version"):
+            compat_table.add_row("Min CLI Version", compat["min_cli_version"])
+        compat_table.add_row("Current CLI", compat.get("current_cli_version", CLI_VERSION))
+
+        # Show warnings if any
+        warnings = compat.get("warnings", [])
+        for warning in warnings:
+            console.print(f"  [yellow]! {warning}[/yellow]")
+
+        console.print(compat_table)
+
+    console.print()  # Final newline

scc_cli/commands/org/update_cmd.py

@@ -0,0 +1,330 @@
+"""Org update command for refreshing organization and team configs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+from ...cli_common import console, handle_errors
+from ...config import load_user_config
+from ...core.exit_codes import EXIT_CONFIG
+from ...json_output import build_envelope
+from ...kinds import Kind
+from ...marketplace.team_fetch import fetch_team_config
+from ...output_mode import json_output_mode, print_json, set_pretty_mode
+from ...panels import create_error_panel, create_success_panel, create_warning_panel
+from ...remote import load_org_config
+from ._builders import _parse_config_source, build_update_data
+
+
+@handle_errors
+def org_update_cmd(
+    team: str | None = typer.Option(
+        None, "--team", "-t", help="Refresh a specific federated team's config"
+    ),
+    all_teams: bool = typer.Option(
+        False, "--all-teams", "-a", help="Refresh all federated team configs"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    pretty: bool = typer.Option(False, "--pretty", help="Pretty-print JSON (implies --json)"),
+) -> None:
+    """Refresh organization config and optionally team configs.
+
+    By default, refreshes the organization config from its remote source.
+    With --team or --all-teams, also refreshes federated team configurations.
+
+    Examples:
+        scc org update              # Refresh org config only
+        scc org update --team dev   # Also refresh 'dev' team config
+        scc org update --all-teams  # Refresh all federated team configs
+    """
+    # --pretty implies --json
+    if pretty:
+        json_output = True
+        set_pretty_mode(True)
+
+    # Load user config
+    user_config = load_user_config()
+
+    # Check for standalone mode
+    is_standalone = user_config.get("standalone", False)
+    if is_standalone:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_UPDATE,
+                    data={"error": "Cannot update in standalone mode"},
+                    ok=False,
+                    errors=["CLI is running in standalone mode"],
+                )
+                print_json(envelope)
+            raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_error_panel(
+                "Standalone Mode",
+                "Cannot update organization config in standalone mode.",
+                hint="Use 'scc setup' to connect to an organization.",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Check for organization source
+    org_source = user_config.get("organization_source")
+    if not org_source:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_UPDATE,
+                    data={"error": "No organization source configured"},
+                    ok=False,
+                    errors=["No organization source configured"],
+                )
+                print_json(envelope)
+            raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_error_panel(
+                "No Organization",
+                "No organization source is configured.",
+                hint="Use 'scc setup' to connect to an organization.",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Force refresh org config
+    org_config = load_org_config(user_config, force_refresh=True)
+    if org_config is None:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_UPDATE,
+                    data=build_update_data(None),
+                    ok=False,
+                    errors=["Failed to fetch organization config"],
+                )
+                print_json(envelope)
+            raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_error_panel(
+                "Update Failed",
+                "Failed to fetch organization config from remote.",
+                hint="Check network connection and organization URL.",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Get profiles from org config
+    profiles = org_config.get("profiles", {})
+
+    # Handle --team option (single team update)
+    team_results: list[dict[str, Any]] | None = None
+    if team is not None:
+        # Validate team exists
+        if team not in profiles:
+            if json_output:
+                with json_output_mode():
+                    envelope = build_envelope(
+                        Kind.ORG_UPDATE,
+                        data=build_update_data(org_config),
+                        ok=False,
+                        errors=[f"Team '{team}' not found in organization config"],
+                    )
+                    print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+            console.print(
+                create_error_panel(
+                    "Team Not Found",
+                    f"Team '{team}' not found in organization config.",
+                    hint=f"Available teams: {', '.join(profiles.keys())}",
+                )
+            )
+            raise typer.Exit(EXIT_CONFIG)
+
+        profile = profiles[team]
+        config_source_dict = profile.get("config_source")
+
+        # Check if team is federated
+        if config_source_dict is None:
+            team_results = [{"team": team, "success": True, "inline": True}]
+            if json_output:
+                with json_output_mode():
+                    data = build_update_data(org_config, team_results)
+                    envelope = build_envelope(Kind.ORG_UPDATE, data=data)
+                    print_json(envelope)
+                raise typer.Exit(0)
+            console.print(
+                create_warning_panel(
+                    "Inline Team",
+                    f"Team '{team}' is not federated (inline config).",
+                    hint="Inline teams don't have external configs to refresh.",
+                )
+            )
+            raise typer.Exit(0)
+
+        # Fetch team config
+        try:
+            config_source = _parse_config_source(config_source_dict)
+            result = fetch_team_config(config_source, team)
+            if result.success:
+                team_results = [
+                    {
+                        "team": team,
+                        "success": True,
+                        "commit_sha": result.commit_sha,
+                    }
+                ]
+            else:
+                team_results = [
+                    {
+                        "team": team,
+                        "success": False,
+                        "error": result.error,
+                    }
+                ]
+                if json_output:
+                    with json_output_mode():
+                        data = build_update_data(org_config, team_results)
+                        envelope = build_envelope(
+                            Kind.ORG_UPDATE,
+                            data=data,
+                            ok=False,
+                            errors=[f"Failed to fetch team config: {result.error}"],
+                        )
+                        print_json(envelope)
+                    raise typer.Exit(EXIT_CONFIG)
+                console.print(
+                    create_error_panel(
+                        "Team Update Failed",
+                        f"Failed to fetch config for team '{team}'.",
+                        hint=str(result.error),
+                    )
+                )
+                raise typer.Exit(EXIT_CONFIG)
+        except Exception as e:
+            if json_output:
+                with json_output_mode():
+                    envelope = build_envelope(
+                        Kind.ORG_UPDATE,
+                        data=build_update_data(org_config),
+                        ok=False,
+                        errors=[f"Error parsing config source: {e}"],
+                    )
+                    print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+            console.print(create_error_panel("Config Error", f"Error parsing config source: {e}"))
+            raise typer.Exit(EXIT_CONFIG)
+
+    # Handle --all-teams option
+    elif all_teams:
+        team_results = []
+        federated_teams = [
+            (name, profile)
+            for name, profile in profiles.items()
+            if profile.get("config_source") is not None
+        ]
+
+        if not federated_teams:
+            team_results = []
+            if json_output:
+                with json_output_mode():
+                    data = build_update_data(org_config, team_results)
+                    envelope = build_envelope(Kind.ORG_UPDATE, data=data)
+                    print_json(envelope)
+                raise typer.Exit(0)
+            console.print(
+                create_warning_panel(
+                    "No Federated Teams",
+                    "No federated teams found in organization config.",
+                    hint="All teams use inline configuration.",
+                )
+            )
+            raise typer.Exit(0)
+
+        # Fetch all federated team configs
+        for team_name, profile in federated_teams:
+            config_source_dict = profile["config_source"]
+            try:
+                config_source = _parse_config_source(config_source_dict)
+                result = fetch_team_config(config_source, team_name)
+                if result.success:
+                    team_results.append(
+                        {
+                            "team": team_name,
+                            "success": True,
+                            "commit_sha": result.commit_sha,
+                        }
+                    )
+                else:
+                    team_results.append(
+                        {
+                            "team": team_name,
+                            "success": False,
+                            "error": result.error,
+                        }
+                    )
+            except Exception as e:
+                team_results.append(
+                    {
+                        "team": team_name,
+                        "success": False,
+                        "error": str(e),
+                    }
+                )
+
+    # Build output data
+    data = build_update_data(org_config, team_results)
+
+    # JSON output
+    if json_output:
+        with json_output_mode():
+            # Determine overall success
+            has_team_failures = team_results is not None and any(
+                not t.get("success") for t in team_results
+            )
+            envelope = build_envelope(
+                Kind.ORG_UPDATE,
+                data=data,
+                ok=not has_team_failures,
+            )
+            print_json(envelope)
+        raise typer.Exit(0)
+
+    # Human-readable output
+    org_data = org_config.get("organization", {})
+    org_name = org_data.get("name", "Unknown")
+
+    if team_results is None:
+        # Org-only update
+        console.print(
+            create_success_panel(
+                "Organization Updated",
+                {
+                    "Organization": org_name,
+                    "Status": "Refreshed from remote",
+                },
+            )
+        )
+    else:
+        # Team updates included
+        success_count = sum(1 for t in team_results if t.get("success"))
+        failed_count = len(team_results) - success_count
+
+        if failed_count == 0:
+            console.print(
+                create_success_panel(
+                    "Update Complete",
+                    {
+                        "Organization": org_name,
+                        "Teams Updated": str(success_count),
+                    },
+                )
+            )
+        else:
+            console.print(
+                create_warning_panel(
+                    "Partial Update",
+                    f"Organization updated. {success_count} team(s) succeeded, {failed_count} failed.",
+                )
+            )
+
+    raise typer.Exit(0)

scc_cli/commands/org/validate_cmd.py

@@ -0,0 +1,138 @@
+"""Org validate command for schema and semantic validation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from ...cli_common import console, handle_errors
+from ...core.exit_codes import EXIT_CONFIG, EXIT_VALIDATION
+from ...json_output import build_envelope
+from ...kinds import Kind
+from ...output_mode import json_output_mode, print_json, set_pretty_mode
+from ...panels import create_error_panel, create_success_panel, create_warning_panel
+from ...validate import validate_org_config
+from ._builders import build_validation_data, check_semantic_errors
+
+
+@handle_errors
+def org_validate_cmd(
+    source: str = typer.Argument(..., help="Path to config file to validate"),
+    schema_version: str = typer.Option(
+        "v1", "--schema-version", "-s", help="Schema version (default: v1)"
+    ),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+    pretty: bool = typer.Option(False, "--pretty", help="Pretty-print JSON (implies --json)"),
+) -> None:
+    """Validate an organization configuration file.
+
+    Performs both JSON schema validation and semantic checks.
+
+    Examples:
+        scc org validate ./org-config.json
+        scc org validate ./org-config.json --json
+    """
+    # --pretty implies --json
+    if pretty:
+        json_output = True
+        set_pretty_mode(True)
+
+    # Load config file
+    config_path = Path(source).expanduser().resolve()
+    if not config_path.exists():
+        if json_output:
+            with json_output_mode():
+                data = build_validation_data(
+                    source=source,
+                    schema_errors=[f"File not found: {source}"],
+                    semantic_errors=[],
+                    schema_version=schema_version,
+                )
+                envelope = build_envelope(Kind.ORG_VALIDATION, data=data, ok=False)
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("File Not Found", f"Cannot find config file: {source}"))
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Parse JSON
+    try:
+        config = json.loads(config_path.read_text())
+    except json.JSONDecodeError as e:
+        if json_output:
+            with json_output_mode():
+                data = build_validation_data(
+                    source=source,
+                    schema_errors=[f"Invalid JSON: {e}"],
+                    semantic_errors=[],
+                    schema_version=schema_version,
+                )
+                envelope = build_envelope(Kind.ORG_VALIDATION, data=data, ok=False)
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("Invalid JSON", f"Failed to parse JSON: {e}"))
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Validate against schema
+    schema_errors = validate_org_config(config, schema_version)
+
+    # Check semantic errors (only if schema is valid)
+    semantic_errors: list[str] = []
+    if not schema_errors:
+        semantic_errors = check_semantic_errors(config)
+
+    # Build result data
+    data = build_validation_data(
+        source=source,
+        schema_errors=schema_errors,
+        semantic_errors=semantic_errors,
+        schema_version=schema_version,
+    )
+
+    # JSON output mode
+    if json_output:
+        with json_output_mode():
+            is_valid = data["valid"]
+            all_errors = schema_errors + semantic_errors
+            envelope = build_envelope(
+                Kind.ORG_VALIDATION,
+                data=data,
+                ok=is_valid,
+                errors=all_errors if not is_valid else None,
+            )
+            print_json(envelope)
+            raise typer.Exit(0 if is_valid else EXIT_VALIDATION)
+
+    # Human-readable output
+    if data["valid"]:
+        console.print(
+            create_success_panel(
+                "Validation Passed",
+                {
+                    "Source": source,
+                    "Schema Version": schema_version,
+                    "Status": "Valid",
+                },
+            )
+        )
+        raise typer.Exit(0)
+
+    # Show errors
+    if schema_errors:
+        console.print(
+            create_error_panel(
+                "Schema Validation Failed",
+                "\n".join(f"• {e}" for e in schema_errors),
+            )
+        )
+
+    if semantic_errors:
+        console.print(
+            create_warning_panel(
+                "Semantic Issues",
+                "\n".join(f"• {e}" for e in semantic_errors),
+            )
+        )
+
+    raise typer.Exit(EXIT_VALIDATION)