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

cloudwright_cli/commands/lint_cmd.py

@@ -0,0 +1,91 @@
+"""Lint an architecture spec for anti-patterns."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def lint(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Architecture spec YAML file", exists=True)],
+    output: Annotated[str, typer.Option(help="Output format: text, json")] = "text",
+    strict: Annotated[bool, typer.Option(help="Fail on warnings too")] = False,
+) -> None:
+    """Detect architecture anti-patterns in a spec file."""
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.linter import lint as run_lint
+
+        spec = ArchSpec.from_file(spec_file)
+        warnings = run_lint(spec)
+
+        if output == "json":
+            result = [
+                {
+                    "rule": w.rule,
+                    "severity": w.severity,
+                    "component": w.component,
+                    "message": w.message,
+                    "recommendation": w.recommendation,
+                }
+                for w in warnings
+            ]
+            print(json.dumps(result, indent=2))
+        else:
+            if not warnings:
+                console.print(f"[green][PASS][/green] No anti-patterns detected in {spec.name}")
+            else:
+                table = Table(title=f"Lint Results: {spec.name}", show_lines=True)
+                table.add_column("Severity", width=9)
+                table.add_column("Rule", style="cyan")
+                table.add_column("Component")
+                table.add_column("Message")
+                table.add_column("Recommendation")
+
+                for w in warnings:
+                    if w.severity == "error":
+                        sev = Text("error", style="bold red")
+                    elif w.severity == "warning":
+                        sev = Text("warning", style="yellow")
+                    else:
+                        sev = Text("info", style="blue")
+
+                    table.add_row(
+                        sev,
+                        w.rule,
+                        w.component or "—",
+                        w.message,
+                        w.recommendation,
+                    )
+
+                console.print(table)
+
+                errors = [w for w in warnings if w.severity == "error"]
+                warns = [w for w in warnings if w.severity == "warning"]
+                console.print(
+                    f"\n[bold]{len(warnings)} finding(s)[/bold]: "
+                    f"[red]{len(errors)} error(s)[/red], "
+                    f"[yellow]{len(warns)} warning(s)[/yellow]"
+                )
+
+        has_errors = any(w.severity == "error" for w in warnings)
+        has_warnings = any(w.severity == "warning" for w in warnings)
+
+        if has_errors or (strict and has_warnings):
+            raise typer.Exit(1)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/modify_cmd.py

@@ -0,0 +1,125 @@
+"""Structured modify — modify a spec with natural language and show the diff."""
+
+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.syntax import Syntax
+from rich.table import Table
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def modify(
+    ctx: typer.Context,
+    spec_file: Annotated[str, typer.Argument(help="Path to the ArchSpec YAML to modify")],
+    instruction: Annotated[str, typer.Argument(help="Natural language modification instruction")],
+    output: Annotated[str | None, typer.Option("--output", "-o", help="Output file (default: overwrite input)")] = None,
+    dry_run: Annotated[bool, typer.Option("--dry-run", help="Show changes without writing")] = False,
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+) -> None:
+    """Modify an ArchSpec with natural language and show the diff."""
+    try:
+        from cloudwright import ArchSpec, Differ
+        from cloudwright.architect import Architect
+        from cloudwright.cost import CostEngine
+
+        spec_path = Path(spec_file)
+        if not spec_path.exists():
+            console.print(f"[red]Error:[/red] Spec file not found: {spec_file}")
+            raise typer.Exit(1)
+
+        original = ArchSpec.from_file(spec_path)
+
+        console.print(f"Modifying [cyan]{spec_file}[/cyan]: [yellow]{instruction}[/yellow]\n")
+
+        with console.status("Applying modification..."):
+            architect = Architect()
+            modified = architect.modify(original, instruction)
+
+        # Price both versions; ignore errors (catalog may not have all services)
+        cost_engine = CostEngine()
+        try:
+            original_costed = cost_engine.price(original)
+            modified_costed = cost_engine.price(modified)
+        except Exception:
+            original_costed = original
+            modified_costed = modified
+
+        diff_result = Differ().diff(original_costed, modified_costed)
+
+        if json_output:
+            import json
+
+            result = {
+                "original": original.model_dump(),
+                "modified": modified.model_dump(),
+                "diff": diff_result.model_dump(),
+            }
+            console.print_json(json.dumps(result, default=str))
+            return
+
+        console.print(Rule("[bold]Changes[/bold]"))
+
+        if not diff_result.added and not diff_result.removed and not diff_result.changed:
+            console.print("[dim]No structural changes detected.[/dim]")
+        else:
+            if diff_result.added:
+                console.print(f"[bold green]Added ({len(diff_result.added)})[/bold green]")
+                for comp in diff_result.added:
+                    console.print(f"  [green]+[/green] {comp.id} ({comp.service}) — {comp.label}")
+                console.print()
+
+            if diff_result.removed:
+                console.print(f"[bold red]Removed ({len(diff_result.removed)})[/bold red]")
+                for comp in diff_result.removed:
+                    console.print(f"  [red]-[/red] {comp.id} ({comp.service}) — {comp.label}")
+                console.print()
+
+            if diff_result.changed:
+                table = Table(title="Changed")
+                table.add_column("Component", style="cyan")
+                table.add_column("Field")
+                table.add_column("Before", style="red")
+                table.add_column("After", style="green")
+                for change in diff_result.changed:
+                    table.add_row(change.component_id, change.field, change.old_value, change.new_value)
+                console.print(table)
+                console.print()
+
+        if diff_result.cost_delta != 0.0:
+            sign = "+" if diff_result.cost_delta > 0 else ""
+            color = "red" if diff_result.cost_delta > 0 else "green"
+            console.print(f"Cost delta: [{color}]{sign}${diff_result.cost_delta:,.2f}/mo[/{color}]")
+
+        if diff_result.compliance_impact:
+            console.print("\n[bold red]Compliance Impact[/bold red]")
+            for impact in diff_result.compliance_impact:
+                console.print(f"  [red]![/red] {impact}")
+
+        console.print()
+        console.print(
+            Panel(
+                Syntax(modified.to_yaml(), "yaml", theme="monokai", word_wrap=True),
+                title="[bold cyan]Modified Spec[/bold cyan]",
+            )
+        )
+
+        if not dry_run:
+            out_path = Path(output) if output else spec_path
+            out_path.write_text(modified.to_yaml())
+            console.print(f"\n[green]Written to {out_path}[/green]")
+        else:
+            console.print("\n[dim]Dry run — no files written.[/dim]")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/policy.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import ArchSpec
+from cloudwright.cost import CostEngine
+from cloudwright.policy import PolicyEngine
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def policy(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to spec YAML file", exists=True)],
+    rules: Annotated[Path, typer.Option("--rules", "-r", help="Path to policy rules YAML file", exists=True)],
+) -> None:
+    """Evaluate an architecture spec against policy rules."""
+    try:
+        spec = ArchSpec.from_file(spec_file)
+        engine = PolicyEngine()
+
+        cost_estimate = spec.cost_estimate
+        if not cost_estimate:
+            cost_engine = CostEngine()
+            cost_estimate = cost_engine.estimate(spec)
+
+        result = engine.evaluate_from_file(spec, rules, cost_estimate=cost_estimate)
+
+        json_mode = ctx.obj.get("json", False) if ctx.obj else False
+        if json_mode:
+            print(json.dumps(result.model_dump(), default=str))
+            if not result.passed:
+                raise typer.Exit(1)
+            return
+
+        table = Table(title="Policy Evaluation")
+        table.add_column("Status", width=6)
+        table.add_column("Rule", style="cyan")
+        table.add_column("Severity")
+        table.add_column("Message", style="dim")
+
+        for check in result.results:
+            if check.passed:
+                status = "[green]PASS[/green]"
+            elif check.severity == "deny":
+                status = "[red]DENY[/red]"
+            elif check.severity == "warn":
+                status = "[yellow]WARN[/yellow]"
+            else:
+                status = "[blue]INFO[/blue]"
+
+            sev_colors = {"deny": "red", "warn": "yellow", "info": "blue"}
+            color = sev_colors.get(check.severity, "")
+            severity_display = f"[{color}]{check.severity.upper()}[/{color}]" if color else check.severity.upper()
+
+            table.add_row(status, check.rule, severity_display, check.message)
+
+        console.print(table)
+        console.print()
+
+        if result.passed:
+            console.print("[green]All policies passed.[/green]")
+        else:
+            parts = []
+            if result.deny_count:
+                parts.append(f"[red]{result.deny_count} denied[/red]")
+            if result.warn_count:
+                parts.append(f"[yellow]{result.warn_count} warnings[/yellow]")
+            console.print(f"Policy evaluation: {', '.join(parts)}")
+            if result.deny_count > 0:
+                raise typer.Exit(1)
+
+    except typer.Exit:
+        raise
+    except FileNotFoundError as e:
+        console.print(f"[red]Error:[/red] File not found: {e}")
+        raise typer.Exit(1)
+    except Exception as e:
+        verbose = ctx.obj.get("verbose", False) if ctx.obj else False
+        console.print(f"[red]Error:[/red] {e}")
+        if verbose:
+            console.print_exception()
+        raise typer.Exit(1)

cloudwright_cli/commands/refresh_cmd.py

@@ -0,0 +1,104 @@
+"""Refresh live pricing data from cloud provider APIs into the catalog."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def refresh(
+    ctx: typer.Context,
+    provider: Annotated[
+        str | None,
+        typer.Option("--provider", "-p", help="Provider to refresh: aws, gcp, azure (default: all)"),
+    ] = None,
+    category: Annotated[
+        str | None,
+        typer.Option("--category", "-c", help="Filter to a category: compute or a service name"),
+    ] = None,
+    region: Annotated[
+        str | None,
+        typer.Option("--region", "-r", help="Override the default region for pricing lookups"),
+    ] = None,
+    dry_run: Annotated[
+        bool,
+        typer.Option("--dry-run", help="Fetch but don't write to catalog DB"),
+    ] = False,
+) -> None:
+    """Refresh live pricing data from cloud provider APIs into the local catalog."""
+    try:
+        from cloudwright.catalog.refresh import refresh_catalog
+
+        providers_label = provider or "aws, gcp, azure"
+        with console.status(f"Fetching pricing for {providers_label}..."):
+            summary = refresh_catalog(
+                provider=provider,
+                category=category,
+                region=region,
+                dry_run=dry_run,
+            )
+
+        json_mode = ctx.obj and ctx.obj.get("json")
+
+        if json_mode:
+            data = {
+                "total_fetched": summary.total_fetched,
+                "total_errors": summary.total_errors,
+                "results": [
+                    {
+                        "provider": r.provider,
+                        "category": r.category,
+                        "instances_fetched": r.instances_fetched,
+                        "managed_services_fetched": r.managed_services_fetched,
+                        "errors": r.errors,
+                        "dry_run": r.dry_run,
+                    }
+                    for r in summary.results
+                ],
+            }
+            print(json.dumps(data, indent=2))
+            return
+
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Provider")
+        table.add_column("Category")
+        table.add_column("Instances", justify="right")
+        table.add_column("Managed", justify="right")
+        table.add_column("Errors", justify="right")
+
+        for r in summary.results:
+            error_str = str(len(r.errors)) if r.errors else "[green]0[/green]"
+            table.add_row(
+                r.provider,
+                r.category or "all",
+                str(r.instances_fetched),
+                str(r.managed_services_fetched),
+                error_str,
+            )
+
+        console.print(table)
+
+        suffix = " [dim](dry run)[/dim]" if dry_run else ""
+        if summary.total_errors == 0:
+            console.print(f"[green]Done.[/green] {summary.total_fetched} pricing records fetched{suffix}")
+        else:
+            console.print(
+                f"[yellow]Done with errors.[/yellow] "
+                f"{summary.total_fetched} fetched, {summary.total_errors} error(s){suffix}"
+            )
+            for r in summary.results:
+                for err in r.errors:
+                    console.print(f"  [red]{r.provider}:[/red] {err}")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/score_cmd.py

