alchemax-plugin 0.1.0__py3-none-any.whl

alchemax_plugin/__init__.py

@@ -0,0 +1,3 @@
+"""Alchemax plugin: standalone MCP toolkit for Docker app deployment to AWS EC2."""
+
+__version__ = "0.1.0"

alchemax_plugin/analyzer.py

@@ -0,0 +1,83 @@
+"""Source code language and framework detection."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+
+class SourceAnalyzer:
+    """Analyzes source code for language, framework, and Dockerfile presence."""
+
+    @staticmethod
+    def analyze(source_path: Path) -> dict:
+        """Analyze source directory. Return lang, framework, has_dockerfile."""
+        if not source_path.exists():
+            return {"language": None, "framework": None, "has_dockerfile": False}
+
+        has_dockerfile = (source_path / "Dockerfile").exists()
+        if has_dockerfile:
+            return {"language": None, "framework": None, "has_dockerfile": True}
+
+        language, framework = None, None
+
+        # Check Node.js
+        pkg_json = source_path / "package.json"
+        if pkg_json.exists():
+            try:
+                with open(pkg_json) as f:
+                    data = json.load(f)
+                    deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                    if "next" in deps:
+                        language, framework = "node", "next"
+                    elif "express" in deps:
+                        language, framework = "node", "express"
+                    elif "react" in deps:
+                        language, framework = "node", "react"
+                    else:
+                        language = "node"
+            except (json.JSONDecodeError, OSError):
+                language = "node"
+
+        # Check Python
+        if not language:
+            if (source_path / "requirements.txt").exists():
+                language = "python"
+                try:
+                    with open(source_path / "requirements.txt") as f:
+                        content = f.read()
+                        if "fastapi" in content:
+                            framework = "fastapi"
+                        elif "flask" in content:
+                            framework = "flask"
+                        elif "django" in content:
+                            framework = "django"
+                except OSError:
+                    pass
+
+            elif (source_path / "pyproject.toml").exists():
+                language = "python"
+                try:
+                    with open(source_path / "pyproject.toml") as f:
+                        content = f.read()
+                        if "fastapi" in content:
+                            framework = "fastapi"
+                        elif "flask" in content:
+                            framework = "flask"
+                        elif "django" in content:
+                            framework = "django"
+                except OSError:
+                    pass
+
+        # Check Go
+        if not language and (source_path / "go.mod").exists():
+            language = "go"
+
+        # Check Rust
+        if not language and (source_path / "Cargo.toml").exists():
+            language = "rust"
+
+        return {
+            "language": language,
+            "framework": framework,
+            "has_dockerfile": has_dockerfile,
+        }

alchemax_plugin/builder.py

@@ -0,0 +1,211 @@
+"""Docker image builder and registry push."""
+
+import json
+import os
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+
+class DockerAuthError(Exception):
+    """Raised when Docker registry authentication fails."""
+
+    pass
+
+
+class DockerBuildError(Exception):
+    """Raised when Docker build fails."""
+
+    pass
+
+
+@dataclass
+class AnalysisResult:
+    """Result of source code analysis."""
+
+    has_dockerfile: bool
+    language: Optional[str]
+    framework: Optional[str]
+    suggested_dockerfile: Optional[str]
+
+
+class DockerBuilder:
+    """Builds and pushes Docker images."""
+
+    def __init__(self, docker_hub_username: Optional[str] = None):
+        self.docker_hub_username = docker_hub_username or os.getenv("DOCKER_HUB_USERNAME")
+
+    def build(self, source_path: str, image_tag: str) -> str:
+        """Build Docker image with buildx. Hard-coded --platform linux/amd64."""
+        source_path = Path(source_path).resolve()
+        if not source_path.exists():
+            raise DockerBuildError(f"Source path does not exist: {source_path}")
+
+        cmd = [
+            "docker",
+            "buildx",
+            "build",
+            "--platform",
+            "linux/amd64",
+            "-t",
+            image_tag,
+            str(source_path),
+        ]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+        except subprocess.CalledProcessError as e:
+            raise DockerBuildError(f"Build failed: {e.stderr}")
+
+        return image_tag
+
+    def push(self, image_tag: str) -> None:
+        """Push image to registry. Lazy auth check: only error on push failure."""
+        cmd = ["docker", "push", image_tag]
+        try:
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+        except subprocess.CalledProcessError as e:
+            if "unauthorized" in e.stderr.lower():
+                raise DockerAuthError(
+                    f"Docker registry authentication failed. Run `docker login` then retry."
+                )
+            raise DockerBuildError(f"Push failed: {e.stderr}")
+
+    def analyze(self, source_path: str) -> AnalysisResult:
+        """Analyze source code for language/framework and Dockerfile presence."""
+        source_path = Path(source_path)
+        if not source_path.exists():
+            return AnalysisResult(
+                has_dockerfile=False,
+                language=None,
+                framework=None,
+                suggested_dockerfile=None,
+            )
+
+        has_dockerfile = (source_path / "Dockerfile").exists()
+        if has_dockerfile:
+            return AnalysisResult(
+                has_dockerfile=True,
+                language=None,
+                framework=None,
+                suggested_dockerfile=None,
+            )
+
+        language = None
+        framework = None
+        suggested_dockerfile = None
+
+        # Check package.json (Node.js)
+        package_json = source_path / "package.json"
+        if package_json.exists():
+            try:
+                with open(package_json) as f:
+                    data = json.load(f)
+                    deps = {**data.get("dependencies", {}), **data.get("devDependencies", {})}
+                    if "next" in deps:
+                        language, framework = "node", "next"
+                    elif "express" in deps:
+                        language, framework = "node", "express"
+                    elif "react" in deps:
+                        language, framework = "node", "react"
+                    else:
+                        language = "node"
+            except (json.JSONDecodeError, OSError):
+                language = "node"
+
+        # Check Python
+        if not language and (source_path / "requirements.txt").exists():
+            language = "python"
+            try:
+                with open(source_path / "requirements.txt") as f:
+                    content = f.read()
+                    if "fastapi" in content:
+                        framework = "fastapi"
+                    elif "flask" in content:
+                        framework = "flask"
+                    elif "django" in content:
+                        framework = "django"
+            except OSError:
+                pass
+
+        if not language and (source_path / "pyproject.toml").exists():
+            language = "python"
+            try:
+                with open(source_path / "pyproject.toml") as f:
+                    content = f.read()
+                    if "fastapi" in content:
+                        framework = "fastapi"
+                    elif "flask" in content:
+                        framework = "flask"
+                    elif "django" in content:
+                        framework = "django"
+            except OSError:
+                pass
+
+        # Check Go
+        if not language and (source_path / "go.mod").exists():
+            language = "go"
+
+        # Check Rust
+        if not language and (source_path / "Cargo.toml").exists():
+            language = "rust"
+
+        # Generate suggested Dockerfile if language detected but no Dockerfile
+        if language and not has_dockerfile:
+            suggested_dockerfile = self._scaffold_dockerfile(language, framework)
+
+        return AnalysisResult(
+            has_dockerfile=has_dockerfile,
+            language=language,
+            framework=framework,
+            suggested_dockerfile=suggested_dockerfile,
+        )
+
+    @staticmethod
+    def _scaffold_dockerfile(language: str, framework: Optional[str]) -> str:
+        """Generate basic Dockerfile scaffold."""
+        if language == "node":
+            return """FROM node:24-alpine
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY . .
+EXPOSE 8000
+CMD ["npm", "start"]
+"""
+        elif language == "python":
+            return """FROM python:3.13-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["python", "main.py"]
+"""
+        elif language == "go":
+            return """FROM golang:1.23-alpine AS builder
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN go build -o app
+
+FROM alpine:latest
+WORKDIR /app
+COPY --from=builder /app/app .
+EXPOSE 8000
+CMD ["./app"]
+"""
+        elif language == "rust":
+            return """FROM rust:latest AS builder
+WORKDIR /app
+COPY . .
+RUN cargo build --release
+
+FROM debian:bookworm-slim
+WORKDIR /app
+COPY --from=builder /app/target/release/app .
+EXPOSE 8000
+CMD ["./app"]
+"""
+        return ""

alchemax_plugin/metadata.py

@@ -0,0 +1,170 @@
+"""Project metadata (alchemax.json) parsing and validation."""
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional
+
+
+@dataclass
+class AppConfig:
+    """Single app configuration."""
+    id: str
+    port: int
+    path: str = "."
+    dockerfile: str = "Dockerfile"
+    tag: str = "latest"
+    health_check: Optional[str] = None
+    env: dict[str, str] = field(default_factory=dict)
+    secrets: list[str] = field(default_factory=list)
+    depends_on: list[str] = field(default_factory=list)
+
+    @property
+    def container_name(self) -> str:
+        """Deployed container name in docker-compose."""
+        return self.id
+
+    def validate(self) -> list[str]:
+        """Validate config. Return list of errors."""
+        errors = []
+        if not self.id:
+            errors.append("app.id is required")
+        if self.port < 1 or self.port > 65535:
+            errors.append(f"app.port {self.port} out of range")
+        if not self.path:
+            errors.append("app.path is required")
+        if not self.tag:
+            errors.append("app.tag is required")
+        return errors
+
+
+@dataclass
+class WorkspaceConfig:
+    """Workspace-level configuration."""
+    region: str = "us-east-1"
+    instance_type: str = "t3.micro"
+    ebs_volume_size: int = 10
+    env: dict[str, str] = field(default_factory=dict)
+
+    def validate(self) -> list[str]:
+        """Validate config."""
+        errors = []
+        if self.region not in [
+            "us-east-1", "us-west-2", "eu-west-1", "ap-southeast-1"
+        ]:
+            errors.append(f"workspace.region {self.region} not supported")
+        if self.instance_type not in ["t3.micro", "t3.small", "t3.medium"]:
+            errors.append(f"workspace.instance_type {self.instance_type} not supported")
+        if self.ebs_volume_size < 1 or self.ebs_volume_size > 1000:
+            errors.append(f"workspace.ebs_volume_size {self.ebs_volume_size} out of range")
+        return errors
+
+
+@dataclass
+class ProjectMetadata:
+    """Full project metadata from alchemax.json."""
+    name: str
+    apps: list[AppConfig] = field(default_factory=list)
+    workspace: WorkspaceConfig = field(default_factory=WorkspaceConfig)
+
+    def validate(self) -> list[str]:
+        """Validate entire manifest."""
+        errors = []
+        if not self.name:
+            errors.append("name is required")
+        if not self.apps:
+            errors.append("at least one app is required")
+
+        # Validate each app
+        app_ids = set()
+        for i, app in enumerate(self.apps):
+            app_errors = app.validate()
+            errors.extend([f"apps[{i}]: {e}" for e in app_errors])
+            
+            if app.id in app_ids:
+                errors.append(f"apps[{i}]: duplicate id '{app.id}'")
+            app_ids.add(app.id)
+
+            # Validate depends_on references
+            for dep in app.depends_on:
+                if dep not in app_ids and dep not in [a.id for a in self.apps]:
+                    errors.append(f"apps[{i}]: depends_on '{dep}' not found")
+
+        # Validate workspace
+        ws_errors = self.workspace.validate()
+        errors.extend([f"workspace: {e}" for e in ws_errors])
+
+        return errors
+
+    def deployment_order(self) -> list[str]:
+        """Return app IDs in dependency order (topological sort)."""
+        visited = set()
+        order = []
+
+        def visit(app_id: str) -> None:
+            if app_id in visited:
+                return
+            visited.add(app_id)
+
+            app = next((a for a in self.apps if a.id == app_id), None)
+            if not app:
+                return
+
+            for dep in app.depends_on:
+                visit(dep)
+
+            order.append(app_id)
+
+        for app in self.apps:
+            visit(app.id)
+
+        return order
+
+
+def load_metadata(project_path: Path) -> Optional[ProjectMetadata]:
+    """Load alchemax.json from project. Return None if not found."""
+    manifest_file = Path(project_path) / "alchemax.json"
+    if not manifest_file.exists():
+        return None
+
+    try:
+        data = json.loads(manifest_file.read_text())
+        return parse_metadata(data)
+    except Exception:
+        return None
+
+
+def parse_metadata(data: dict[str, Any]) -> ProjectMetadata:
+    """Parse metadata dict. Raise on invalid."""
+    name = data.get("name", "")
+    
+    workspace_data = data.get("workspace", {})
+    workspace = WorkspaceConfig(
+        region=workspace_data.get("region", "us-east-1"),
+        instance_type=workspace_data.get("instance_type", "t3.micro"),
+        ebs_volume_size=workspace_data.get("ebs_volume_size", 10),
+        env=workspace_data.get("env", {}),
+    )
+
+    apps = []
+    for app_data in data.get("apps", []):
+        app = AppConfig(
+            id=app_data.get("id", ""),
+            port=app_data.get("port", 8000),
+            path=app_data.get("path", "."),
+            dockerfile=app_data.get("dockerfile", "Dockerfile"),
+            tag=app_data.get("tag", "latest"),
+            health_check=app_data.get("health_check"),
+            env=app_data.get("env", {}),
+            secrets=app_data.get("secrets", []),
+            depends_on=app_data.get("depends_on", []),
+        )
+        apps.append(app)
+
+    metadata = ProjectMetadata(name=name, apps=apps, workspace=workspace)
+    
+    errors = metadata.validate()
+    if errors:
+        raise ValueError(f"Invalid metadata:\n" + "\n".join(errors))
+
+    return metadata

alchemax_plugin/runner.py

@@ -0,0 +1,86 @@
+"""Terraform runner for infrastructure provisioning."""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any, Optional
+
+
+class TerraformError(Exception):
+    """Raised when Terraform commands fail."""
+
+    pass
+
+
+class TerraformRunner:
+    """Executes Terraform commands."""
+
+    def __init__(self, workspace_dir: Path):
+        self.workspace_dir = Path(workspace_dir)
+        if not self.workspace_dir.exists():
+            raise TerraformError(f"Workspace directory does not exist: {workspace_dir}")
+
+    def init(self) -> None:
+        """Initialize Terraform."""
+        cmd = ["terraform", "init"]
+        self._run_cmd(cmd, cwd=self.workspace_dir)
+
+    def apply(self, auto_approve: bool = False) -> dict[str, Any]:
+        """Apply Terraform changes. Return outputs."""
+        cmd = ["terraform", "apply"]
+        if auto_approve:
+            cmd.append("-auto-approve")
+        
+        self._run_cmd(cmd, cwd=self.workspace_dir)
+        return self.output()
+
+    def destroy(self, auto_approve: bool = False) -> None:
+        """Destroy Terraform resources."""
+        cmd = ["terraform", "destroy"]
+        if auto_approve:
+            cmd.append("-auto-approve")
+        
+        self._run_cmd(cmd, cwd=self.workspace_dir)
+
+    def output(self) -> dict[str, Any]:
+        """Get Terraform outputs as JSON."""
+        cmd = ["terraform", "output", "-json"]
+        result = subprocess.run(
+            cmd,
+            cwd=self.workspace_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        
+        if result.returncode != 0:
+            if "no output" in result.stdout.lower() or result.stdout.strip() == "{}":
+                return {}
+            raise TerraformError(f"Terraform output failed: {result.stderr}")
+        
+        try:
+            data = json.loads(result.stdout)
+            # Extract raw values from Terraform output format: {"key": {"value": ...}}
+            return {k: v.get("value") if isinstance(v, dict) else v for k, v in data.items()}
+        except json.JSONDecodeError:
+            return {}
+
+    def validate(self) -> bool:
+        """Validate Terraform configuration."""
+        cmd = ["terraform", "validate", "-json"]
+        result = subprocess.run(
+            cmd,
+            cwd=self.workspace_dir,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        return result.returncode == 0
+
+    @staticmethod
+    def _run_cmd(cmd: list[str], cwd: Path) -> str:
+        """Run command and raise on failure."""
+        result = subprocess.run(cmd, cwd=cwd, capture_output=True, text=True)
+        if result.returncode != 0:
+            raise TerraformError(f"Command failed: {result.stderr}")
+        return result.stdout