deployforge 0.1.0__py3-none-any.whl

deployforge/deployment/planner.py

@@ -0,0 +1,172 @@
+"""Deployment planning.
+
+Turns a :class:`ProjectAnalysis` into an ordered, safe deployment plan before
+any provider API is touched.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from deployforge.analyzer.project import ProjectAnalysis
+
+
+@dataclass
+class PlannedService:
+    kind: str
+    provider: str
+    directory: Path
+    framework: str
+    label: str
+
+
+@dataclass
+class PlannedEnvVar:
+    key: str
+    provider: str
+    applies_to: str
+    value: str = field(default="(obtained after deployment)")
+
+
+@dataclass
+class DeploymentPlan:
+    services: list[PlannedService]
+    env_vars: list[PlannedEnvVar]
+    actions: list[str]
+    database_note: str | None = None
+
+    @property
+    def has_backend(self) -> bool:
+        return any(s.kind == "backend" for s in self.services)
+
+    @property
+    def has_frontend(self) -> bool:
+        return any(s.kind == "frontend" for s in self.services)
+
+    def summarize(self) -> list[str]:
+        lines = ["DEPLOYMENT PLAN"]
+        if self.has_backend:
+            for service in self.services:
+                if service.kind == "backend":
+                    lines.append(f"Backend: {service.framework} → {service.provider}")
+        if self.has_frontend:
+            for service in self.services:
+                if service.kind == "frontend":
+                    lines.append(f"Frontend: {service.framework} → {service.provider}")
+        if self.env_vars:
+            lines.append("Connection:")
+            for env in self.env_vars:
+                lines.append(f"  {env.key} → {env.provider}")
+        lines.append("Actions:")
+        for action in self.actions:
+            lines.append(f"  {action}")
+        return lines
+
+
+def default_api_var(frontend_framework: str) -> str:
+    mapping = {
+        "Next.js": "NEXT_PUBLIC_API_URL",
+        "Nuxt": "NUXT_PUBLIC_API_URL",
+        "Vite": "VITE_API_URL",
+        "React": "REACT_APP_API_URL",
+        "SvelteKit": "SVELTEKIT_API_URL",
+    }
+    return mapping.get(frontend_framework, "API_URL")
+
+
+def default_cors_var() -> str:
+    return "FRONTEND_URL"
+
+
+def build_plan(analysis: ProjectAnalysis) -> DeploymentPlan:
+    services: list[PlannedService] = []
+    env_vars: list[PlannedEnvVar] = []
+    actions: list[str] = []
+
+    backend = analysis.backend
+    frontend = analysis.frontend
+
+    if backend:
+        label = f"{analysis.name}-api" if frontend else analysis.name
+        services.append(
+            PlannedService(
+                kind="backend",
+                provider=backend.provider,
+                directory=backend.directory,
+                framework=backend.framework,
+                label=label,
+            )
+        )
+        actions.append("Deploy backend")
+        actions.append("Obtain backend URL")
+
+    if frontend:
+        services.append(
+            PlannedService(
+                kind="frontend",
+                provider=frontend.provider,
+                directory=frontend.directory,
+                framework=frontend.framework,
+                label=analysis.name,
+            )
+        )
+        actions.append("Deploy frontend")
+
+    if backend and frontend:
+        api_var = (
+            frontend.api_url_names[0]
+            if frontend.api_url_names
+            else default_api_var(frontend.framework)
+        )
+        env_vars.append(
+            PlannedEnvVar(
+                key=api_var,
+                provider=analysis.frontends[0].provider,
+                applies_to="frontend",
+            )
+        )
+        actions.append("Configure frontend environment")
+
+        cors_var = backend.cors_env_names[0] if backend.cors_env_names else None
+        if cors_var:
+            env_vars.append(
+                PlannedEnvVar(
+                    key=cors_var,
+                    provider=backend.provider,
+                    applies_to="backend",
+                )
+            )
+            actions.append("Configure backend CORS")
+
+    actions.extend(
+        [
+            "Verify frontend",
+            "Verify backend",
+            "Verify frontend → backend communication",
+        ]
+    )
+
+    database_note = None
+    database = getattr(analysis, "database", None)
+    if database is not None:
+        engine = getattr(database, "engine", None)
+        configured = getattr(database, "configured", False)
+        if engine:
+            if configured:
+                database_note = (
+                    f"Database ({engine}) configuration detected and preserved. "
+                    "DeployForge does not migrate or modify databases."
+                )
+            else:
+                database_note = (
+                    f"Database ({engine}) may be used; no connection configuration was found "
+                    "in the project. DeployForge will not provision databases."
+                )
+
+    return DeploymentPlan(
+        services=services,
+        env_vars=env_vars,
+        actions=actions,
+        database_note=database_note,
+    )

deployforge/deployment/verifier.py

@@ -0,0 +1,65 @@
+"""Deployment verification.
+
+Checks that deployed services are reachable over HTTP and that expected
+endpoints respond. Uses conservative defaults and never guesses endpoint
+paths that were not detected in the source.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from urllib.parse import urljoin
+
+import requests
+
+
+@dataclass
+class VerificationResult:
+    name: str
+    url: str
+    reachable: bool
+    status_code: int | None = None
+    health_ok: bool | None = None
+    latency_ms: float | None = None
+
+
+@dataclass
+class VerificationReport:
+    results: list[VerificationResult]
+
+    @property
+    def passed(self) -> bool:
+        return bool(self.results) and all(r.reachable for r in self.results)
+
+
+def check_url(name: str, url: str, health_path: str | None = None) -> VerificationResult:
+    start = time.monotonic()
+    try:
+        response = requests.get(url, timeout=15, allow_redirects=True)
+    except requests.RequestException:
+        return VerificationResult(name=name, url=url, reachable=False, latency_ms=None)
+    latency_ms = round((time.monotonic() - start) * 1000, 1)
+    reachable = response.status_code < 400
+    health_ok: bool | None = None
+    if reachable and health_path:
+        try:
+            base = url.rstrip("/") + "/"
+            health = requests.get(urljoin(base, health_path.lstrip("/")), timeout=15)
+            health_ok = health.status_code < 500
+        except requests.RequestException:
+            health_ok = False
+    return VerificationResult(
+        name=name,
+        url=url,
+        reachable=reachable,
+        status_code=response.status_code,
+        health_ok=health_ok,
+        latency_ms=latency_ms,
+    )
+
+
+def verify_endpoints(pairs: list[tuple[str, str, str | None]]) -> VerificationReport:
+    """Verify a list of ``(name, url, health_path)`` tuples."""
+    results = [check_url(name, url, health_path) for name, url, health_path in pairs]
+    return VerificationReport(results=results)