@@ -0,0 +1,80 @@
+"""Score an architecture's quality."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+
+def score(
+    ctx: typer.Context,
+    spec_file: Annotated[str, typer.Argument(help="Path to ArchSpec YAML/JSON file")],
+    with_cost: Annotated[bool, typer.Option("--with-cost", help="Run cost analysis before scoring")] = False,
+) -> None:
+    """Score an architecture's quality on 5 dimensions (0-100)."""
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.scorer import Scorer
+
+        spec = ArchSpec.from_file(spec_file)
+
+        if with_cost:
+            from cloudwright.cost import CostEngine
+
+            engine = CostEngine()
+            spec = engine.price(spec)
+
+        scorer = Scorer()
+        result = scorer.score(spec)
+
+        if ctx.obj and ctx.obj.get("json"):
+            print(json.dumps(result.to_dict(), indent=2))
+            return
+
+        border = "green" if result.overall >= 70 else "yellow" if result.overall >= 50 else "red"
+        console.print(
+            Panel(
+                f"[bold]Overall Score: {result.overall:.0f}/100[/bold]  Grade: [bold]{result.grade}[/bold]",
+                title=f"Architecture Quality: {spec.name}",
+                border_style=border,
+            )
+        )
+
+        table = Table(title="Dimension Breakdown")
+        table.add_column("Dimension", style="cyan")
+        table.add_column("Score", justify="right")
+        table.add_column("Weight", justify="right")
+        table.add_column("Weighted", justify="right")
+        table.add_column("Details")
+
+        for d in result.dimensions:
+            weighted = d.score * d.weight
+            color = "green" if d.score >= 70 else "yellow" if d.score >= 50 else "red"
+            table.add_row(
+                d.name,
+                f"[{color}]{d.score:.0f}[/{color}]",
+                f"{d.weight:.0%}",
+                f"{weighted:.1f}",
+                "; ".join(d.details[:2]) if d.details else "",
+            )
+
+        console.print(table)
+
+        if result.recommendations:
+            console.print("\n[bold]Top Recommendations:[/bold]")
+            for i, rec in enumerate(result.recommendations, 1):
+                console.print(f"  {i}. {rec}")
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)

