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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cloudwright-ai-cli
-Version: 1.2.2
+Version: 1.4.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.4.0/cloudwright_cli/__init__.py

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

{cloudwright_ai_cli-1.2.2 → cloudwright_ai_cli-1.4.0}/cloudwright_cli/commands/chat.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
 import logging
-import sys
+import os
 import time
 from typing import Annotated
 
 import typer
 from cloudwright import ArchSpec, ConversationSession
 from cloudwright.ascii_diagram import render_ascii
+from cloudwright.logging import configure_logging
 from cloudwright.session_store import SessionStore
 from rich.console import Console
 from rich.live import Live
@@ -23,21 +24,27 @@ from .chat_ui import _HELP, print_cost_summary, print_diff, run_validate
 
 console = Console()
 
+DEFAULT_WEB_PORT = 8765
+
 
 def chat(
     web: Annotated[bool, typer.Option("--web", help="Launch web UI instead of terminal chat")] = False,
     resume: Annotated[str | None, typer.Option("--resume", help="Resume a saved session by ID")] = None,
     debug: Annotated[bool, typer.Option("--debug", help="Log LLM requests/responses to stderr")] = False,
+    port: Annotated[
+        int,
+        typer.Option("--port", help=f"Port for --web (default: {DEFAULT_WEB_PORT})"),
+    ] = DEFAULT_WEB_PORT,
 ) -> None:
     """Interactive architecture design chat."""
     if web:
-        _launch_web()
+        _launch_web(port=port)
         return
 
     _run_terminal_chat(resume=resume, debug=debug)
 
 
-def _launch_web() -> None:
+def _launch_web(port: int = DEFAULT_WEB_PORT) -> None:
     try:
         import cloudwright_web  # type: ignore
         import uvicorn
@@ -49,18 +56,19 @@ def _launch_web() -> None:
 
     import socket
 
-    port = 8000
-    for candidate in range(8000, 8100):
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            if s.connect_ex(("127.0.0.1", candidate)) != 0:
-                port = candidate
-                break
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        if s.connect_ex(("127.0.0.1", port)) == 0:
+            console.print(
+                f"[red]Error:[/red] port {port} is already in use. "
+                f"Pass --port to choose another (e.g. --port {port + 1})."
+            )
+            raise typer.Exit(1)
 
     import threading
     import webbrowser
 
     url = f"http://127.0.0.1:{port}"
-    console.print(f"[cyan]Launching Cloudwright web UI on {url}[/cyan]")
+    console.print(f"\n[bold cyan]Cloudwright web UI:[/bold cyan] {url}\n")
 
     def _open_browser():
         time.sleep(1.5)
@@ -71,8 +79,14 @@ def _launch_web() -> None:
 
 
 def _run_terminal_chat(resume: str | None = None, debug: bool = False) -> None:
