cloudwright-ai-cli 0.1.0__py3-none-any.whl

cloudwright_cli/commands/cost.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import ArchSpec
+from cloudwright.cost import CostEngine
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def cost(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to spec YAML file", exists=True)],
+    compare: Annotated[str | None, typer.Option(help="Comma-separated providers to compare")] = None,
+    pricing_tier: Annotated[
+        str | None, typer.Option(help="Pricing tier (on_demand, reserved_1yr, reserved_3yr, spot)")
+    ] = None,
+) -> None:
+    """Show cost breakdown for an architecture spec."""
+    spec = ArchSpec.from_file(spec_file)
+
+    # Compute cost estimate if not present
+    if not spec.cost_estimate:
+        engine = CostEngine()
+        spec.cost_estimate = engine.estimate(spec)
+
+    if ctx.obj and ctx.obj.get("json"):
+        import json
+
+        print(json.dumps({"estimate": spec.cost_estimate.model_dump()}, default=str))
+        return
+
+    if compare:
+        providers = [p.strip() for p in compare.split(",") if p.strip()]
+        _print_multi_cloud_table(spec, providers)
+    else:
+        _print_single_cost_table(spec)
+
+
+def _print_single_cost_table(spec: ArchSpec) -> None:
+    if not spec.cost_estimate:
+        console.print("[yellow]No cost estimate in spec. Run 'cloudwright design' to generate one.[/yellow]")
+        return
+
+    table = Table(title=f"Cost Breakdown — {spec.name}", show_footer=True)
+    table.add_column("Component", style="cyan")
+    table.add_column("Service")
+    table.add_column("Monthly", justify="right", footer=f"${spec.cost_estimate.monthly_total:,.2f}")
+    table.add_column("Notes", style="dim")
+
+    comp_map = {c.id: c for c in spec.components}
+    for item in spec.cost_estimate.breakdown:
+        comp = comp_map.get(item.component_id)
+        svc_label = comp.service if comp else item.service
+        table.add_row(
+            item.component_id,
+            svc_label,
+            f"${item.monthly:,.2f}",
+            item.notes,
+        )
+
+    console.print(table)
+
+
+def _print_multi_cloud_table(spec: ArchSpec, providers: list[str]) -> None:
+    all_providers = [spec.provider] + [p for p in providers if p != spec.provider]
+    alternatives_map: dict = {spec.provider: spec}
+
+    engine = CostEngine()
+    if not spec.cost_estimate:
+        spec.cost_estimate = engine.estimate(spec)
+    with console.status("Computing alternatives..."):
+        alts = engine.compare_providers(spec, providers)
+        for alt in alts:
+            if alt.spec:
+                alt.spec.cost_estimate = engine.estimate(alt.spec)
+                alternatives_map[alt.provider] = alt.spec
+
+    table = Table(title=f"Multi-Cloud Comparison — {spec.name}")
+    table.add_column("Component", style="cyan")
+
+    for p in all_providers:
+        table.add_column(p.upper(), justify="right")
+
+    comp_ids = [c.id for c in spec.components]
+    for cid in comp_ids:
+        row = [cid]
+        for p in all_providers:
+            s = alternatives_map.get(p)
+            if s and s.cost_estimate:
+                item = next((i for i in s.cost_estimate.breakdown if i.component_id == cid), None)
+                row.append(f"${item.monthly:,.2f}" if item else "-")
+            else:
+                row.append("-")
+        table.add_row(*row)
+
+    # Totals row
+    totals = []
+    for p in all_providers:
+        s = alternatives_map.get(p)
+        if s and s.cost_estimate:
+            totals.append(f"${s.cost_estimate.monthly_total:,.2f}")
+        else:
+            totals.append("-")
+    table.add_section()
+    table.add_row("[bold]TOTAL[/bold]", *totals)
+
+    console.print(table)