cloudwright_cli/commands/validate.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from cloudwright import ArchSpec, Validator
+from rich.console import Console
+from rich.rule import Rule
+from rich.text import Text
+
+console = Console()
+
+
+def validate(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to spec YAML file", exists=True)],
+    compliance: Annotated[
+        str | None, typer.Option(help="Comma-separated compliance frameworks (hipaa, pci-dss, soc2)")
+    ] = None,
+    well_architected: Annotated[bool, typer.Option("--well-architected", help="Run well-architected review")] = False,
+    report: Annotated[
+        Path | None, typer.Option("--report", help="Write a markdown compliance report to this path")
+    ] = None,
+    pdf_report: Annotated[Path | None, typer.Option("--pdf", help="Write a PDF compliance report to this path")] = None,
+) -> None:
+    """Validate an architecture spec against compliance frameworks or well-architected principles."""
+    if not compliance and not well_architected:
+        console.print("[yellow]Specify --compliance and/or --well-architected.[/yellow]")
+        raise typer.Exit(1)
+
+    spec = ArchSpec.from_file(spec_file)
+    frameworks: list[str] = []
+
+    if compliance:
+        frameworks.extend(f.strip() for f in compliance.split(",") if f.strip())
+    if well_architected:
+        frameworks.append("well-architected")
+
+    wa = "well-architected" in frameworks
+    compliance_only = [f for f in frameworks if f != "well-architected"]
+
+    with console.status("Running validation..."):
+        results = Validator().validate(spec, compliance_only, well_architected=wa)
+
+    if report and results:
+        from cloudwright.exporter.compliance_report import render as render_report
+
+        # Generate one report per framework; if multiple, use the first or merge
+        report_text = "\n\n---\n\n".join(render_report(spec, r) for r in results)
+        report.write_text(report_text)
+        console.print(f"[green]Compliance report written to {report}[/green]")
+
+    if pdf_report and results:
+        from cloudwright.exporter.compliance_report import render_pdf
+
+        for r in results:
+            if len(results) > 1:
+                out_path = pdf_report.parent / f"{pdf_report.stem}_{r.framework}{pdf_report.suffix}"
+            else:
+                out_path = pdf_report
+            render_pdf(spec, r, str(out_path))
+            console.print(f"[green]PDF compliance report written to {out_path}[/green]")
+
+    if ctx.obj and ctx.obj.get("json"):
+        import json
+
+        print(json.dumps({"results": [r.model_dump() for r in results]}, default=str))
+        return
+
+    any_failed = False
+    for result in results:
+        title = _framework_title(result.framework)
+        console.print(Rule(f"[bold]{title}[/bold]"))
+
+        passed_count = sum(1 for c in result.checks if c.passed)
+        total = len(result.checks)
+
+        for check in result.checks:
+            status = Text("[PASS]", style="green") if check.passed else Text("[FAIL]", style="red")
+            line = Text()
+            line.append_text(status)
+            line.append(f" {check.name}")
+            if check.detail:
+                line.append(f" — {check.detail}", style="dim")
+            console.print(line)
+
+            if not check.passed and check.recommendation:
+                console.print(f"       [dim]Recommendation: {check.recommendation}[/dim]")
+                any_failed = True
+
+        pct = int(result.score * 100) if result.score <= 1 else int(result.score)
+        console.print(f"Score: {passed_count}/{total} ({pct}%)\n")
+
+    if any_failed:
+        raise typer.Exit(1)
+
+
+def _framework_title(framework: str) -> str:
+    titles = {
+        "hipaa": "HIPAA Compliance Review",
+        "pci-dss": "PCI-DSS Compliance Review",
+        "soc2": "SOC 2 Compliance Review",
+        "well-architected": "Well-Architected Review",
+    }
+    return titles.get(framework.lower(), f"{framework.upper()} Review")