deployforge/errors/__init__.py

@@ -0,0 +1,53 @@
+"""Base exceptions for DeployForge."""
+
+
+class DeployForgeError(Exception):
+    """Base exception for all DeployForge errors."""
+
+
+class ConfigError(DeployForgeError):
+    """Raised when configuration is invalid or cannot be read."""
+
+
+class ProjectError(DeployForgeError):
+    """Raised when a project cannot be analyzed or deployed."""
+
+
+class GitHubError(DeployForgeError):
+    """Raised when a GitHub operation fails."""
+
+
+class SecurityError(DeployForgeError):
+    """Raised when the security preflight detects a potential secret."""
+
+
+class AuthenticationError(DeployForgeError):
+    """Raised when provider authentication is missing or invalid."""
+
+
+class ProviderError(DeployForgeError):
+    """Raised when a deployment provider API call fails."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class DeploymentError(DeployForgeError):
+    """Raised when a deployment fails."""
+
+
+class VerificationError(DeployForgeError):
+    """Raised when a deployment cannot be verified."""
+
+
+class PartialDeploymentError(DeployForgeError):
+    """Raised when part of a deployment fails after earlier steps succeeded.
+
+    Carries the steps that succeeded so the caller can report "partial
+    deployment" accurately instead of claiming success or total failure.
+    """
+
+    def __init__(self, message: str, succeeded: list[str]) -> None:
+        super().__init__(message)
+        self.succeeded = succeeded

deployforge/github/__init__.py

@@ -0,0 +1,21 @@
+from deployforge.github.integration import (
+    RepoInfo,
+    current_branch,
+    detect_repository,
+    github_token,
+    has_local_git,
+    parse_github_url,
+    remote_urls,
+    repo_exists,
+)
+
+__all__ = [
+    "RepoInfo",
+    "current_branch",
+    "detect_repository",
+    "github_token",
+    "has_local_git",
+    "parse_github_url",
+    "remote_urls",
+    "repo_exists",
+]

deployforge/github/integration.py

@@ -0,0 +1,127 @@
+"""GitHub is the source of truth.
+
+DeployForge does not create repositories. It reads the git remote of the
+local project and, when possible, verifies the repository exists on GitHub.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import requests
+
+from deployforge.errors import GitHubError
+
+_GITHUB_URL_RE = re.compile(
+    r"^((?:https?://)?(?:www\.)?github\.com[:/]|git@github\.com:)([^/\s]+)/([^/\s]+?)(?:\.git)?$"
+)
+
+
+@dataclass
+class RepoInfo:
+    exists: bool
+    host: str | None = None
+    owner: str | None = None
+    name: str | None = None
+    url: str | None = None
+    branch: str | None = None
+
+    def slug(self) -> str | None:
+        if self.owner and self.name:
+            return f"{self.owner}/{self.name}"
+        return None
+
+
+def _run_git(project: Path, args: list[str]) -> str | None:
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(project), *args],
+            capture_output=True,
+            text=True,
+            timeout=15,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def has_local_git(project: Path) -> bool:
+    inside = _run_git(project, ["rev-parse", "--is-inside-work-tree"]) == "true"
+    return (project / ".git").exists() or inside
+
+
+def current_branch(project: Path) -> str | None:
+    return _run_git(project, ["branch", "--show-current"])
+
+
+def remote_urls(project: Path) -> list[str]:
+    output = _run_git(project, ["remote", "-v"])
+    if not output:
+        return []
+    urls: list[str] = []
+    for line in output.splitlines():
+        parts = line.split()
+        if len(parts) >= 2:
+            urls.append(parts[1])
+    return urls
+
+
+def parse_github_url(url: str) -> tuple[str, str] | None:
+    """Return (owner, name) for a GitHub URL, or None."""
+    candidate = url.strip()
+    if candidate.startswith("git@"):
+        candidate = candidate.replace("git@", "https://", 1).replace(":", "/", 1)
+    match = _GITHUB_URL_RE.match(candidate)
+    if not match:
+        return None
+    owner = match.group(2)
+    name = match.group(3).rstrip("/")
+    return owner, name
+
+
+def detect_repository(project: Path) -> RepoInfo:
+    """Detect the GitHub repository backing *project* from its git remote."""
+    branch = current_branch(project) or "main"
+    if not has_local_git(project):
+        return RepoInfo(exists=False, branch=branch)
+
+    for url in remote_urls(project):
+        parsed = parse_github_url(url)
+        if parsed:
+            owner, name = parsed
+            return RepoInfo(
+                exists=True,
+                host="github.com",
+                owner=owner,
+                name=name,
+                url=f"https://github.com/{owner}/{name}",
+                branch=branch,
+            )
+    return RepoInfo(exists=False, branch=branch)
+
+
+def github_token() -> str | None:
+    return os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+
+
+def repo_exists(repo: RepoInfo, token: str | None = None) -> bool:
+    """Verify a repository exists on GitHub without printing the token."""
+    slug = repo.slug()
+    if not slug:
+        return False
+    headers = {"Accept": "application/vnd.github+json"}
+    token = token or github_token()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try:
+        response = requests.get(f"https://api.github.com/repos/{slug}", headers=headers, timeout=15)
+    except requests.RequestException as exc:
+        raise GitHubError(f"Unable to reach GitHub API: {exc}") from exc
+    return response.status_code == 200