cloudwright_cli/commands/design.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import Architect, Constraints
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.table import Table
+
+console = Console()
+
+
+def design(
+    ctx: typer.Context,
+    description: Annotated[str, typer.Argument(help="Natural language architecture description")],
+    provider: Annotated[str, typer.Option(help="Cloud provider")] = "aws",
+    region: Annotated[str, typer.Option(help="Primary region")] = "us-east-1",
+    budget: Annotated[float | None, typer.Option(help="Monthly budget in USD")] = None,
+    compliance: Annotated[
+        list[str] | None, typer.Option(help="Compliance frameworks (hipaa, pci-dss, soc2, fedramp, gdpr)")
+    ] = None,
+    output: Annotated[Path | None, typer.Option("--output", "-o", help="Write YAML to file")] = None,
+) -> None:
+    """Design a cloud architecture from a natural language description."""
+    constraints = Constraints(
+        regions=[region] if region else [],
+        budget_monthly=budget,
+        compliance=compliance or [],
+    )
+
+    with console.status("Designing architecture..."):
+        spec = Architect().design(description, constraints=constraints)
+        # Set provider/region from CLI args if not overridden by LLM
+        if spec.provider == "aws" and provider != "aws":
+            spec = spec.model_copy(update={"provider": provider})
+        if spec.region == "us-east-1" and region != "us-east-1":
+            spec = spec.model_copy(update={"region": region})
+
+    if ctx.obj and ctx.obj.get("json"):
+        import json
+
+        print(json.dumps(spec.model_dump(), default=str))
+        return
+
+    yaml_str = spec.to_yaml()
+
+    console.print(
+        Panel(
+            Syntax(yaml_str, "yaml", theme="monokai", word_wrap=True),
+            title=f"[bold cyan]{spec.name}[/bold cyan]",
+            subtitle=f"{spec.provider.upper()} / {spec.region}",
+        )
+    )
+
+    if spec.cost_estimate:
+        _print_cost_table(spec)
+
+    if output:
+        output.write_text(yaml_str)
+        console.print(f"[green]Saved to {output}[/green]")
+
+
+def _print_cost_table(spec) -> None:
+    table = Table(title="Cost Estimate", show_footer=True)
+    table.add_column("Component", style="cyan")
+    table.add_column("Service")
+    table.add_column("Monthly", justify="right", footer=f"${spec.cost_estimate.monthly_total:,.2f}")
+    table.add_column("Notes", style="dim")
+
+    comp_map = {c.id: c for c in spec.components}
+    for item in spec.cost_estimate.breakdown:
+        service = comp_map.get(item.component_id, None)
+        svc_label = service.service if service else item.service
+        table.add_row(
+            item.component_id,
+            svc_label,
+            f"${item.monthly:,.2f}",
+            item.notes,
+        )
+
+    console.print(table)

cloudwright_cli/commands/diff.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import ArchSpec, Differ
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+console = Console()
+
+
+def diff(
+    ctx: typer.Context,
+    spec_a: Annotated[Path, typer.Argument(help="First spec file (baseline)", exists=True)],
+    spec_b: Annotated[Path, typer.Argument(help="Second spec file (new)", exists=True)],
+) -> None:
+    """Show the diff between two architecture specs."""
+    a = ArchSpec.from_file(spec_a)
+    b = ArchSpec.from_file(spec_b)
+
+    with console.status("Computing diff..."):
+        result = Differ().diff(a, b)
+
+    if ctx.obj and ctx.obj.get("json"):
+        import json
+
+        print(json.dumps(result.model_dump(), default=str))
+        return
+
+    console.print(Rule(f"[bold]Diff: {spec_a.name} → {spec_b.name}[/bold]"))
+
+    if result.summary:
+        console.print(f"[dim]{result.summary}[/dim]\n")
+
+    if not result.added and not result.removed and not result.changed:
+        console.print("[green]No changes detected.[/green]")
+        return
+
+    if result.added:
+        console.print("[bold green]Added Components[/bold green]")
+        for comp in result.added:
+            console.print(f"  [green]+[/green] {comp.id} ({comp.service}) — {comp.label}")
+        console.print()
+
+    if result.removed:
+        console.print("[bold red]Removed Components[/bold red]")
+        for comp in result.removed:
+            console.print(f"  [red]-[/red] {comp.id} ({comp.service}) — {comp.label}")
+        console.print()
+
+    if result.changed:
+        table = Table(title="Changed Components")
+        table.add_column("Component", style="cyan")
+        table.add_column("Field")
+        table.add_column("Before", style="red")
+        table.add_column("After", style="green")
+        table.add_column("Cost Delta", justify="right")
+
+        for change in result.changed:
+            delta_str = _fmt_delta(change.cost_delta)
+            table.add_row(
+                change.component_id,
+                change.field,
+                change.old_value,
+                change.new_value,
+                delta_str,
+            )
+        console.print(table)
+
+    if result.cost_delta != 0.0:
+        delta_str = _fmt_delta(result.cost_delta)
+        console.print(f"\nTotal cost delta: {delta_str}/month")
+
+    if result.compliance_impact:
+        console.print("\n[bold yellow]Compliance Impact[/bold yellow]")
+        for item in result.compliance_impact:
+            console.print(f"  [yellow]![/yellow] {item}")
+
+
+def _fmt_delta(delta: float) -> str:
+    if delta > 0:
+        return f"[red]+${delta:,.2f}[/red]"
+    if delta < 0:
+        return f"[green]-${abs(delta):,.2f}[/green]"
+    return "[dim]$0.00[/dim]"

