scc-cli 1.5.3__py3-none-any.whl

scc_cli/commands/org/import_cmd.py

@@ -0,0 +1,267 @@
+"""Organization import command implementation.
+
+Provides the org import command for importing organization configurations
+from URLs or shorthands.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+import requests
+import typer
+from rich.table import Table
+
+from ...cli_common import console, handle_errors
+from ...config import load_user_config, save_user_config
+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
+from ...remote import save_to_cache
+from ...source_resolver import ResolveError, resolve_source
+from ...validate import validate_org_config
+from ._builders import build_import_preview_data
+
+if TYPE_CHECKING:
+    pass
+
+
+@handle_errors
+def org_import_cmd(
+    source: str = typer.Argument(..., help="URL or shorthand (e.g., github:org/repo)"),
+    preview: bool = typer.Option(False, "--preview", "-p", help="Preview import without saving"),
+    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:
+    """Import an organization configuration from a URL.
+
+    Supports direct URLs and shorthands like github:org/repo.
+    Use --preview to validate without saving.
+
+    Examples:
+        scc org import https://example.com/org-config.json
+        scc org import github:acme/configs
+        scc org import github:acme/configs --preview
+        scc org import https://example.com/org.json --json
+    """
+    # --pretty implies --json
+    if pretty:
+        json_output = True
+        set_pretty_mode(True)
+
+    # Resolve source URL (handles shorthands like github:org/repo)
+    resolved = resolve_source(source)
+    if isinstance(resolved, ResolveError):
+        error_msg = resolved.message
+        if resolved.suggestion:
+            error_msg = f"{resolved.message}\n{resolved.suggestion}"
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT_PREVIEW if preview else Kind.ORG_IMPORT,
+                    data={"error": error_msg, "source": source},
+                    ok=False,
+                    errors=[error_msg],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("Invalid Source", error_msg))
+        raise typer.Exit(EXIT_CONFIG)
+
+    resolved_url = resolved.resolved_url
+
+    # Fetch the config from URL
+    try:
+        response = requests.get(resolved_url, timeout=30)
+    except requests.RequestException as e:
+        error_msg = f"Failed to fetch config: {e}"
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT_PREVIEW if preview else Kind.ORG_IMPORT,
+                    data={"error": error_msg, "source": source, "resolved_url": resolved_url},
+                    ok=False,
+                    errors=[error_msg],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("Network Error", error_msg))
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Check HTTP status
+    if response.status_code == 404:
+        error_msg = f"Config not found at {resolved_url}"
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT_PREVIEW if preview else Kind.ORG_IMPORT,
+                    data={"error": error_msg, "source": source, "resolved_url": resolved_url},
+                    ok=False,
+                    errors=[error_msg],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("Not Found", error_msg))
+        raise typer.Exit(EXIT_CONFIG)
+
+    if response.status_code != 200:
+        error_msg = f"HTTP {response.status_code} from {resolved_url}"
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT_PREVIEW if preview else Kind.ORG_IMPORT,
+                    data={"error": error_msg, "source": source, "resolved_url": resolved_url},
+                    ok=False,
+                    errors=[error_msg],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("HTTP Error", error_msg))
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Parse JSON response
+    try:
+        config = response.json()
+    except json.JSONDecodeError as e:
+        error_msg = f"Invalid JSON in response: {e}"
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT_PREVIEW if preview else Kind.ORG_IMPORT,
+                    data={"error": error_msg, "source": source, "resolved_url": resolved_url},
+                    ok=False,
+                    errors=[error_msg],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(create_error_panel("Invalid JSON", error_msg))
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Validate config against schema
+    validation_errors = validate_org_config(config, "v1")
+
+    # Build preview data
+    preview_data = build_import_preview_data(
+        source=source,
+        resolved_url=resolved_url,
+        config=config,
+        validation_errors=validation_errors,
+    )
+
+    # Preview mode: show info without saving
+    if preview:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(Kind.ORG_IMPORT_PREVIEW, data=preview_data)
+                print_json(envelope)
+                raise typer.Exit(0)
+
+        # Human-readable preview
+        _render_import_preview(preview_data)
+        raise typer.Exit(0)
+
+    # Import mode: validate and save
+    if not preview_data["valid"]:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_IMPORT,
+                    data=preview_data,
+                    ok=False,
+                    errors=validation_errors,
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_VALIDATION)
+        console.print(
+            create_error_panel(
+                "Validation Failed",
+                "\n".join(f"* {e}" for e in validation_errors),
+            )
+        )
+        raise typer.Exit(EXIT_VALIDATION)
+
+    # Save to user config
+    user_config = load_user_config()
+    user_config["organization_source"] = {
+        "url": resolved_url,
+        "auth": getattr(resolved, "auth_spec", None),
+    }
+    user_config["standalone"] = False
+    save_user_config(user_config)
+
+    # Cache the fetched config
+    etag = response.headers.get("ETag")
+    save_to_cache(config, source_url=resolved_url, etag=etag, ttl_hours=24)
+
+    # Build import result data
+    import_data = {
+        **preview_data,
+        "imported": True,
+    }
+
+    if json_output:
+        with json_output_mode():
+            envelope = build_envelope(Kind.ORG_IMPORT, data=import_data)
+            print_json(envelope)
+            raise typer.Exit(0)
+
+    # Human-readable success
+    org_name = preview_data["organization"]["name"] or "organization"
+    console.print(
+        create_success_panel(
+            "Import Successful",
+            {
+                "Organization": org_name,
+                "Source": source,
+                "Profiles": ", ".join(preview_data["available_profiles"]) or "None",
+            },
+        )
+    )
+    raise typer.Exit(0)
+
+
+def _render_import_preview(preview: dict[str, Any]) -> None:
+    """Render import preview as human-readable Rich output.
+
+    Args:
+        preview: Preview data from build_import_preview_data
+    """
+    console.print("\n[bold cyan]Organization Config Preview[/bold cyan]")
+
+    # Create info table
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column("Key", style="dim")
+    table.add_column("Value")
+
+    org = preview.get("organization", {})
+    table.add_row("Organization", f"[bold]{org.get('name') or '[unnamed]'}[/bold]")
+
+    if preview["source"] != preview["resolved_url"]:
+        table.add_row("Source", preview["source"])
+        table.add_row("Resolved URL", preview["resolved_url"])
+    else:
+        table.add_row("Source", preview["source"])
+
+    if preview.get("schema_version"):
+        table.add_row("Schema Version", preview["schema_version"])
+    if preview.get("min_cli_version"):
+        table.add_row("Min CLI Version", preview["min_cli_version"])
+
+    profiles = preview.get("available_profiles", [])
+    if profiles:
+        table.add_row("Available Profiles", ", ".join(profiles))
+
+    console.print(table)
+
+    # Validation status
+    if preview["valid"]:
+        console.print("\n[green]Configuration is valid[/green]")
+    else:
+        console.print("\n[red]Configuration is invalid[/red]")
+        for error in preview.get("validation_errors", []):
+            console.print(f"  [red]* {error}[/red]")
+
+    console.print("\n[dim]Use 'scc org import <source>' without --preview to import[/dim]\n")

scc_cli/commands/org/init_cmd.py

@@ -0,0 +1,269 @@
+"""Organization init command implementation.
+
+Provides the org init command for generating organization configuration
+skeletons from templates.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from ...cli_common import console, handle_errors
+from ...core.exit_codes import EXIT_CONFIG
+from ...json_output import build_envelope
+from ...kinds import Kind
+from ...org_templates import (
+    TemplateNotFoundError,
+    TemplateVars,
+    list_templates,
+    render_template_string,
+)
+from ...output_mode import json_output_mode, print_json, set_pretty_mode
+from ...panels import create_error_panel, create_success_panel, create_warning_panel
+
+
+@handle_errors
+def org_init_cmd(
+    template: str = typer.Option(
+        "minimal",
+        "--template",
+        "-t",
+        help="Template to use (minimal, teams, strict, reference).",
+    ),
+    org_name: str = typer.Option(
+        "my-org",
+        "--org-name",
+        "-n",
+        help="Organization name for template substitution.",
+    ),
+    org_domain: str = typer.Option(
+        "example.com",
+        "--org-domain",
+        "-d",
+        help="Organization domain for template substitution.",
+    ),
+    stdout: bool = typer.Option(
+        False,
+        "--stdout",
+        help="Print generated config to stdout instead of writing to file.",
+    ),
+    output: Path | None = typer.Option(
+        None,
+        "--output",
+        "-o",
+        help="Write config to specified file path.",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Overwrite existing file without prompting.",
+    ),
+    list_templates_flag: bool = typer.Option(
+        False,
+        "--list-templates",
+        "-l",
+        help="List available templates and exit.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Output in JSON envelope format.",
+    ),
+    pretty: bool = typer.Option(
+        False,
+        "--pretty",
+        help="Pretty-print JSON output with indentation.",
+    ),
+) -> None:
+    """Generate an organization config skeleton from templates.
+
+    Templates provide starting points for organization configurations:
+    - minimal: Simple quickstart with sensible defaults
+    - teams: Multi-team setup with delegation
+    - strict: Security-focused for regulated industries
+    - reference: Complete reference with all fields documented
+
+    Examples:
+        scc org init --list-templates          # Show available templates
+        scc org init --stdout                  # Print minimal config to stdout
+        scc org init -t teams --stdout         # Print teams template
+        scc org init -o org.json               # Write to org.json
+        scc org init -n acme -d acme.com -o .  # Customize and write
+    """
+    if pretty:
+        set_pretty_mode(True)
+
+    # Handle --list-templates
+    if list_templates_flag:
+        _handle_list_templates(json_output)
+        return
+
+    # Require either --stdout or --output
+    if not stdout and output is None:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_INIT,
+                    data={"error": "Must specify --stdout or --output"},
+                    ok=False,
+                )
+                print_json(envelope)
+            raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_warning_panel(
+                "Output Required",
+                "Must specify either --stdout or --output to generate config.",
+                hint="Use --list-templates to see available templates.",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Generate config from template
+    try:
+        vars = TemplateVars(org_name=org_name, org_domain=org_domain)
+        config_json = render_template_string(template, vars)
+    except TemplateNotFoundError as e:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_INIT,
+                    data={
+                        "error": str(e),
+                        "available_templates": e.available,
+                    },
+                    ok=False,
+                )
+                print_json(envelope)
+            raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_error_panel(
+                "Template Not Found",
+                str(e),
+                hint=f"Available templates: {', '.join(e.available)}",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # Handle --stdout
+    if stdout:
+        if json_output:
+            # In JSON mode with --stdout, just print the raw config
+            # The config itself is the output, not wrapped in envelope
+            console.print(config_json)
+        else:
+            console.print(config_json)
+        raise typer.Exit(0)
+
+    # Handle --output
+    if output is not None:
+        # Resolve output path
+        if output.is_dir():
+            output_path = output / "org-config.json"
+        else:
+            output_path = output
+
+        # Check for existing file
+        if output_path.exists() and not force:
+            if json_output:
+                with json_output_mode():
+                    envelope = build_envelope(
+                        Kind.ORG_INIT,
+                        data={
+                            "error": f"File already exists: {output_path}",
+                            "file": str(output_path),
+                        },
+                        ok=False,
+                    )
+                    print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+            console.print(
+                create_error_panel(
+                    "File Exists",
+                    f"File already exists: {output_path}",
+                    hint="Use --force to overwrite.",
+                )
+            )
+            raise typer.Exit(EXIT_CONFIG)
+
+        # Write file
+        output_path.write_text(config_json)
+
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_INIT,
+                    data={
+                        "file": str(output_path),
+                        "template": template,
+                        "org_name": org_name,
+                        "org_domain": org_domain,
+                    },
+                )
+                print_json(envelope)
+        else:
+            console.print(
+                create_success_panel(
+                    "Config Created",
+                    {
+                        "File": str(output_path),
+                        "Template": template,
+                    },
+                )
+            )
+        raise typer.Exit(0)
+
+
+def _handle_list_templates(json_output: bool) -> None:
+    """Handle --list-templates flag.
+
+    Args:
+        json_output: Whether to output JSON envelope format.
+    """
+    templates = list_templates()
+
+    if json_output:
+        with json_output_mode():
+            template_data = [
+                {
+                    "name": t.name,
+                    "description": t.description,
+                    "level": t.level,
+                    "use_case": t.use_case,
+                }
+                for t in templates
+            ]
+            envelope = build_envelope(
+                Kind.ORG_TEMPLATE_LIST,
+                data={"templates": template_data},
+            )
+            print_json(envelope)
+        raise typer.Exit(0)
+
+    # Human-readable output
+    console.print("\n[bold cyan]Available Organization Config Templates[/bold cyan]\n")
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Template", style="cyan")
+    table.add_column("Level")
+    table.add_column("Description")
+
+    for t in templates:
+        level_style = {
+            "beginner": "green",
+            "intermediate": "yellow",
+            "advanced": "red",
+            "reference": "blue",
+        }.get(t.level, "")
+        table.add_row(
+            t.name,
+            f"[{level_style}]{t.level}[/{level_style}]" if level_style else t.level,
+            t.description,
+        )
+
+    console.print(table)
+    console.print("\n[dim]Use: scc org init --template <name> --stdout[/dim]\n")
+    raise typer.Exit(0)

