cloudwright-ai-cli 1.4.0__tar.gz → 1.6.0__tar.gz

{cloudwright_ai_cli-1.4.0 → cloudwright_ai_cli-1.6.0}/.gitignore

@@ -18,3 +18,5 @@ node_modules/
 CLAUDE.md
 packages/*/CLAUDE.md
 docs/fix-plan.md
+tmp/
+_recording*/

{cloudwright_ai_cli-1.4.0 → cloudwright_ai_cli-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudwright-ai-cli
-Version: 1.4.0
+Version: 1.6.0
 Summary: CLI for Cloudwright architecture intelligence
 Project-URL: Homepage, https://github.com/xmpuspus/cloudwright
 Project-URL: Repository, https://github.com/xmpuspus/cloudwright

cloudwright_ai_cli-1.6.0/cloudwright_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.6.0"

cloudwright_ai_cli-1.6.0/cloudwright_cli/commands/compliance_cmd.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cloudwright_cli.output import emit_stream, emit_success, is_json_mode, should_stream
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+_SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "none": 4}
+
+
+def compliance_scan(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to ArchSpec YAML file", exists=True)],
+    frameworks: Annotated[
+        str | None,
+        typer.Option("--frameworks", "-f", help="Comma list: hipaa,soc2,pci-dss,fedramp,gdpr,iso27001,nist"),
+    ] = None,
+    checkov: Annotated[
+        bool | None,
+        typer.Option("--checkov/--no-checkov", help="Force or skip the Checkov deep scan (auto-detected by default)"),
+    ] = None,
+    fail_on: Annotated[str, typer.Option("--fail-on", help="Fail on: critical, high, medium, none")] = "high",
+    output: Annotated[str | None, typer.Option("--output", "-o", help="Write a markdown control report")] = None,
+    oscal: Annotated[
+        bool,
+        typer.Option("--oscal", "-O", help="Emit OSCAL 1.1.2 component-definition JSON alongside the scan"),
+    ] = False,
+    traceability: Annotated[
+        bool,
+        typer.Option("--traceability", help="Show the control traceability chain: component -> resource -> control"),
+    ] = False,
+) -> None:
+    """Scan an ArchSpec and map every finding to framework control IDs.
+
+    Maps design-stage findings to HIPAA / SOC 2 / PCI-DSS / FedRAMP / GDPR /
+    ISO 27001 / NIST 800-53 controls before any infrastructure exists. Folds in
+    a Checkov deep scan against the exported Terraform when Checkov is on PATH.
+
+    Use --oscal / -O to also emit an OSCAL 1.1.2 component-definition document.
+    When --output is set the OSCAL JSON is written to <output>.oscal.json;
+    otherwise it is printed to stdout after the standard report.
+    """
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.compliance import ComplianceScanner, render_markdown
+
+        spec = ArchSpec.from_file(spec_file)
+        fw_list = [f for f in (frameworks.split(",") if frameworks else []) if f.strip()]
+        report = ComplianceScanner().scan(spec, frameworks=fw_list or None, run_checkov=checkov)
+
+        if output:
+            Path(output).write_text(render_markdown(spec, report))
+
+        if oscal:
+            import json as _json
+
+            from cloudwright.oscal import to_oscal
+
+            scanner = ComplianceScanner()
+            resolved_fws = scanner.resolve_frameworks(spec, fw_list or None)
+            oscal_doc = to_oscal(spec, report, resolved_fws)
+            oscal_text = _json.dumps(oscal_doc, indent=2)
+            if output:
+                oscal_path = str(output) + ".oscal.json"
+                Path(oscal_path).write_text(oscal_text)
+                if not is_json_mode(ctx):
+                    console.print(f"OSCAL document written to {oscal_path}", style="dim")
+            else:
+                print(oscal_text)
+
+        if is_json_mode(ctx):
+            if should_stream(ctx):
+                for f in report.findings:
+                    emit_stream(f.as_dict())
+            else:
+                payload = report.as_dict()
+                if traceability:
+                    from cloudwright.compliance import build_traceability
+
+                    payload["traceability"] = build_traceability(spec, report)
+                emit_success(ctx, payload)
+            _maybe_exit(report, fail_on)
+            return
+
+        console.print(f"\nCompliance Scan: {spec_file.name}  (scanner: {report.scanner})\n")
+
+        posture = Table("Framework", "Satisfied", "Violated controls", "Findings", "Status")
+        for s in report.frameworks:
+            sat = f"{s.controls_total - len(s.controls_violated)}/{s.controls_total}"
+            viol = ", ".join(s.controls_violated) if s.controls_violated else "-"
+            style = "green" if s.status == "pass" else "red"
+            posture.add_row(s.framework, sat, viol, str(s.findings), f"[{style}]{s.status.upper()}[/{style}]")
+        console.print(posture)
+        console.print()
+
+        if not report.findings:
+            console.print("[green][PASS][/green] No control violations detected.")
+        else:
+            for f in report.findings:
+                sev = f.severity.upper()
+                color = {"CRITICAL": "bold red", "HIGH": "red", "MEDIUM": "yellow"}.get(sev, "dim")
+                console.print(f"  [{color}][{sev}][/{color}] {f.message}  [dim]({f.source})[/dim]")
+                if f.controls:
+                    ctrl = ", ".join(f"{c.framework} {c.control_id}" for c in f.controls)
+                    console.print(f"           Controls: {ctrl}", style="cyan")
+                console.print(f"           Remediation: {f.remediation}", style="dim")
+                console.print()
+
+        if traceability and report.findings:
+            from cloudwright.compliance import build_traceability
+
+            chain_table = Table("Component", "Resource", "Controls", "Status", title="Control Traceability")
+            for row in build_traceability(spec, report):
+                ctrls = ", ".join(f"{c['framework']} {c['control_id']}" for c in row["controls"]) or "-"
+                chain_table.add_row(
+                    f"{row['label'] or row['component_id'] or '-'} ({row['service'] or '-'})",
+                    row["resource_type"] or "-",
+                    ctrls,
+                    f"[red]{row['status']}[/red]",
+                )
+            console.print(chain_table)
+            console.print()
+
+        crit = report.critical_count
+        high = report.high_count
+        console.print(f"{len(report.findings)} finding(s) ({crit} critical, {high} high)")
+        threshold = _SEVERITY_ORDER.get(fail_on, 1)
+        worst = min((_SEVERITY_ORDER.get(f.severity, 4) for f in report.findings), default=4)
+        status = "PASSED" if worst > threshold else "FAILED"
+        console.print(f"Status: [{'green' if status == 'PASSED' else 'red'}]{status}[/] (fail-on={fail_on})")
+        if output:
+            console.print(f"\nReport written to {output}", style="dim")
+
+        _maybe_exit(report, fail_on)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)
+
+
+def _maybe_exit(report, fail_on: str) -> None:
+    threshold = _SEVERITY_ORDER.get(fail_on, 1)
+    for f in report.findings:
+        if _SEVERITY_ORDER.get(f.severity, 4) <= threshold:
+            raise typer.Exit(1)