cloudwright_cli/commands/drift_cmd.py

@@ -0,0 +1,98 @@
+"""Drift detection — compare design spec against deployed infrastructure."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.table import Table
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def drift(
+    ctx: typer.Context,
+    spec_file: Annotated[str, typer.Argument(help="Path to the design ArchSpec YAML")],
+    infra_file: Annotated[str, typer.Argument(help="Path to Terraform .tfstate or CloudFormation template")],
+    fmt: Annotated[
+        str, typer.Option("--format", "-f", help="Infrastructure format: auto, terraform, cloudformation")
+    ] = "auto",
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+) -> None:
+    """Compare design spec against deployed infrastructure to detect drift."""
+    try:
+        from cloudwright.drift import detect_drift
+
+        if not Path(spec_file).exists():
+            console.print(f"[red]Error:[/red] Design spec not found: {spec_file}")
+            raise typer.Exit(1)
+        if not Path(infra_file).exists():
+            console.print(f"[red]Error:[/red] Infrastructure file not found: {infra_file}")
+            raise typer.Exit(1)
+
+        with console.status("Detecting drift..."):
+            report = detect_drift(spec_file, infra_file, infra_format=fmt)
+
+        if json_output:
+            import json
+
+            result = {
+                "drift_score": report.drift_score,
+                "drifted_components": report.drifted_components,
+                "extra_components": report.extra_components,
+                "missing_components": report.missing_components,
+                "diff": report.diff.model_dump(),
+                "summary": report.summary,
+            }
+            console.print_json(json.dumps(result, default=str))
+            return
+
+        score_color = "green" if report.drift_score == 0 else "yellow" if report.drift_score < 0.3 else "red"
+
+        console.print(Rule("[bold]Cloudwright Drift Detection[/bold]"))
+        console.print(
+            Panel(
+                f"[{score_color}]Drift Score: {report.drift_score:.0%}[/{score_color}]\n[dim]{report.summary}[/dim]",
+                title=f"[dim]{Path(spec_file).name}[/dim] vs [dim]{Path(infra_file).name}[/dim]",
+            )
+        )
+
+        if report.drift_score == 0:
+            return
+
+        if report.missing_components:
+            console.print(f"\n[bold red]Missing from deployment ({len(report.missing_components)})[/bold red]")
+            for cid in report.missing_components:
+                console.print(f"  [red]-[/red] {cid}")
+
+        if report.extra_components:
+            console.print(f"\n[bold yellow]Extra in deployment ({len(report.extra_components)})[/bold yellow]")
+            for cid in report.extra_components:
+                console.print(f"  [yellow]+[/yellow] {cid}")
+
+        if report.drifted_components:
+            table = Table(title=f"Configuration Drift ({len(report.drifted_components)} components)")
+            table.add_column("Component", style="cyan")
+            table.add_column("Field")
+            table.add_column("Design", style="green")
+            table.add_column("Deployed", style="red")
+            for change in report.diff.changed:
+                table.add_row(change.component_id, change.field, change.old_value, change.new_value)
+            console.print()
+            console.print(table)
+
+        if report.diff.compliance_impact:
+            console.print("\n[bold red]Compliance Impact[/bold red]")
+            for impact in report.diff.compliance_impact:
+                console.print(f"  [red]![/red] {impact}")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/export.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import ArchSpec
+from cloudwright.exporter import FORMATS
+from rich.console import Console
+from rich.syntax import Syntax
+
+console = Console()
+
+_SYNTAX_MAP = {
+    "terraform": "hcl",
+    "cloudformation": "yaml",
+    "mermaid": "text",
+    "sbom": "json",
+    "aibom": "json",
+}
+
+
+def export(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to spec YAML file", exists=True)],
+    format: Annotated[str, typer.Option("--format", "-f", help=f"Export format: {', '.join(FORMATS)}")],
+    output: Annotated[Path | None, typer.Option("--output", "-o", help="Output file or directory")] = None,
+) -> None:
+    """Export an architecture spec to Terraform, CloudFormation, Mermaid, SBOM, or AIBOM."""
+    fmt = format.lower().strip()
+    if fmt not in FORMATS and fmt != "cfn":
+        console.print(f"[red]Error:[/red] Unknown format {fmt!r}. Supported: {', '.join(FORMATS)}")
+        raise typer.Exit(1)
+
+    spec = ArchSpec.from_file(spec_file)
+
+    output_str = str(output) if output else None
+    output_dir_str = None
+
+    # Terraform with a directory target writes main.tf inside the dir
+    if fmt == "terraform" and output and output.is_dir():
+        output_dir_str = output_str
+        output_str = None
+    elif fmt == "terraform" and output and not output.suffix:
+        # Treat extensionless output as a directory path
+        output_dir_str = output_str
+        output_str = None
+
+    with console.status(f"Exporting as {fmt}..."):
+        content = spec.export(fmt, output=output_str, output_dir=output_dir_str)
+
+    if ctx.obj and ctx.obj.get("json"):
+        import json
+
+        print(json.dumps({"format": fmt, "content": content}, default=str))
+        return
+
+    if output:
+        if output_dir_str:
+            console.print(f"[green]Written to {output_dir_str}/main.tf[/green]")
+        else:
+            console.print(f"[green]Written to {output}[/green]")
+    else:
+        lang = _SYNTAX_MAP.get(fmt, "text")
+        console.print(Syntax(content, lang, theme="monokai", word_wrap=True))

cloudwright_cli/commands/import_cmd.py

@@ -0,0 +1,69 @@
+"""Import existing infrastructure (Terraform state, CloudFormation) into an ArchSpec."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def import_infra(
+    ctx: typer.Context,
+    source: Annotated[str, typer.Argument(help="Path to .tfstate or CloudFormation template")],
+    fmt: Annotated[
+        str | None,
+        typer.Option("--format", "-f", help="Import format: terraform, cloudformation (default: auto-detect)"),
+    ] = None,
+    output: Annotated[
+        str | None,
+        typer.Option("--output", "-o", help="Write ArchSpec YAML to this file instead of stdout"),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option("--name", help="Override the architecture name"),
+    ] = None,
+) -> None:
+    """Import infrastructure state or templates into an ArchSpec YAML file."""
+    try:
+        from cloudwright.importer import import_spec
+
+        kwargs: dict = {}
+        if fmt:
+            kwargs["fmt"] = fmt
+
+        with console.status(f"Importing {Path(source).name}..."):
+            spec = import_spec(source, **kwargs)
+
+        if name:
+            spec = spec.model_copy(update={"name": name})
+
+        json_mode = ctx.obj and ctx.obj.get("json")
+
+        if json_mode:
+            print(json.dumps(json.loads(spec.to_json()), indent=2))
+            return
+
+        content = spec.to_yaml()
+
+        if output:
+            Path(output).write_text(content)
+            n_comps = len(spec.components)
+            n_conns = len(spec.connections)
+            console.print(
+                f"[green]Imported[/green] {n_comps} component(s), {n_conns} connection(s) → [bold]{output}[/bold]"
+            )
+        else:
+            sys.stdout.write(content)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/init_cmd.py