scc_cli/commands/org/schema_cmd.py

@@ -0,0 +1,76 @@
+"""Org schema command for printing bundled schema."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from ...cli_common import console, handle_errors
+from ...core.exit_codes import EXIT_CONFIG
+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
+from ...validate import load_bundled_schema
+
+
+@handle_errors
+def org_schema_cmd(
+    schema_version: str = typer.Option(
+        "v1", "--version", "-v", help="Schema version to print (default: v1)"
+    ),
+    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:
+    """Print the bundled organization config schema.
+
+    Useful for understanding the expected configuration format
+    or for use with external validators.
+
+    Examples:
+        scc org schema
+        scc org schema --json
+    """
+    # --pretty implies --json
+    if pretty:
+        json_output = True
+        set_pretty_mode(True)
+
+    # Load schema
+    try:
+        schema = load_bundled_schema(schema_version)
+    except FileNotFoundError:
+        if json_output:
+            with json_output_mode():
+                envelope = build_envelope(
+                    Kind.ORG_SCHEMA,
+                    data={"error": f"Schema version '{schema_version}' not found"},
+                    ok=False,
+                    errors=[f"Schema version '{schema_version}' not found"],
+                )
+                print_json(envelope)
+                raise typer.Exit(EXIT_CONFIG)
+        console.print(
+            create_error_panel(
+                "Schema Not Found",
+                f"Schema version '{schema_version}' does not exist.",
+                "Available version: v1",
+            )
+        )
+        raise typer.Exit(EXIT_CONFIG)
+
+    # JSON envelope output
+    if json_output:
+        with json_output_mode():
+            data = {
+                "schema_version": schema_version,
+                "schema": schema,
+            }
+            envelope = build_envelope(Kind.ORG_SCHEMA, data=data)
+            print_json(envelope)
+            raise typer.Exit(0)
+
+    # Raw schema output (for piping to files or validators)
+    print(json.dumps(schema, indent=2))  # noqa: T201
+    raise typer.Exit(0)