deployforge/integration/__init__.py

@@ -0,0 +1,20 @@
+from deployforge.integration.cors import (
+    cors_configured,
+    cors_origin_variable,
+    detect_cors_origin,
+)
+from deployforge.integration.environment import is_configured, read_env_value
+from deployforge.integration.frontend_backend import (
+    connection_summary,
+    determine_api_variable,
+)
+
+__all__ = [
+    "connection_summary",
+    "cors_configured",
+    "cors_origin_variable",
+    "detect_cors_origin",
+    "determine_api_variable",
+    "is_configured",
+    "read_env_value",
+]

deployforge/integration/cors.py

@@ -0,0 +1,30 @@
+"""CORS origin detection for backends.
+
+DeployForge only proposes CORS changes through provider environment
+variables when a backend references a configurable origin variable. It never
+rewrites application source code.
+"""
+
+from __future__ import annotations
+
+from deployforge.analyzer.backend import BackendDetection
+from deployforge.deployment.planner import default_cors_var
+
+
+def detect_cors_origin(backend: BackendDetection | None) -> str | None:
+    """Return the CORS origin env var the backend expects, if detectable."""
+    if backend is None:
+        return None
+    if backend.cors_env_names:
+        return backend.cors_env_names[0]
+    return None
+
+
+def cors_origin_variable(backend: BackendDetection | None) -> str:
+    """Return the var to use for a backend that expects a configurable origin."""
+    return detect_cors_origin(backend) or default_cors_var()
+
+
+def cors_configured(backend: BackendDetection | None) -> bool:
+    """A backend is CORS-configurable only when evidence exists in its source."""
+    return bool(backend and backend.cors_env_names)