cloudwright_cli/main.py

@@ -0,0 +1,66 @@
+import typer
+
+from cloudwright_cli import __version__
+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.cost import cost
+from cloudwright_cli.commands.design import design
+from cloudwright_cli.commands.diff import diff
+from cloudwright_cli.commands.drift_cmd import drift
+from cloudwright_cli.commands.export import export
+from cloudwright_cli.commands.import_cmd import import_infra
+from cloudwright_cli.commands.init_cmd import init
+from cloudwright_cli.commands.lint_cmd import lint
+from cloudwright_cli.commands.modify_cmd import modify
+from cloudwright_cli.commands.policy import policy
+from cloudwright_cli.commands.refresh_cmd import refresh
+from cloudwright_cli.commands.score_cmd import score
+from cloudwright_cli.commands.validate import validate
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(f"cloudwright {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="cloudwright",
+    help="Architecture intelligence for cloud engineers",
+    no_args_is_help=True,
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(
+        False, "--version", "-V", help="Show version", callback=_version_callback, is_eager=True
+    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
+    json_output: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["json"] = json_output
+
+
+app.command()(design)
+app.command()(cost)
+app.command()(compare)
+app.command()(validate)
+app.command()(export)
+app.command()(diff)
+app.command()(drift)
+app.command()(modify)
+app.command(name="import")(import_infra)
+app.command()(chat)
+app.command()(init)
+app.command()(policy)
+app.command()(score)
+app.command()(analyze)
+app.command()(refresh)
+app.command()(lint)
+app.add_typer(catalog_app, name="catalog")