cloudwright-ai-cli 0.2.27__tar.gz → 0.3.0__tar.gz

{cloudwright_ai_cli-0.2.27 → cloudwright_ai_cli-0.3.0}/PKG-INFO

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

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

cloudwright_ai_cli-0.3.0/cloudwright_cli/commands/adr.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+_ADR_SYSTEM = """You generate Architecture Decision Records (ADRs) in MADR format.
+
+Given an architecture spec as JSON, produce a markdown ADR with this exact structure:
+
+# ADR: {name} — {key decision}
+
+## Status
+Proposed
+
+## Context
+{problem and why a decision is needed}
+
+## Decision
+{the chosen architecture and key choices}
+
+## Components
+| ID | Service | Provider | Purpose |
+|---|---|---|---|
+{component rows}
+
+## Consequences
+### Positive
+- {benefits}
+
+### Negative
+- {trade-offs and risks}
+
+## Alternatives Considered
+{alternatives if any, otherwise note none documented}
+
+## Cost Estimate
+{monthly cost if available, otherwise omit}
+
+Be concise. Focus on the WHY, not just what the architecture contains.
+Respond with ONLY the markdown — no explanation, no code fences."""
+
+
+def adr(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to ArchSpec YAML file", exists=True)],
+    output: Annotated[str | None, typer.Option("--output", "-o", help="Write ADR to this file")] = None,
+    title: Annotated[str | None, typer.Option("--title", help="ADR title (default: auto-generated)")] = None,
+    decision: Annotated[str | None, typer.Option("--decision", help="Specific decision to document")] = None,
+) -> None:
+    """Generate an Architecture Decision Record from an ArchSpec."""
+    try:
+        from cloudwright import ArchSpec
+
+        spec = ArchSpec.from_file(spec_file)
+        text = _generate_adr(spec, title=title, decision=decision)
+
+        if output:
+            Path(output).write_text(text)
+            console.print(f"[green]ADR written to {output}[/green]")
+        else:
+            print(text)
+
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(ctx, e)
+
+
+def _generate_adr(spec, *, title: str | None = None, decision: str | None = None) -> str:
+    try:
+        return _llm_adr(spec, title=title, decision=decision)
+    except Exception:
+        return _deterministic_adr(spec, title=title, decision=decision)
+
+
+def _llm_adr(spec, *, title: str | None, decision: str | None) -> str:
+    from cloudwright.architect import Architect
+
+    arch = Architect()
+    spec_summary = spec.model_dump_json(indent=2, exclude_none=True)
+
+    decision_hint = f"\nDocument this specific decision: {decision}" if decision else ""
+    title_hint = f"\nUse this ADR title: {title}" if title else ""
+    prompt = f"Generate an ADR for this architecture:{title_hint}{decision_hint}\n\n{spec_summary}"
+
+    text, _ = arch.llm.generate([{"role": "user", "content": prompt}], _ADR_SYSTEM, max_tokens=2000)
+    if not text.strip().startswith("#"):
+        raise ValueError("LLM did not return markdown ADR")
+    return text.strip()
+
+
+def _deterministic_adr(spec, *, title: str | None = None, decision: str | None = None) -> str:
+    adr_title = title or spec.name
+    key_decision = decision or _infer_key_decision(spec)
+
+    lines = [
+        f"# ADR: {adr_title} — {key_decision}",
+        "",
+        "## Status",
+        "Proposed",
+        "",
+        "## Context",
+        _build_context(spec),
+        "",
+        "## Decision",
+        _build_decision(spec),
+        "",
+        "## Components",
+        "| ID | Service | Provider | Purpose |",
+        "|---|---|---|---|",
+    ]
+
+    for c in spec.components:
+        purpose = c.description or c.label
+        lines.append(f"| {c.id} | {c.service} | {c.provider} | {purpose} |")
+
+    lines += ["", "## Consequences"]
+    lines += _build_consequences(spec)
+
+    rationale = spec.metadata.get("rationale") or []
+    if rationale:
+        lines += ["", "## Alternatives Considered"]
+        for r in rationale:
+            if isinstance(r, dict):
+                lines.append(f"- **{r.get('decision', '')}**: {r.get('reason', '')}")
+
+    if spec.cost_estimate:
+        lines += [
+            "",
+            "## Cost Estimate",
+            f"Estimated monthly cost: ${spec.cost_estimate.monthly_total:,.2f} USD",
+        ]
+
+    return "\n".join(lines)
+
+
+def _infer_key_decision(spec) -> str:
+    rationale = spec.metadata.get("rationale") or []
+    if rationale and isinstance(rationale[0], dict):
+        return rationale[0].get("decision", f"{spec.provider.upper()} architecture")
+    return f"{spec.provider.upper()} architecture"
+
+
+def _build_context(spec) -> str:
+    parts = [f"This architecture, {spec.name!r}, targets the {spec.provider.upper()} platform in region {spec.region}."]
+    if spec.constraints:
+        if spec.constraints.compliance:
+            parts.append(f"Compliance requirements: {', '.join(spec.constraints.compliance)}.")
+        if spec.constraints.budget_monthly:
+            parts.append(f"Monthly budget constraint: ${spec.constraints.budget_monthly:,.0f}.")
+    parts.append(f"It consists of {len(spec.components)} components across {len(spec.connections)} connections.")
+    return " ".join(parts)
+
+
+def _build_decision(spec) -> str:
+    rationale = spec.metadata.get("rationale") or []
+    if rationale:
+        items = []
+        for r in rationale:
+            if isinstance(r, dict):
+                items.append(f"- **{r.get('decision', '')}**: {r.get('reason', '')}")
+        if items:
+            return "\n".join(items)
+
+    services = ", ".join(c.service for c in spec.components[:5])
+    suffix = ", ..." if len(spec.components) > 5 else ""
+    return f"Selected architecture using: {services}{suffix}."
+
+
+def _build_consequences(spec) -> list[str]:
+    lines = ["### Positive"]
+    suggestions = spec.metadata.get("suggestions") or []
+
+    positives = [
+        f"Established {spec.provider.upper()} native services reduce operational overhead.",
+        f"{len(spec.components)} components provide clear separation of concerns.",
+    ]
+    lines += [f"- {p}" for p in positives]
+
+    lines += ["", "### Negative"]
+    negatives = ["Vendor lock-in to selected provider and service tier."]
+    if suggestions:
+        negatives.append("Additional configuration required: " + suggestions[0].lower() + ".")
+    lines += [f"- {n}" for n in negatives]
+
+    return lines