deployforge/integration/environment.py

@@ -0,0 +1,62 @@
+"""Environment variable helpers for service wiring.
+
+Reads what the project currently expects and reports it without modifying
+source code. All actual wiring happens through provider APIs.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from deployforge.analyzer.shared import walk_files
+
+ENV_FILE_NAMES = (".env", ".env.local", ".env.production", ".env.development")
+
+
+def read_env_value(directory: Path, key: str) -> str | None:
+    """Return the current value of *key* from any ``.env`` file, if present."""
+    for path in walk_files(directory):
+        if path.name not in ENV_FILE_NAMES:
+            continue
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for line in text.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            name, _, value = line.partition("=")
+            if name.strip() == key:
+                return value.strip().strip('"').strip("'")
+    return None
+
+
+def is_configured(value: str | None) -> bool:
+    """True when a value looks real rather than a placeholder."""
+    if not value:
+        return False
+    lowered = value.lower()
+    if lowered in {
+        "unset",
+        "not-configured",
+        "none",
+        "null",
+        "changeme",
+        "set-me",
+        "to-be-configured",
+    }:
+        return False
+    return not any(
+        token in lowered
+        for token in (
+            "localhost",
+            "127.0.0.1",
+            "example",
+            "placeholder",
+            "your-url",
+            "your_url",
+            "yoururl",
+            "your-api",
+        )
+    )

deployforge/integration/frontend_backend.py

@@ -0,0 +1,39 @@
+"""Frontend ↔ backend auto-connection.
+
+After the backend is deployed, DeployForge wires the backend URL into the
+frontend's environment. It only ever uses environment variables — it never
+hard-codes URLs into source code.
+"""
+
+from __future__ import annotations
+
+from deployforge.analyzer.project import ProjectAnalysis
+from deployforge.deployment.planner import default_api_var
+
+
+def determine_api_variable(analysis: ProjectAnalysis) -> tuple[str | None, str | None]:
+    """Return the (env var, provider) used to connect a frontend to its backend."""
+    frontend = analysis.frontend
+    backend = analysis.backend
+    if not frontend or not backend:
+        return None, None
+    if frontend.api_url_names:
+        key = frontend.api_url_names[0]
+    else:
+        key = default_api_var(frontend.framework)
+    return key, frontend.provider
+
+
+def connection_summary(analysis: ProjectAnalysis) -> list[str]:
+    lines: list[str] = []
+    frontend = analysis.frontend
+    backend = analysis.backend
+    if not frontend or not backend:
+        return lines
+    key, provider = determine_api_variable(analysis)
+    if key:
+        lines.append(f"Frontend → Backend: {key} on {provider}")
+    if backend.cors_env_names:
+        cors = backend.cors_env_names[0]
+        lines.append(f"Backend → Frontend: {cors} on {backend.provider}")
+    return lines

deployforge/providers/__init__.py

@@ -0,0 +1,32 @@
+from deployforge.providers.base import (
+    AuthInfo,
+    DeploymentProvider,
+    DeploymentResult,
+    DeployStatus,
+    HttpClient,
+)
+from deployforge.providers.render import RenderProvider
+from deployforge.providers.vercel import VercelProvider
+
+
+def build_providers(
+    vercel_token: str | None,
+    render_api_key: str | None,
+    client: HttpClient | None = None,
+) -> dict[str, DeploymentProvider]:
+    return {
+        "vercel": VercelProvider(vercel_token, client),
+        "render": RenderProvider(render_api_key, client),
+    }
+
+
+__all__ = [
+    "AuthInfo",
+    "DeploymentProvider",
+    "DeploymentResult",
+    "DeployStatus",
+    "HttpClient",
+    "RenderProvider",
+    "VercelProvider",
+    "build_providers",
+]