-    if debug:
-        logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
+    configure_logging()
+    env_level = os.environ.get("CLOUDWRIGHT_LOG_LEVEL", "").upper()
+    if debug or env_level == "DEBUG":
+        logging.getLogger().setLevel(logging.DEBUG)
+        logging.getLogger("cloudwright").setLevel(logging.DEBUG)
+    elif env_level in {"INFO", "WARNING", "ERROR", "CRITICAL"}:
+        logging.getLogger().setLevel(getattr(logging, env_level))
+        logging.getLogger("cloudwright").setLevel(getattr(logging, env_level))
 
     console.print(
         Panel(

{cloudwright_ai_cli-1.2.2 → cloudwright_ai_cli-1.4.0}/cloudwright_cli/commands/chat_ui.py

@@ -16,7 +16,7 @@ Commands:
   /yaml                     Show YAML for last architecture
   /cost                     Show cost estimate for last architecture
   /validate [fw]            Run compliance check (hipaa, pci-dss, soc2, fedramp, gdpr)
-  /export <fmt>             Export last architecture (terraform, mermaid, d2, cloudformation, sbom, aibom)
+  /export <fmt>             Export last architecture (terraform, pulumi-ts, pulumi-python, mermaid, d2, cloudformation, sbom, aibom)
   /terraform                Export last architecture as Terraform
   /new                      Start a new architecture from scratch
   /help, /?                 Show this help

{cloudwright_ai_cli-1.2.2 → cloudwright_ai_cli-1.4.0}/cloudwright_cli/commands/export.py

@@ -15,6 +15,10 @@ console = Console()
 
 _SYNTAX_MAP = {
     "terraform": "hcl",
+    "pulumi-ts": "typescript",
+    "pulumi-typescript": "typescript",
+    "pulumi-python": "python",
+    "pulumi-py": "python",
     "cloudformation": "yaml",
     "mermaid": "text",
     "d2": "text",
@@ -25,6 +29,26 @@ _SYNTAX_MAP = {
     "aibom": "json",
 }
 
+# Formats that produce a multi-file project layout when --output points at a
+# directory (or any extensionless path). Keep in sync with the dispatch in
+# cloudwright.exporter.export_spec.
+_DIRECTORY_FORMATS = {
+    "terraform",
+    "pulumi-ts",
+    "pulumi-typescript",
+    "pulumi-python",
+    "pulumi-py",
+}
+
+# Primary entry filename per directory-format, used only for status messages.
+_DIRECTORY_ENTRY = {
+    "terraform": "main.tf",
+    "pulumi-ts": "index.ts",
+    "pulumi-typescript": "index.ts",
+    "pulumi-python": "__main__.py",
+    "pulumi-py": "__main__.py",
+}
+
 
 def export(
     ctx: typer.Context,
@@ -39,9 +63,10 @@ def export(
     ],
     output: Annotated[Path | None, typer.Option("--output", "-o", help="Output file or directory")] = None,
 ) -> None:
-    """Export an architecture spec to Terraform, CloudFormation, Mermaid, SVG, PNG, SBOM, or AIBOM."""
+    """Export an architecture spec to Terraform, Pulumi (TS/Python), CloudFormation, Mermaid, SVG, PNG, SBOM, or AIBOM."""
     fmt = format.lower().strip()
-    if fmt not in FORMATS and fmt != "cfn":
+    _aliases = {"cfn", "pulumi-typescript", "pulumi-py"}
+    if fmt not in FORMATS and fmt not in _aliases:
         emit_error(ctx, ValueError(f"Unknown format {fmt!r}"), action=f"Use one of: {', '.join(FORMATS)}")
 
     if output:
@@ -55,11 +80,11 @@ def export(
     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():
+    # Terraform / Pulumi with a directory target writes a project layout in the dir
+    if fmt in _DIRECTORY_FORMATS and output and output.is_dir():
         output_dir_str = output_str
         output_str = None
-    elif fmt == "terraform" and output and not output.suffix:
+    elif fmt in _DIRECTORY_FORMATS and output and not output.suffix:
         # Treat extensionless output as a directory path
         output_dir_str = output_str
         output_str = None
@@ -104,7 +129,8 @@ def export(
 
     if output:
         if output_dir_str:
-            console.print(f"[green]Written to {output_dir_str}/main.tf[/green]")
+            entry = _DIRECTORY_ENTRY.get(fmt, "main.tf")
+            console.print(f"[green]Written to {output_dir_str}/{entry}[/green]")
         else:
             console.print(f"[green]Written to {output}[/green]")
     else:

cloudwright_ai_cli-1.4.0/cloudwright_cli/commands/import_live_cmd.py

@@ -0,0 +1,136 @@
+"""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)

{cloudwright_ai_cli-1.2.2 → cloudwright_ai_cli-1.4.0}/cloudwright_cli/completions.py

@@ -47,6 +47,8 @@ def complete_workload_profile(incomplete: str) -> list[tuple[str, str]]:
 def complete_export_format(incomplete: str) -> list[tuple[str, str]]:
     formats = [
         ("terraform", "HashiCorp Terraform HCL"),
+        ("pulumi-ts", "Pulumi TypeScript (@pulumi/aws, @pulumi/gcp, @pulumi/azure-native)"),
+        ("pulumi-python", "Pulumi Python (pulumi_aws, pulumi_gcp, pulumi_azure_native)"),
         ("cloudformation", "AWS CloudFormation YAML"),
         ("mermaid", "Mermaid diagram syntax"),
         ("d2", "D2 diagram language"),

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

@@ -13,6 +13,7 @@ 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.import_live_cmd import import_live
 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
@@ -68,6 +69,7 @@ app.command()(diff)
 app.command()(drift)
 app.command()(modify)
 app.command(name="import")(import_infra)
+app.command(name="import-live")(import_live)
 app.command()(chat)
 app.command()(init)
 app.command()(policy)

cloudwright_ai_cli-1.4.0/tests/test_chat_debug.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import logging
+from unittest.mock import patch
+
+
+class TestDebugMode:
+    def test_debug_enables_logging(self):
+        """--debug flag should set the cloudwright logger to DEBUG level.
+
+        Audit fix v1.3: previously called logging.basicConfig() which is a
+        no-op against the structlog-configured root logger. Now it sets
+        DEBUG on the root + cloudwright logger directly.
+        """
+        cloudwright_logger = logging.getLogger("cloudwright")
+        prior_level = cloudwright_logger.level
+        try:
+            with (
+                patch("cloudwright_cli.commands.chat.ConversationSession"),
+                patch("cloudwright_cli.commands.chat.SessionStore"),
+                patch("cloudwright_cli.commands.chat.Prompt.ask", side_effect=[KeyboardInterrupt]),
+            ):
+                from cloudwright_cli.commands.chat import _run_terminal_chat
+
+                _run_terminal_chat(debug=True)
+
+            assert cloudwright_logger.level == logging.DEBUG
+        finally:
+            cloudwright_logger.setLevel(prior_level)
+
+    def test_debug_flag_via_chat_entrypoint(self):
+        with (
+            patch("cloudwright_cli.commands.chat._run_terminal_chat") as mock_run,
+            patch("cloudwright_cli.commands.chat._launch_web"),
+        ):
+            from cloudwright_cli.commands.chat import chat
+
+            chat(web=False, resume=None, debug=True)
+
+        # The chat() entrypoint may pass extra args (port). Just assert debug=True.
+        assert mock_run.call_count == 1
+        kwargs = mock_run.call_args.kwargs
+        assert kwargs.get("debug") is True
+
+    def test_no_debug_flag_via_chat_entrypoint(self):
+        with (
+            patch("cloudwright_cli.commands.chat._run_terminal_chat") as mock_run,
+            patch("cloudwright_cli.commands.chat._launch_web"),
+        ):
+            from cloudwright_cli.commands.chat import chat
+
+            chat(web=False, resume=None, debug=False)
+
+        assert mock_run.call_count == 1
+        assert mock_run.call_args.kwargs.get("debug") is False
+
+    def test_log_level_env_var_debug(self, monkeypatch):
+        """CLOUDWRIGHT_LOG_LEVEL=DEBUG should also set DEBUG even without --debug."""
+        monkeypatch.setenv("CLOUDWRIGHT_LOG_LEVEL", "DEBUG")
+        cloudwright_logger = logging.getLogger("cloudwright")
+        prior_level = cloudwright_logger.level
+        try:
+            with (
+                patch("cloudwright_cli.commands.chat.ConversationSession"),
+                patch("cloudwright_cli.commands.chat.SessionStore"),
+                patch("cloudwright_cli.commands.chat.Prompt.ask", side_effect=[KeyboardInterrupt]),
+            ):
+                from cloudwright_cli.commands.chat import _run_terminal_chat
+
+                _run_terminal_chat(debug=False)
+
+            assert cloudwright_logger.level == logging.DEBUG
+        finally:
+            cloudwright_logger.setLevel(prior_level)

cloudwright_ai_cli-1.2.2/cloudwright_cli/__init__.py

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

cloudwright_ai_cli-1.2.2/tests/test_chat_debug.py

@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-import logging
-import sys
-from unittest.mock import patch
-
-
-class TestDebugMode:
-    def test_debug_enables_logging(self):
-        with (
-            patch("cloudwright_cli.commands.chat.ConversationSession"),
-            patch("cloudwright_cli.commands.chat.SessionStore"),
-            patch("cloudwright_cli.commands.chat.Prompt.ask", side_effect=[KeyboardInterrupt]),
-            patch("logging.basicConfig") as mock_basic,
-        ):
-            from cloudwright_cli.commands.chat import _run_terminal_chat
-
-            _run_terminal_chat(debug=True)
-
-        mock_basic.assert_called_once_with(stream=sys.stderr, level=logging.DEBUG)
-
-    def test_no_debug_by_default(self):
-        with (
-            patch("cloudwright_cli.commands.chat.ConversationSession"),
-            patch("cloudwright_cli.commands.chat.SessionStore"),
-            patch("cloudwright_cli.commands.chat.Prompt.ask", side_effect=[KeyboardInterrupt]),
-            patch("logging.basicConfig") as mock_basic,
-        ):
-            from cloudwright_cli.commands.chat import _run_terminal_chat
-
-            _run_terminal_chat(debug=False)
-
-        mock_basic.assert_not_called()
-
-    def test_debug_flag_via_chat_entrypoint(self):
-        with (
-            patch("cloudwright_cli.commands.chat._run_terminal_chat") as mock_run,
-            patch("cloudwright_cli.commands.chat._launch_web"),
-        ):
-            from cloudwright_cli.commands.chat import chat
-
-            chat(web=False, resume=None, debug=True)
-
-        mock_run.assert_called_once_with(resume=None, debug=True)
-
-    def test_no_debug_flag_via_chat_entrypoint(self):
-        with (
-            patch("cloudwright_cli.commands.chat._run_terminal_chat") as mock_run,
-            patch("cloudwright_cli.commands.chat._launch_web"),
-        ):
-            from cloudwright_cli.commands.chat import chat
-
-            chat(web=False, resume=None, debug=False)
-
-        mock_run.assert_called_once_with(resume=None, debug=False)