{cloudwright_ai_cli-1.4.0 → cloudwright_ai_cli-1.6.0}/cloudwright_cli/commands/cost.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 from typing import Annotated
 
@@ -30,6 +31,18 @@ def cost(
             "Sets realistic defaults for request volumes, storage, node counts, and data transfer.",
         ),
     ] = None,
+    carbon: Annotated[
+        bool,
+        typer.Option("--carbon", help="Include a CO2e carbon footprint estimate."),
+    ] = False,
+    focus: Annotated[
+        bool,
+        typer.Option("--focus", help="Output cost data as FinOps FOCUS 1.0 CSV."),
+    ] = False,
+    output: Annotated[
+        Path | None,
+        typer.Option("-o", "--output", help="Write FOCUS CSV to this file instead of stdout."),
+    ] = None,
 ) -> None:
     """Show cost breakdown for an architecture spec."""
     if workload_profile:
@@ -43,14 +56,32 @@ def cost(
             raise typer.Exit(1)
 
     spec = ArchSpec.from_file(spec_file)
+    tier = pricing_tier or "on_demand"
 
     # Compute cost estimate if not present
     if not spec.cost_estimate:
         engine = CostEngine()
-        spec.cost_estimate = engine.estimate(spec, workload_profile=workload_profile)
+        spec.cost_estimate = engine.estimate(spec, pricing_tier=tier, workload_profile=workload_profile)
+
+    # --focus: emit FOCUS CSV and exit
+    if focus:
+        from cloudwright.focus import to_focus_csv
+
+        csv_text = to_focus_csv(spec.cost_estimate, pricing_tier=tier)
+        if output:
+            output.write_text(csv_text, encoding="utf-8")
+            console.print(f"FOCUS CSV written to {output}")
+        else:
+            sys.stdout.write(csv_text)
+        return
 
     if is_json_mode(ctx):
-        emit_success(ctx, {"estimate": spec.cost_estimate.model_dump(exclude_none=True)})
+        payload: dict = {"estimate": spec.cost_estimate.model_dump(exclude_none=True)}
+        if carbon:
+            from cloudwright.carbon import estimate_carbon
+
+            payload["carbon"] = estimate_carbon(spec)
+        emit_success(ctx, payload)
         return
 
     if compare:
@@ -59,31 +90,51 @@ def cost(
     else:
         _print_single_cost_table(spec)
 
+    if carbon:
+        from cloudwright.carbon import estimate_carbon
+
+        _print_carbon_table(spec, estimate_carbon(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)
+    est = spec.cost_estimate
+    region_note = ""
+    if est.region_multiplier != 1.0:
+        region_note = f" (region multiplier: {est.region_multiplier:.2f}x vs us-east-1)"
+
+    title = f"Cost Breakdown — {spec.name}{region_note}"
+    table = Table(title=title, 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("Monthly", justify="right", footer=f"${est.monthly_total:,.2f}")
+    table.add_column("Confidence", justify="center")
     table.add_column("Notes", style="dim")
 
     comp_map = {c.id: c for c in spec.components}
-    for item in spec.cost_estimate.breakdown:
+    for item in est.breakdown:
         comp = comp_map.get(item.component_id)
         svc_label = comp.service if comp else item.service
+        conf_style = "green" if item.confidence == "high" else "yellow"
         table.add_row(
             item.component_id,
             svc_label,
             f"${item.monthly:,.2f}",
+            f"[{conf_style}]{item.confidence}[/{conf_style}]",
             item.notes,
         )
 
     console.print(table)
 
+    if est.pricing_confidence != "high":
+        console.print(
+            "[yellow]Pricing confidence: low[/yellow] — one or more services used formula/fallback "
+            "pricing, not real catalog data. Treat totals as rough estimates."
+        )
+
 
 def _print_multi_cloud_table(spec: ArchSpec, providers: list[str]) -> None:
     all_providers = [spec.provider] + [p for p in providers if p != spec.provider]
@@ -129,3 +180,29 @@ def _print_multi_cloud_table(spec: ArchSpec, providers: list[str]) -> None:
     table.add_row("[bold]TOTAL[/bold]", *totals)
 
     console.print(table)
+
+
+def _print_carbon_table(spec: ArchSpec, carbon: dict) -> None:
+    table = Table(title=f"Carbon Estimate — {spec.name} ({carbon['region']})")
+    table.add_column("Component", style="cyan")
+    table.add_column("Service")
+    table.add_column("Watts", justify="right")
+    table.add_column("kWh/mo", justify="right")
+    table.add_column("kgCO2e/mo", justify="right")
+
+    for item in carbon["breakdown"]:
+        table.add_row(
+            item["component_id"],
+            item["service"],
+            f"{item['watts']:.1f}",
+            f"{item['kwh_per_month']:.2f}",
+            f"{item['kg_co2e_per_month']:.3f}",
+        )
+
+    console.print(table)
+    console.print(
+        f"[bold]Total:[/bold] {carbon['total_kg_co2e_per_month']:.3f} kgCO2e/month  "
+        f"[dim](grid: {carbon['grid_intensity_g_per_kwh']} gCO2e/kWh, "
+        f"PUE: {carbon['assumptions']['pue']})[/dim]"
+    )
+    console.print(f"[dim]{carbon['assumptions']['disclaimer']}[/dim]")

{cloudwright_ai_cli-1.4.0 → cloudwright_ai_cli-1.6.0}/cloudwright_cli/commands/drift_cmd.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated, Any
 
 import typer
 from rich.console import Console
@@ -24,6 +24,17 @@ def drift(
     fmt: Annotated[
         str, typer.Option("--format", "-f", help="Infrastructure format: auto, terraform, cloudformation")
     ] = "auto",
+    remediate: Annotated[
+        bool,
+        typer.Option(
+            "--remediate",
+            help="Show cost/quality delta and terraform plan preview to close drift (read-only).",
+        ),
+    ] = False,
+    run_plan: Annotated[
+        bool,
+        typer.Option("--run-plan", help="With --remediate: attempt a real terraform plan (needs credentials)."),
+    ] = False,
 ) -> None:
     """Compare design spec against deployed infrastructure to detect drift."""
     try:
@@ -39,6 +50,10 @@ def drift(
         with console.status("Detecting drift..."):
             report = detect_drift(spec_file, infra_file, infra_format=fmt)
 
+        if remediate:
+            _run_remediate(ctx, report, run_plan=run_plan)
+            return
+
         if is_json_mode(ctx):
             result = {
                 "drift_score": report.drift_score,
@@ -94,3 +109,61 @@ def drift(
         raise
     except Exception as e:
         handle_error(ctx, e)
+
+
+def _run_remediate(ctx: typer.Context, report: Any, *, run_plan: bool) -> None:
+    from cloudwright.remediation import remediate as compute_remediation
+
+    with console.status("Computing remediation plan..."):
+        result = compute_remediation(report.deployed_spec, report.design_spec, run_plan=run_plan)
+
+    if is_json_mode(ctx):
+        emit_success(ctx, {"remediation": result})
+        return
+
+    console.print(Rule("[bold]Cloudwright Remediation Preview[/bold]"))
+    console.print(Panel(result["summary"], title="Summary"))
+
+    drift_items = result["drift"]
+    if drift_items:
+        table = Table(title=f"Changes to close drift ({len(drift_items)})")
+        table.add_column("Action", style="cyan")
+        table.add_column("Component")
+        table.add_column("Detail")
+        for item in drift_items:
+            action = item["change"]
+            cid = item.get("id", "")
+            detail = ""
+            if action == "modify":
+                detail = f"{item.get('field')}: {item.get('from')} -> {item.get('to')}"
+            elif action == "add":
+                detail = item.get("service", "")
+            elif action == "remove":
+                detail = item.get("service", "")
+            color = {"add": "green", "remove": "red", "modify": "yellow"}.get(action, "white")
+            table.add_row(f"[{color}]{action}[/{color}]", cid, detail)
+        console.print()
+        console.print(table)
+    else:
+        console.print("[green]No drift changes required.[/green]")
+
+    cd = result["cost_delta"]
+    sign = "+" if cd["delta"] >= 0 else ""
+    console.print(
+        f"\n[bold]Cost delta:[/bold] {sign}${cd['delta']:,.2f}/mo (${cd['current']:,.2f} -> ${cd['desired']:,.2f})"
+    )
+
+    qd = result["quality_delta"]
+    q_sign = "+" if qd["delta"] >= 0 else ""
+    q_color = "green" if qd["delta"] >= 0 else "red"
+    console.print(
+        f"[bold]Quality delta:[/bold] [{q_color}]{q_sign}{qd['delta']:.1f} pts[/{q_color}] "
+        f"(grade {qd['current_grade']} -> {qd['desired_grade']})"
+    )
+
+    plan = result["plan"]
+    plan_color = "green" if plan.get("ok") else "red"
+    plan_label = "valid" if plan.get("validated") else "not validated"
+    console.print(f"[bold]Plan ([/bold]{plan['tool']}[bold]):[/bold] [{plan_color}]{plan_label}[/{plan_color}]")
+    for msg in plan.get("messages", []):
+        console.print(f"  [dim]{msg}[/dim]")

cloudwright_ai_cli-1.6.0/cloudwright_cli/commands/import_live_cmd.py

@@ -0,0 +1,172 @@
+"""Import live cloud infrastructure into an ArchSpec via provider APIs.
+
+Supports AWS (boto3), GCP (google-cloud SDKs), and Azure (azure-mgmt SDKs):
+
+    cloudwright import-live --provider aws   --region us-east-1
+    cloudwright import-live --provider gcp   --project my-project
+    cloudwright import-live --provider azure --subscription <SUB_ID>
+"""
+
+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.output import emit_success, err_console, is_json_mode, validate_output_path
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def import_live(
+    ctx: typer.Context,
+    provider: Annotated[
+        str,
+        typer.Option("--provider", help="Cloud provider to scan: aws | gcp | azure"),
+    ] = "aws",
+    region: Annotated[
+        str,
+        typer.Option("--region", help="Cloud region (e.g. us-east-1). Recorded in metadata for gcp/azure."),
+    ] = "us-east-1",
+    profile: Annotated[
+        str | None,
+        typer.Option("--profile", help="AWS named profile (~/.aws/credentials)"),
+    ] = None,
+    project: Annotated[
+        str | None,
+        typer.Option("--project", help="GCP project ID (or set GOOGLE_CLOUD_PROJECT)"),
+    ] = None,
+    subscription: Annotated[
+        str | None,
+        typer.Option("--subscription", help="Azure subscription ID (or set AZURE_SUBSCRIPTION_ID)"),
+    ] = None,
+    services: Annotated[
+        str | None,
+        typer.Option(
+            "--services",
+            help="Comma-separated subset of services to scan. Default: all for the provider.",
+        ),
+    ] = 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:
+    """Walk live cloud APIs and produce an ArchSpec from running infrastructure."""
+    try:
+        provider_norm = (provider or "aws").lower()
+        if provider_norm == "google":
+            provider_norm = "gcp"
+        if provider_norm not in {"aws", "gcp", "azure"}:
+            raise typer.BadParameter(f"Unknown --provider {provider!r}. Supported: aws, gcp, azure.")
+
+        try:
+            from cloudwright.importer.live_aws import LiveImportError
+        except ImportError as exc:
+            err_console.print(
+                "[red]Live import core is unavailable.[/red] Install with: pip install 'cloudwright-ai[live-import]'"
+            )
+            raise typer.Exit(code=1) from exc
+
+        json_mode = is_json_mode(ctx)
+
+        def _progress(msg: str) -> None:
+            if not json_mode:
+                err_console.print(msg)
+
+        services_list: list[str] | None = None
+        if services:
+            services_list = [s.strip().lower() for s in services.split(",") if s.strip()]
+
+        scope_label = region
+        try:
+            if provider_norm == "aws":
+                from cloudwright.importer.live_aws import SUPPORTED_SERVICES, import_live_aws
+
+                _check_services(services_list, SUPPORTED_SERVICES)
+                spec = import_live_aws(
+                    region=region,
+                    profile=profile,
+                    services=services_list,
+                    progress=_progress,
+                    name=name,
+                )
+                scope_label = region
+            elif provider_norm == "gcp":
+                from cloudwright.importer.live_gcp import SUPPORTED_SERVICES, import_live_gcp
+
+                _check_services(services_list, SUPPORTED_SERVICES)
+                spec = import_live_gcp(
+                    project=project,
+                    region=region,
+                    services=services_list,
+                    progress=_progress,
+                    name=name,
+                )
+                scope_label = project or "project"
+            else:  # azure
+                from cloudwright.importer.live_azure import SUPPORTED_SERVICES, import_live_azure
+
+                _check_services(services_list, SUPPORTED_SERVICES)
+                spec = import_live_azure(
+                    subscription=subscription,
+                    region=region,
+                    services=services_list,
+                    progress=_progress,
+                    name=name,
+                )
+                scope_label = subscription or "subscription"
+        except LiveImportError as exc:
+            err_console.print(f"[red]error:[/red] {exc}")
+            raise typer.Exit(code=1) from exc
+
+        if name:
+            spec = spec.model_copy(update={"name": name})
+
+        if json_mode:
+            emit_success(ctx, {"spec": json.loads(spec.to_json())})
+            return
+
+        content = spec.to_yaml()
+        n_comps = len(spec.components)
+        n_bounds = len(spec.boundaries)
+
+        if output:
+            validate_output_path(output)
+            Path(output).write_text(content)
+            err_console.print()
+            err_console.print(
+                f"[green]Imported[/green] {n_comps} component(s), {n_bounds} boundary(ies) "
+                f"from {scope_label} -> [bold]{output}[/bold]"
+            )
+            err_console.print(f"Run [bold]cloudwright cost {output}[/bold] to estimate.")
+        else:
+            sys.stdout.write(content)
+            err_console.print()
+            err_console.print(
+                f"[green]Imported[/green] {n_comps} component(s), {n_bounds} boundary(ies) from {scope_label}"
+            )
+
+    except typer.Exit:
+        raise
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)
+
+
+def _check_services(services_list: list[str] | None, supported: tuple[str, ...]) -> None:
+    if not services_list:
+        return
+    unknown = [s for s in services_list if s not in supported]
+    if unknown:
+        raise typer.BadParameter(f"Unknown service(s): {sorted(set(unknown))}. Supported: {list(supported)}")

cloudwright_ai_cli-1.6.0/cloudwright_cli/commands/plan_cmd.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cloudwright_cli.output import emit_success, is_json_mode
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def plan(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to ArchSpec YAML file", exists=True)],
+    target: Annotated[
+        str,
+        typer.Option("--target", "-t", help="terraform | pulumi-python | pulumi-ts"),
+    ] = "terraform",
+    no_plan: Annotated[
+        bool,
+        typer.Option("--no-plan", help="Validate only; skip the credential-requiring plan/preview step"),
+    ] = False,
+    timeout: Annotated[int, typer.Option("--timeout", help="Seconds before the plan step is aborted")] = 180,
+) -> None:
+    """Prove the exported infrastructure is deployable.
+
+    Runs `terraform validate`/`plan` or `pulumi preview` against the generated
+    artifact. Read-only — nothing is applied. `validate` needs no credentials
+    and is the offline proof of deployability; `plan` adds a real resource
+    diff when cloud credentials are available.
+    """
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.planner import plan as run_plan
+
+        spec = ArchSpec.from_file(spec_file)
+        result = run_plan(spec, target=target, run_plan=not no_plan, timeout=timeout)
+
+        if is_json_mode(ctx):
+            emit_success(ctx, result.as_dict())
+            if not result.ok:
+                raise typer.Exit(1)
+            return
+
+        console.print(f"\nPlan ({result.tool}): {spec_file.name}\n")
+        if not result.available:
+            console.print(f"[yellow][SKIP][/yellow] {result.messages[0]}")
+            raise typer.Exit(1)
+
+        for msg in result.messages:
+            console.print(f"  {msg}")
+        if result.summary is not None:
+            s = result.summary
+            console.print(
+                f"\n  Resource diff: [green]+{s['add']}[/green] "
+                f"[yellow]~{s['change']}[/yellow] [red]-{s['destroy']}[/red]"
+            )
+        if result.output_tail:
+            console.print("\n[dim]--- tool output (tail) ---[/dim]")
+            console.print(f"[dim]{result.output_tail}[/dim]")
+
+        verdict = "DEPLOYABLE" if result.ok else "NOT DEPLOYABLE"
+        style = "green" if result.ok else "red"
+        plan_note = "" if result.plan_ran else " (validate only — no credentials for full plan)"
+        console.print(f"\nVerdict: [{style}]{verdict}[/{style}]{plan_note}")
+        if not result.ok:
+            raise typer.Exit(1)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_ai_cli-1.6.0/cloudwright_cli/commands/review_cmd.py

@@ -0,0 +1,78 @@
+"""Review an architecture with the deterministic critics (offline)."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cloudwright_cli.output import emit_success, is_json_mode
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+_SEV_COLOR = {"critical": "red", "high": "red", "medium": "yellow", "low": "cyan"}
+
+
+def review(
+    ctx: typer.Context,
+    spec_file: Annotated[str, typer.Argument(help="Path to ArchSpec YAML/JSON file")],
+    compliance: Annotated[str, typer.Option("--compliance", help="Comma-separated frameworks, e.g. hipaa,soc2")] = "",
+    well_architected: Annotated[
+        bool, typer.Option("--well-architected", help="Include Well-Architected checks")
+    ] = False,
+) -> None:
+    """Review an architecture: unified scorer + linter + validator findings (no LLM, free)."""
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.critique import critique
+
+        spec = ArchSpec.from_file(spec_file)
+        frameworks = [f.strip() for f in compliance.split(",") if f.strip()] or None
+        report = critique(spec, compliance=frameworks, well_architected=well_architected)
+
+        if is_json_mode(ctx):
+            emit_success(ctx, {"review": report.as_dict()})
+            return
+
+        border = "green" if not report.blocking else "red"
+        console.print(
+            Panel(
+                f"[bold]{report.summary_line()}[/bold]",
+                title=f"Architecture Review: {spec.name}",
+                border_style=border,
+            )
+        )
+
+        if not report.findings:
+            console.print("[green]No findings. This architecture passes every critic.[/green]")
+            return
+
+        table = Table(title="Findings (severity-ranked)")
+        table.add_column("Severity")
+        table.add_column("Source", style="dim")
+        table.add_column("Finding")
+        table.add_column("Fix")
+        for f in report.findings:
+            color = _SEV_COLOR.get(f.severity, "white")
+            table.add_row(
+                f"[{color}]{f.severity}[/{color}]",
+                f.source,
+                f.message,
+                (f.recommendation or "")[:80],
+            )
+        console.print(table)
+
+        if report.blocking:
+            console.print(
+                f"\n[red]{len(report.blocking)} blocking finding(s).[/red] "
+                "Run `cloudwright design` (repair is on by default) or fix these before deploy."
+            )
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

{cloudwright_ai_cli-1.4.0 → cloudwright_ai_cli-1.6.0}/cloudwright_cli/main.py

@@ -6,6 +6,7 @@ from cloudwright_cli.commands.analyze_cmd import analyze
 from cloudwright_cli.commands.catalog_cmd import catalog_app
 from cloudwright_cli.commands.chat import chat
 from cloudwright_cli.commands.compare import compare
+from cloudwright_cli.commands.compliance_cmd import compliance_scan
 from cloudwright_cli.commands.cost import cost
 from cloudwright_cli.commands.databricks_cmd import databricks_validate
 from cloudwright_cli.commands.design import design
@@ -18,8 +19,10 @@ from cloudwright_cli.commands.init_cmd import init
 from cloudwright_cli.commands.lint_cmd import lint
 from cloudwright_cli.commands.mcp_cmd import mcp_serve
 from cloudwright_cli.commands.modify_cmd import modify
+from cloudwright_cli.commands.plan_cmd import plan
 from cloudwright_cli.commands.policy import policy
 from cloudwright_cli.commands.refresh_cmd import refresh
+from cloudwright_cli.commands.review_cmd import review
 from cloudwright_cli.commands.schema_cmd import schema
 from cloudwright_cli.commands.score_cmd import score
 from cloudwright_cli.commands.security_cmd import security_scan
@@ -72,13 +75,16 @@ app.command(name="import")(import_infra)
 app.command(name="import-live")(import_live)
 app.command()(chat)
 app.command()(init)
+app.command()(plan)
 app.command()(policy)
 app.command()(score)
+app.command()(review)
 app.command()(analyze)
 app.command()(refresh)
 app.command()(lint)
 app.command()(databricks_validate)
 app.command(name="security")(security_scan)
+app.command(name="compliance")(compliance_scan)
 app.command(name="adr")(adr)
 app.command()(schema)
 app.command(name="mcp")(mcp_serve)

cloudwright_ai_cli-1.4.0/cloudwright_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.4.0"

cloudwright_ai_cli-1.4.0/cloudwright_cli/commands/import_live_cmd.py

@@ -1,136 +0,0 @@
-"""Import live cloud infrastructure into an ArchSpec via provider APIs.
-
-Currently supports AWS via boto3 (``cloudwright import-live --provider aws``).
-GCP and Azure surface a clear ``not yet implemented`` error.
-"""
-
-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.output import emit_success, err_console, is_json_mode, validate_output_path
-from cloudwright_cli.utils import handle_error
-
-console = Console()
-
-
-def import_live(
-    ctx: typer.Context,
-    provider: Annotated[
-        str,
-        typer.Option("--provider", help="Cloud provider to scan: aws (gcp, azure not yet implemented)"),
-    ] = "aws",
-    region: Annotated[
-        str,
-        typer.Option("--region", help="Cloud region (e.g. us-east-1)"),
-    ] = "us-east-1",
-    profile: Annotated[
-        str | None,
-        typer.Option("--profile", help="AWS named profile (~/.aws/credentials)"),
-    ] = None,
-    services: Annotated[
-        str | None,
-        typer.Option(
-            "--services",
-            help="Comma-separated subset of services to scan (e.g. ec2,rds,s3). Default: all.",
-        ),
-    ] = 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:
-    """Walk live AWS APIs and produce an ArchSpec from running infrastructure."""
-    try:
-        provider_norm = (provider or "aws").lower()
-        if provider_norm in {"gcp", "google", "azure"}:
-            raise typer.BadParameter(
-                f"--provider {provider!r} is not yet implemented. Only --provider aws is supported in v1.4."
-            )
-        if provider_norm != "aws":
-            raise typer.BadParameter(f"Unknown --provider {provider!r}. Supported: aws.")
-
-        try:
-            from cloudwright.importer.live_aws import (
-                SUPPORTED_SERVICES,
-                LiveImportError,
-                import_live_aws,
-            )
-        except ImportError as exc:
-            # boto3 not installed at all (cloudwright.importer.live_aws import boto3 lazily,
-            # but a missing core import surfaces here as a final fallback).
-            err_console.print(
-                "[red]boto3 is required for live AWS import.[/red] "
-                "Install with: pip install 'cloudwright-ai[live-import]'"
-            )
-            raise typer.Exit(code=1) from exc
-
-        services_list: list[str] | None = None
-        if services:
-            services_list = [s.strip().lower() for s in services.split(",") if s.strip()]
-            unknown = [s for s in services_list if s not in SUPPORTED_SERVICES]
-            if unknown:
-                raise typer.BadParameter(
-                    f"Unknown service(s): {sorted(set(unknown))}. Supported: {list(SUPPORTED_SERVICES)}"
-                )
-
-        json_mode = is_json_mode(ctx)
-
-        def _progress(msg: str) -> None:
-            if not json_mode:
-                err_console.print(msg)
-
-        try:
-            spec = import_live_aws(
-                region=region,
-                profile=profile,
-                services=services_list,
-                progress=_progress,
-                name=name,
-            )
-        except LiveImportError as exc:
-            # Clean error path — credentials missing, profile not found, etc.
-            err_console.print(f"[red]error:[/red] {exc}")
-            raise typer.Exit(code=1) from exc
-
-        if name:
-            spec = spec.model_copy(update={"name": name})
-
-        if json_mode:
-            emit_success(ctx, {"spec": json.loads(spec.to_json())})
-            return
-
-        content = spec.to_yaml()
-        n_comps = len(spec.components)
-        n_bounds = len(spec.boundaries)
-
-        if output:
-            validate_output_path(output)
-            Path(output).write_text(content)
-            err_console.print()
-            err_console.print(
-                f"[green]Imported[/green] {n_comps} component(s), {n_bounds} boundary(ies) "
-                f"from {region} -> [bold]{output}[/bold]"
-            )
-            err_console.print(f"Run [bold]cloudwright cost {output}[/bold] to estimate.")
-        else:
-            sys.stdout.write(content)
-            err_console.print()
-            err_console.print(f"[green]Imported[/green] {n_comps} component(s), {n_bounds} boundary(ies) from {region}")
-
-    except typer.Exit:
-        raise
-    except typer.BadParameter:
-        raise
-    except Exception as e:
-        handle_error(ctx, e)