cloudwright_ai_cli-0.3.0/cloudwright_cli/commands/security_cmd.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.text import Text
+
+from cloudwright_cli.utils import handle_error
+
+console = Console()
+
+_SEVERITY_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3, "none": 4}
+
+
+def security_scan(
+    ctx: typer.Context,
+    spec_file: Annotated[Path, typer.Argument(help="Path to ArchSpec YAML file", exists=True)],
+    fail_on: Annotated[str, typer.Option("--fail-on", help="Fail on: critical, high, medium, none")] = "high",
+    output: Annotated[str | None, typer.Option("--output", "-o")] = None,
+) -> None:
+    """Scan an ArchSpec for security anti-patterns and misconfigurations."""
+    try:
+        from cloudwright import ArchSpec
+        from cloudwright.security import SecurityScanner
+
+        spec = ArchSpec.from_file(spec_file)
+        report = SecurityScanner().scan(spec)
+
+        if ctx.obj and ctx.obj.get("json"):
+            result = {
+                "passed": report.passed,
+                "findings": [
+                    {
+                        "severity": f.severity,
+                        "rule": f.rule,
+                        "component_id": f.component_id,
+                        "message": f.message,
+                        "remediation": f.remediation,
+                    }
+                    for f in report.findings
+                ],
+            }
+            print(json.dumps(result, indent=2))
+            _maybe_exit(report, fail_on)
+            return
+
+        console.print(f"\nSecurity Scan: {spec_file.name}\n")
+
+        if not report.findings:
+            console.print("[green][PASS][/green] No security findings detected.")
+        else:
+            for f in report.findings:
+                sev_upper = f.severity.upper()
+                if f.severity == "critical":
+                    sev_text = Text(f"[{sev_upper}]", style="bold red")
+                elif f.severity == "high":
+                    sev_text = Text(f"[{sev_upper}]", style="red")
+                elif f.severity == "medium":
+                    sev_text = Text(f"[{sev_upper}]", style="yellow")
+                else:
+                    sev_text = Text(f"[{sev_upper}]", style="dim")
+
+                line = Text("  ")
+                line.append_text(sev_text)
+                line.append(f" {f.message}")
+                console.print(line)
+                console.print(f"           Remediation: {f.remediation}", style="dim")
+                console.print()
+
+        total = len(report.findings)
+        crit = report.critical_count
+        high = report.high_count
+        med = sum(1 for f in report.findings if f.severity == "medium")
+
+        console.print(f"{total} finding(s) ({crit} critical, {high} high, {med} medium)")
+
+        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"
+        style = "green" if status == "PASSED" else "red"
+        console.print(f"Status: [{style}]{status}[/{style}] (fail-on={fail_on})")
+
+        _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-0.2.27 → cloudwright_ai_cli-0.3.0}/cloudwright_cli/main.py

@@ -1,6 +1,7 @@
 import typer
 
 from cloudwright_cli import __version__
+from cloudwright_cli.commands.adr import adr
 from cloudwright_cli.commands.analyze_cmd import analyze
 from cloudwright_cli.commands.catalog_cmd import catalog_app
 from cloudwright_cli.commands.chat import chat
@@ -18,6 +19,7 @@ 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.security_cmd import security_scan
 from cloudwright_cli.commands.validate import validate
 
 
@@ -65,4 +67,6 @@ app.command()(analyze)
 app.command()(refresh)
 app.command()(lint)
 app.command()(databricks_validate)
+app.command(name="security")(security_scan)
+app.command(name="adr")(adr)
 app.add_typer(catalog_app, name="catalog")

cloudwright_ai_cli-0.2.27/cloudwright_cli/__init__.py

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