cloudwright-ai-mcp 0.3.1__tar.gz

cloudwright_ai_mcp-0.3.1/.gitignore

@@ -0,0 +1,20 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.env
+*.db
+!packages/core/cloudwright/data/catalog.db
+node_modules/
+.vite/
+.ruff_cache/
+.pytest_cache/
+.mypy_cache/
+
+# AI tooling
+.claude/
+.planning/
+CLAUDE.md
+packages/*/CLAUDE.md
+docs/fix-plan.md

cloudwright_ai_mcp-0.3.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cloudwright-ai-mcp
+Version: 0.3.1
+Summary: MCP server for Cloudwright architecture intelligence
+Project-URL: Homepage, https://github.com/xmpuspus/cloudwright
+Author: Xavier Puspus
+License-Expression: MIT
+Requires-Python: >=3.12
+Requires-Dist: cloudwright-ai<1,>=0.3.0
+Requires-Dist: mcp<2,>=1.12

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/__init__.py

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

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/serializers.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import dataclasses
+
+
+def security_report_to_dict(report) -> dict:
+    return {
+        "passed": report.passed,
+        "critical_count": report.critical_count,
+        "high_count": report.high_count,
+        "findings": [dataclasses.asdict(f) for f in report.findings],
+    }
+
+
+def lint_warnings_to_dict(warnings) -> list[dict]:
+    return [dataclasses.asdict(w) for w in warnings]
+
+
+def score_result_to_dict(result) -> dict:
+    return result.to_dict()
+
+
+def analysis_result_to_dict(result) -> dict:
+    return result.to_dict()

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/server.py

@@ -0,0 +1,32 @@
+"""FastMCP server for Cloudwright architecture intelligence."""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+from cloudwright_mcp.tools import analyze, cost, design, export, session, validate
+
+_GROUPS = {
+    "design": design,
+    "cost": cost,
+    "validate": validate,
+    "analyze": analyze,
+    "export": export,
+    "session": session,
+}
+
+
+def create_server(tools: set[str] | None = None) -> FastMCP:
+    """Create a FastMCP server with selected tool groups.
+
+    Args:
+        tools: Set of group names to register. None = all groups.
+               Valid groups: design, cost, validate, analyze, export, session.
+    """
+    mcp = FastMCP("cloudwright", description="Architecture intelligence for cloud engineers")
+
+    for name, module in _GROUPS.items():
+        if tools is None or name in tools:
+            module.register(mcp)
+
+    return mcp

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/analyze.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def analyze_blast_radius(spec_json: dict, component_id: str | None = None) -> dict:
+        """Analyze blast radius and dependency structure of an architecture."""
+        from cloudwright.analyzer import Analyzer
+        from cloudwright.spec import ArchSpec
+
+        from cloudwright_mcp.serializers import analysis_result_to_dict
+
+        spec = ArchSpec.model_validate(spec_json)
+        result = Analyzer().analyze(spec, component_id=component_id)
+        return analysis_result_to_dict(result)
+
+    @mcp.tool()
+    def score_architecture(spec_json: dict) -> dict:
+        """Score an architecture across reliability, security, cost, compliance, and complexity."""
+        from cloudwright.scorer import Scorer
+        from cloudwright.spec import ArchSpec
+
+        from cloudwright_mcp.serializers import score_result_to_dict
+
+        spec = ArchSpec.model_validate(spec_json)
+        result = Scorer().score(spec)
+        return score_result_to_dict(result)
+
+    @mcp.tool()
+    def diff_architectures(old_spec_json: dict, new_spec_json: dict) -> dict:
+        """Diff two architecture specs and return a structured change report."""
+        from cloudwright.differ import Differ
+        from cloudwright.spec import ArchSpec
+
+        old = ArchSpec.model_validate(old_spec_json)
+        new = ArchSpec.model_validate(new_spec_json)
+        result = Differ().diff(old, new)
+        return result.model_dump(exclude_none=True)

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/cost.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def estimate_cost(spec_json: dict, pricing_tier: str = "on_demand") -> dict:
+        """Estimate monthly cost for an architecture spec."""
+        from cloudwright.cost import CostEngine
+        from cloudwright.spec import ArchSpec
+
+        spec = ArchSpec.model_validate(spec_json)
+        estimate = CostEngine().estimate(spec, pricing_tier=pricing_tier)
+        return estimate.model_dump(exclude_none=True)
+
+    @mcp.tool()
+    def compare_provider_costs(spec_json: dict, providers: list[str]) -> list[dict]:
+        """Compare costs for an architecture across cloud providers."""
+        from cloudwright.cost import CostEngine
+        from cloudwright.spec import ArchSpec
+
+        spec = ArchSpec.model_validate(spec_json)
+        comparisons = CostEngine().compare_providers(spec, providers)
+        return [c.model_dump(exclude_none=True) for c in comparisons]

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/design.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def design_architecture(
+        description: str,
+        provider: str = "aws",
+        region: str = "us-east-1",
+        budget_monthly: float | None = None,
+        compliance: list[str] | None = None,
+    ) -> dict:
+        """Design a cloud architecture from a natural language description."""
+        from cloudwright.architect import Architect
+        from cloudwright.cost import CostEngine
+        from cloudwright.spec import Constraints
+
+        constraints = Constraints(regions=[region], budget_monthly=budget_monthly, compliance=compliance or [])
+        spec = Architect().design(description, constraints=constraints)
+        if not spec.cost_estimate:
+            spec = spec.model_copy(update={"cost_estimate": CostEngine().estimate(spec)})
+        return spec.model_dump(exclude_none=True)
+
+    @mcp.tool()
+    def modify_architecture(spec_json: dict, instruction: str) -> dict:
+        """Modify an existing architecture with a natural language instruction."""
+        from cloudwright.architect import Architect
+        from cloudwright.spec import ArchSpec
+
+        spec = ArchSpec.model_validate(spec_json)
+        modified = Architect().modify(spec, instruction)
+        return modified.model_dump(exclude_none=True)
+
+    @mcp.tool()
+    def compare_providers(spec_json: dict, providers: list[str]) -> list[dict]:
+        """Compare an architecture across cloud providers."""
+        from cloudwright.architect import Architect
+        from cloudwright.spec import ArchSpec
+
+        spec = ArchSpec.model_validate(spec_json)
+        alternatives = Architect().compare(spec, providers)
+        return [a.model_dump(exclude_none=True) for a in alternatives]

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/export.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def export_architecture(spec_json: dict, format: str = "terraform") -> dict:
+        """Export an architecture spec to Terraform, CloudFormation, Mermaid, D2, or other formats."""
+        from cloudwright.exporter import export_spec
+        from cloudwright.spec import ArchSpec
+
+        spec = ArchSpec.model_validate(spec_json)
+        content = export_spec(spec, fmt=format)
+        return {"format": format, "content": content}
+
+    @mcp.tool()
+    def list_services(provider: str = "aws") -> list[dict]:
+        """List all cloud services for a provider from the service registry."""
+        from cloudwright.registry import ServiceRegistry
+
+        services = ServiceRegistry().list_services(provider)
+        return [s.to_dict() for s in services]
+
+    @mcp.tool()
+    def catalog_search(
+        provider: str = "aws",
+        query: str | None = None,
+        vcpus: int | None = None,
+        memory_gb: float | None = None,
+        max_price_per_hour: float | None = None,
+    ) -> list[dict]:
+        """Search the cloud instance catalog by provider, specs, or text query."""
+        from cloudwright.catalog import Catalog
+
+        return Catalog().search(
+            query=query,
+            provider=provider,
+            vcpus=vcpus,
+            memory_gb=memory_gb,
+            max_price_per_hour=max_price_per_hour,
+        )

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/session.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import uuid
+
+from mcp.server.fastmcp import FastMCP
+
+_sessions: dict[str, object] = {}
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def chat_create_session(
+        provider: str = "aws",
+        budget_monthly: float | None = None,
+        compliance: list[str] | None = None,
+    ) -> dict:
+        """Create a new stateful architecture design conversation session."""
+        from cloudwright.architect import ConversationSession
+        from cloudwright.spec import Constraints
+
+        constraints = Constraints(budget_monthly=budget_monthly, compliance=compliance or [])
+        session = ConversationSession(constraints=constraints)
+        session_id = uuid.uuid4().hex[:12]
+        _sessions[session_id] = session
+        return {"session_id": session_id}
+
+    @mcp.tool()
+    def chat_send(session_id: str, message: str) -> dict:
+        """Send a message to an existing conversation session and get a response."""
+        session = _sessions.get(session_id)
+        if session is None:
+            return {"error": f"Session {session_id!r} not found. Create one with chat_create_session."}
+
+        text, spec = session.send(message)
+        return {
+            "response": text,
+            "spec": spec.model_dump(exclude_none=True) if spec is not None else None,
+        }
+
+    @mcp.tool()
+    def chat_list_sessions() -> list[dict]:
+        """List all active conversation sessions."""
+        from cloudwright.architect import ConversationSession
+
+        result = []
+        for sid, session in _sessions.items():
+            if isinstance(session, ConversationSession):
+                result.append(
+                    {
+                        "session_id": sid,
+                        "message_count": len(session.history),
+                        "has_spec": session.current_spec is not None,
+                    }
+                )
+        return result

cloudwright_ai_mcp-0.3.1/cloudwright_mcp/tools/validate.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+
+def register(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def validate_compliance(
+        spec_json: dict,
+        frameworks: list[str],
+        well_architected: bool = False,
+    ) -> list[dict]:
+        """Validate an architecture against compliance frameworks."""
+        from cloudwright.spec import ArchSpec
+        from cloudwright.validator import Validator
+
+        spec = ArchSpec.model_validate(spec_json)
+        results = Validator().validate(spec, compliance=frameworks, well_architected=well_architected)
+        return [r.model_dump(exclude_none=True) for r in results]
+
+    @mcp.tool()
+    def security_scan(spec_json: dict) -> dict:
+        """Scan an architecture for security anti-patterns and misconfigurations."""
+        from cloudwright.security import SecurityScanner
+        from cloudwright.spec import ArchSpec
+
+        from cloudwright_mcp.serializers import security_report_to_dict
+
+        spec = ArchSpec.model_validate(spec_json)
+        report = SecurityScanner().scan(spec)
+        return security_report_to_dict(report)
+
+    @mcp.tool()
+    def scan_terraform(hcl_content: str) -> dict:
+        """Scan Terraform HCL for security misconfigurations."""
+        from cloudwright.security import scan_terraform as _scan_terraform
+
+        from cloudwright_mcp.serializers import security_report_to_dict
+
+        report = _scan_terraform(hcl_content)
+        return security_report_to_dict(report)
+
+    @mcp.tool()
+    def lint_architecture(spec_json: dict) -> list[dict]:
+        """Lint an architecture for anti-patterns and best-practice violations."""
+        from cloudwright.linter import lint
+        from cloudwright.spec import ArchSpec
+
+        from cloudwright_mcp.serializers import lint_warnings_to_dict
+
+        spec = ArchSpec.model_validate(spec_json)
+        warnings = lint(spec)
+        return lint_warnings_to_dict(warnings)

cloudwright_ai_mcp-0.3.1/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cloudwright-ai-mcp"
+dynamic = ["version"]
+description = "MCP server for Cloudwright architecture intelligence"
+requires-python = ">=3.12"
+license = "MIT"
+authors = [{name = "Xavier Puspus"}]
+dependencies = [
+    "cloudwright-ai>=0.3.0,<1",
+    "mcp>=1.12,<2",
+]
+
+[project.urls]
+Homepage = "https://github.com/xmpuspus/cloudwright"
+
+[tool.hatch.version]
+path = "cloudwright_mcp/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["cloudwright_mcp"]