@@ -0,0 +1,135 @@
+"""Initialize a new ArchSpec from a template."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+try:
+    from importlib.resources import files as _pkg_files
+
+    _TEMPLATES_DIR = Path(str(_pkg_files("cloudwright") / "data" / "templates"))
+except Exception:
+    _TEMPLATES_DIR = Path(__file__).resolve().parents[4] / "catalog" / "templates"
+
+
+def init(
+    ctx: typer.Context,
+    template: Annotated[str | None, typer.Option("--template", "-t", help="Template name")] = None,
+    output: Annotated[str, typer.Option("--output", "-o", help="Output file path")] = "spec.yaml",
+    list_templates: Annotated[bool, typer.Option("--list", "-l", help="List available templates")] = False,
+    provider: Annotated[str | None, typer.Option(help="Override provider (aws, gcp, azure)")] = None,
+    region: Annotated[str | None, typer.Option(help="Override region")] = None,
+    name: Annotated[str | None, typer.Option(help="Override architecture name")] = None,
+    compliance: Annotated[
+        str | None, typer.Option(help="Comma-separated compliance frameworks (hipaa, pci-dss, soc2, fedramp, gdpr)")
+    ] = None,
+    budget: Annotated[float | None, typer.Option(help="Monthly budget in USD")] = None,
+    project: Annotated[bool, typer.Option("--project", "-p", help="Create a .cloudwright/ project directory")] = False,
+) -> None:
+    """Initialize a new ArchSpec from a template."""
+    try:
+        index_path = _TEMPLATES_DIR / "_index.yaml"
+        if not index_path.exists():
+            console.print("[red]Error:[/red] Template index not found.")
+            raise typer.Exit(1)
+
+        index = yaml.safe_load(index_path.read_text())
+        templates = index.get("templates", {})
+
+        if list_templates:
+            table = Table(title="Available Templates")
+            table.add_column("Name", style="cyan")
+            table.add_column("Description")
+            table.add_column("Provider")
+            table.add_column("Complexity")
+            table.add_column("Tags")
+
+            for key, tmpl in templates.items():
+                table.add_row(
+                    key,
+                    tmpl.get("description", ""),
+                    tmpl.get("provider", ""),
+                    tmpl.get("complexity", ""),
+                    ", ".join(tmpl.get("tags", [])),
+                )
+            console.print(table)
+            return
+
+        if not template:
+            console.print("[red]Error:[/red] Specify a template with --template <name>, or use --list to see options.")
+            raise typer.Exit(1)
+
+        if template not in templates:
+            console.print(f"[red]Error:[/red] Unknown template '{template}'. Use --list to see available templates.")
+            raise typer.Exit(1)
+
+        tmpl_info = templates[template]
+        tmpl_file = _TEMPLATES_DIR / tmpl_info["file"]
+
+        if not tmpl_file.exists():
+            console.print(f"[red]Error:[/red] Template file not found: {tmpl_info['file']}")
+            raise typer.Exit(1)
+
+        spec_data = yaml.safe_load(tmpl_file.read_text())
+
+        if name:
+            spec_data["name"] = name
+        if provider:
+            spec_data["provider"] = provider
+            for comp in spec_data.get("components", []):
+                comp["provider"] = provider
+        if region:
+            spec_data["region"] = region
+
+        if compliance:
+            if "constraints" not in spec_data:
+                spec_data["constraints"] = {}
+            spec_data["constraints"]["compliance"] = [c.strip() for c in compliance.split(",")]
+
+        if budget is not None:
+            if "constraints" not in spec_data:
+                spec_data["constraints"] = {}
+            spec_data["constraints"]["budget_monthly"] = budget
+
+        if project:
+            proj_dir = Path(".cloudwright")
+            proj_dir.mkdir(exist_ok=True)
+            output_path = proj_dir / "spec.yaml"
+            config = {
+                "version": 1,
+                "default_provider": spec_data.get("provider", "aws"),
+                "default_region": spec_data.get("region", "us-east-1"),
+                "compliance": [c.strip() for c in compliance.split(",")] if compliance else [],
+                "budget_monthly": budget,
+            }
+            config = {k: v for k, v in config.items() if v is not None}
+            (proj_dir / "config.yaml").write_text(yaml.dump(config, default_flow_style=False, sort_keys=False))
+        else:
+            output_path = Path(output)
+
+        output_path.write_text(yaml.dump(spec_data, default_flow_style=False, sort_keys=False, allow_unicode=True))
+
+        console.print(f"[green]Created {output_path}[/green] from template '{template}'")
+        console.print(f"  Provider: {spec_data.get('provider', 'aws')}")
+        console.print(f"  Components: {len(spec_data.get('components', []))}")
+        if project:
+            console.print(f"  Config: {proj_dir / 'config.yaml'}")
+        console.print("\nNext steps:")
+        console.print(f"  cloudwright cost {output_path}")
+        console.print(f"  cloudwright validate {output_path}")
+        console.print(f"  cloudwright export {output_path} --format terraform -o ./infra")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)