deployforge 0.1.0__py3-none-any.whl

deployforge/__init__.py

@@ -0,0 +1,3 @@
+"""DeployForge — from GitHub to a Live Application. Automatically."""
+
+__version__ = "0.1.0"

deployforge/__version__.py

@@ -0,0 +1,3 @@
+"""Package version for DeployForge."""
+
+__version__ = "0.1.0"

deployforge/analyzer/__init__.py

@@ -0,0 +1,23 @@
+from deployforge.analyzer.backend import BACKEND_CORS_ENV_NAMES, detect_backend
+from deployforge.analyzer.database import detect_database
+from deployforge.analyzer.frontend import FRONTEND_API_ENV_NAMES, detect_frontend
+from deployforge.analyzer.project import (
+    BackendApp,
+    FrontendApp,
+    ProjectAnalysis,
+    analyze_project,
+    suggest_name,
+)
+
+__all__ = [
+    "BACKEND_CORS_ENV_NAMES",
+    "BackendApp",
+    "FRONTEND_API_ENV_NAMES",
+    "FrontendApp",
+    "ProjectAnalysis",
+    "analyze_project",
+    "detect_backend",
+    "detect_database",
+    "detect_frontend",
+    "suggest_name",
+]

deployforge/analyzer/backend.py

@@ -0,0 +1,326 @@
+"""Backend application detection.
+
+Handles Python (FastAPI, Flask, Django, generic) and Node.js (Express,
+NestJS, Fastify, generic) backends. Detection relies on manifests, entry
+point files, and framework references — never directory names alone.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from deployforge.analyzer.frontend import read_package_json
+from deployforge.analyzer.shared import (
+    backend_framework_from_deps,
+    read_text_safe,
+    scan_env_references,
+    walk_files,
+)
+
+BACKEND_CORS_ENV_NAMES: tuple[str, ...] = (
+    "FRONTEND_URL",
+    "FRONTEND_ORIGIN",
+    "ALLOWED_ORIGINS",
+    "CORS_ORIGIN",
+    "CORS_ORIGINS",
+    "CLIENT_URL",
+    "CLIENT_ORIGIN",
+    "WEB_ORIGIN",
+)
+
+PYTHON_MARKERS = (
+    "requirements.txt",
+    "pyproject.toml",
+    "Pipfile",
+    "poetry.lock",
+    "setup.py",
+)
+
+PYTHON_ENTRY_CANDIDATES = ("main.py", "app.py", "server.py", "api.py")
+NODE_ENTRY_CANDIDATES = (
+    "server.js",
+    "server.ts",
+    "src/server.js",
+    "src/server.ts",
+    "index.js",
+    "index.ts",
+)
+
+
+@dataclass
+class BackendDetection:
+    framework: str | None
+    language: str | None
+    entrypoint: Path | None
+    start_command: str | None
+    build_command: str | None
+    health_path: str | None
+    cors_env_names: list[str]
+    directory: Path
+
+    @property
+    def detected(self) -> bool:
+        return self.framework is not None
+
+
+def _fastapi_object(path: Path) -> tuple[str, str] | None:
+    """Return (module_stem, object_name) for a FastAPI/Starlette entry file."""
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return None
+    match = re.search(r"(\w+)\s*=\s*(FastAPI|Starlette)\s*\(", text)
+    if match:
+        return path.stem, match.group(1)
+    return (path.stem, "app") if "FastAPI(" in text else None
+
+
+def _flask_object(path: Path) -> tuple[str, str] | None:
+    try:
+        text = path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return None
+    match = re.search(r"(\w+)\s*=\s*Flask\s*\(", text)
+    if match:
+        return path.stem, match.group(1)
+    return None
+
+
+def _detect_python(directory: Path) -> BackendDetection:
+    markers_present = any((directory / name).exists() for name in PYTHON_MARKERS)
+    py_files = [p for p in walk_files(directory) if p.suffix == ".py"]
+    detection = BackendDetection(
+        framework=None,
+        language="python",
+        entrypoint=None,
+        start_command=None,
+        build_command=None,
+        health_path=None,
+        cors_env_names=[],
+        directory=directory,
+    )
+
+    framework: str | None = None
+    deps_files = ("requirements.txt", "pyproject.toml", "Pipfile", "poetry.lock")
+    deps_text = "".join(
+        read_text_safe(directory / name).lower()
+        for name in deps_files
+        if (directory / name).exists()
+    )
+
+    if "fastapi" in deps_text:
+        framework = "FastAPI"
+    elif "flask" in deps_text:
+        framework = "Flask"
+    elif "django" in deps_text or (directory / "manage.py").exists():
+        framework = "Django"
+    elif markers_present or py_files:
+        framework = "Python"
+
+    detection.framework = framework
+
+    entry = _find_python_entrypoint(directory)
+    if framework == "FastAPI":
+        detection.start_command = _fastapi_start(directory, entry)
+    elif framework == "Flask":
+        detection.start_command = _flask_start(directory, entry)
+    elif framework == "Django":
+        detection.start_command = _django_start(directory)
+    elif framework == "Python":
+        detection.start_command = _fastapi_start(directory, entry)
+
+    detection.entrypoint = entry
+    detection.health_path = _detect_health_path(directory)
+    detection.cors_env_names = scan_env_references(directory, BACKEND_CORS_ENV_NAMES)
+    detection.build_command = _python_build_command(directory)
+    return detection
+
+
+def _find_python_entrypoint(directory: Path) -> Path | None:
+    for name in PYTHON_ENTRY_CANDIDATES:
+        candidate = directory / name
+        if candidate.exists():
+            return candidate
+    for candidate in walk_files(directory):
+        if candidate.name in ("main.py", "app.py", "server.py", "api.py"):
+            text = read_text_safe(candidate)
+            if "FastAPI(" in text or "Flask(" in text or "Starlette(" in text:
+                return candidate
+    return None
+
+
+def _fastapi_start(directory: Path, entry: Path | None) -> str | None:
+    if entry is None:
+        return None
+    module = _to_module_path(directory, entry)
+    pair = _fastapi_object(entry)
+    obj = pair[1] if pair else "app"
+    return f"uvicorn {module}:{obj} --host 0.0.0.0 --port $PORT"
+
+
+def _to_module_path(directory: Path, entry: Path) -> str:
+    try:
+        rel = entry.relative_to(directory)
+    except ValueError:
+        return "main"
+    parts = list(rel.parts)
+    if parts and parts[-1].endswith(".py"):
+        parts[-1] = parts[-1][:-3]
+    if parts and parts[-1] == "__init__":
+        parts = parts[:-1]
+    return ".".join(parts) if parts else "main"
+
+
+def _flask_start(directory: Path, entry: Path | None) -> str | None:
+    if entry is None:
+        return None
+    module = _to_module_path(directory, entry)
+    pair = _flask_object(entry)
+    obj = pair[1] if pair else "app"
+    return f"gunicorn {module}:{obj} --bind 0.0.0.0:$PORT"
+
+
+def _django_start(directory: Path) -> str | None:
+    manage = directory / "manage.py"
+    project = None
+    if manage.exists():
+        try:
+            text = manage.read_text(encoding="utf-8", errors="ignore")
+            match = re.search(r"DJANGO_SETTINGS_MODULE\s*[=:]\s*['\"]?([\w.]+)['\"]?", text)
+            if match:
+                project = match.group(1).split(".")[0]
+        except OSError:
+            pass
+    if project is None and directory.name:
+        project = directory.name.replace("-", "_")
+    return f"gunicorn {project}.wsgi:application --bind 0.0.0.0:$PORT"
+
+
+def _python_build_command(directory: Path) -> str | None:
+    if (directory / "requirements.txt").exists():
+        return "pip install -r requirements.txt"
+    if (directory / "pyproject.toml").exists() or (directory / "setup.py").exists():
+        return "pip install -e ."
+    return None
+
+
+def _detect_health_path(directory: Path) -> str | None:
+    for path in walk_files(directory):
+        if path.suffix not in (".py", ".js", ".ts"):
+            continue
+        if "health" in path.name.lower():
+            continue
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        if '"/health"' in text or "'/health'" in text or "health/" in text:
+            return "/health"
+    return None
+
+
+_NODE_ENTRY_SUFFIXES = ("server.js", "server.ts", "index.js", "index.ts")
+
+
+def _detect_node(directory: Path) -> BackendDetection:
+    detection = BackendDetection(
+        framework=None,
+        language="node",
+        entrypoint=None,
+        start_command=None,
+        build_command=None,
+        health_path=None,
+        cors_env_names=[],
+        directory=directory,
+    )
+    package = read_package_json(directory)
+    if package is None:
+        return detection
+
+    backend_fw = backend_framework_from_deps(package)
+    if backend_fw:
+        detection.framework = backend_fw
+    else:
+        frontend_fw = _frontend_deps_present(package)
+        entry = _find_node_entrypoint(directory)
+        if not frontend_fw and entry is not None:
+            detection.framework = "Node.js"
+            detection.entrypoint = entry
+
+    if detection.framework is None:
+        return detection
+
+    entry = detection.entrypoint or _find_node_entrypoint(directory)
+    detection.entrypoint = entry
+    scripts = package.get("scripts")
+    if isinstance(scripts, dict) and isinstance(scripts.get("start"), str):
+        detection.start_command = scripts["start"]
+    elif entry is not None:
+        detection.start_command = f"node {_rel_path(directory, entry)}"
+    detection.build_command = _node_build_command(directory)
+    detection.health_path = _detect_health_path(directory)
+    detection.cors_env_names = scan_env_references(directory, BACKEND_CORS_ENV_NAMES)
+    return detection
+
+
+def _frontend_deps_present(package: dict) -> bool:
+    names = set(_iter_dep_names(package))
+    return bool(names & {"react", "react-dom", "next", "vue", "svelte", "astro", "vite"})
+
+
+def _iter_dep_names(package: dict) -> list[str]:
+    names: list[str] = []
+    for section in ("dependencies", "devDependencies"):
+        raw = package.get(section)
+        if isinstance(raw, dict):
+            names.extend(raw.keys())
+    return names
+
+
+def _find_node_entrypoint(directory: Path) -> Path | None:
+    for name in _NODE_ENTRY_SUFFIXES:
+        for candidate in (directory / name, directory / "src" / name):
+            if candidate.exists():
+                return candidate
+    package = read_package_json(directory)
+    if package:
+        main = package.get("main")
+        if isinstance(main, str):
+            candidate = directory / main
+            if candidate.exists():
+                return candidate
+    return None
+
+
+def _rel_path(directory: Path, entry: Path) -> str:
+    try:
+        return entry.relative_to(directory).as_posix()
+    except ValueError:
+        return entry.name
+
+
+def _node_build_command(directory: Path) -> str | None:
+    if (directory / "package-lock.json").exists():
+        return "npm ci"
+    if (directory / "pnpm-lock.yaml").exists():
+        return "pnpm install --frozen-lockfile"
+    if (directory / "yarn.lock").exists():
+        return "yarn install --frozen-lockfile"
+    if (directory / "package.json").exists():
+        return "npm install"
+    return None
+
+
+def detect_backend(directory: Path) -> BackendDetection:
+    """Classify *directory* as a backend application if the evidence supports it."""
+    if (directory / "package.json").exists():
+        node = _detect_node(directory)
+        # A node backend wins over python only when its evidence is real.
+        if node.detected:
+            return node
+    python = _detect_python(directory)
+    if python.detected:
+        return python
+    return python

deployforge/analyzer/database.py

@@ -0,0 +1,120 @@
+"""Database configuration detection.
+
+DeployForge never provisions databases in the MVP. It only *reports* which
+database a project appears to use so deployment plans preserve that
+configuration instead of guessing.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from deployforge.analyzer.shared import read_text_safe
+
+DATABASE_ENV_MAP: tuple[tuple[str, str], ...] = (
+    ("POSTGRES_URL", "PostgreSQL"),
+    ("POSTGRESQL_URL", "PostgreSQL"),
+    ("DATABASE_URL", "PostgreSQL"),
+    ("MONGODB_URI", "MongoDB"),
+    ("MONGO_URI", "MongoDB"),
+    ("REDIS_URL", "Redis"),
+    ("MYSQL_URL", "MySQL"),
+)
+
+DATABASE_TEXT_KEYWORDS: tuple[tuple[str, str], ...] = (
+    ("psycopg", "PostgreSQL"),
+    ("postgres", "PostgreSQL"),
+    ("djangodb", "PostgreSQL"),
+    ("sqlalchemy", "PostgreSQL"),
+    ("pymongo", "MongoDB"),
+    ("redis", "Redis"),
+    ("mysql", "MySQL"),
+    ("sqlite", "SQLite"),
+)
+
+_MAX_DEPTH = 3
+
+
+@dataclass
+class DatabaseDetection:
+    engine: str | None
+    env_name: str | None
+    configured: bool
+    presets: list[str]
+
+    @property
+    def detected(self) -> bool:
+        return self.engine is not None
+
+
+def _env_files(directory: Path) -> list[Path]:
+    result: list[Path] = []
+    for path in sorted(directory.rglob("*")):
+        if not path.is_file():
+            continue
+        if any(part in {".git", "node_modules", ".venv", "__pycache__"} for part in path.parts):
+            continue
+        parts = path.relative_to(directory).parts
+        if len(parts) > _MAX_DEPTH:
+            continue
+        is_env = path.name.startswith(".env") or ".env." in path.name
+        is_compose = path.name in {
+            "docker-compose.yml",
+            "docker-compose.yaml",
+            "compose.yml",
+            "compose.yaml",
+        }
+        if is_env or is_compose:
+            result.append(path)
+    return result
+
+
+def _scan_env_text(directory: Path) -> tuple[str | None, str | None]:
+    for path in _env_files(directory):
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for name, engine in DATABASE_ENV_MAP:
+            if name in text:
+                return engine, name
+    return None, None
+
+
+def _scan_dependency_text(directory: Path) -> str | None:
+    text_parts: list[str] = []
+    for name in ("requirements.txt", "pyproject.toml", "Pipfile"):
+        text_parts.append(read_text_safe(directory / name).lower())
+    for path in directory.rglob("package.json"):
+        if any(part in {"node_modules", ".git"} for part in path.parts):
+            continue
+        text_parts.append(read_text_safe(path).lower())
+    return "\n".join(text_parts) or None
+
+
+def _keyword_engine(text: str) -> str | None:
+    for keyword, engine in DATABASE_TEXT_KEYWORDS:
+        if keyword in text:
+            return engine
+    return None
+
+
+def detect_database(directory: Path) -> DatabaseDetection:
+    """Detect which database a project appears to use."""
+    engine, env_name = _scan_env_text(directory)
+    presets: list[str] = []
+
+    text = _scan_dependency_text(directory)
+    if text:
+        keyword_engine = _keyword_engine(text)
+        if keyword_engine and keyword_engine != engine:
+            presets.append(keyword_engine)
+
+    configured = engine is not None
+    return DatabaseDetection(
+        engine=engine or (presets[0] if presets else None),
+        env_name=env_name,
+        configured=configured,
+        presets=presets,
+    )

deployforge/analyzer/frontend.py

@@ -0,0 +1,179 @@
+"""Frontend application detection.
+
+Detection uses multiple signals — dependency manifests, framework-specific
+config files, package manager lockfiles, and source references to API
+environment variables. A directory name alone never decides anything.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+from deployforge.analyzer.shared import scan_env_references, strong_frontend_marker
+
+FRONTEND_FRAMEWORKS = (
+    "Next.js",
+    "React",
+    "Vite",
+    "Vue",
+    "Nuxt",
+    "Angular",
+    "Astro",
+    "Svelte",
+    "SvelteKit",
+    "Static HTML",
+)
+
+_FRAMEWORK_DEPS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("Next.js", ("next",)),
+    ("React", ("react", "react-dom")),
+    ("Vite", ("vite",)),
+    ("Vue", ("vue",)),
+    ("Nuxt", ("nuxt",)),
+    ("Angular", ("@angular/core",)),
+    ("Astro", ("astro",)),
+    ("SvelteKit", ("@sveltejs/kit",)),
+    ("Svelte", ("svelte",)),
+)
+
+# Preferred order matters: the first referenced name wins when we wire up the
+# frontend to the backend URL.
+FRONTEND_API_ENV_NAMES: tuple[str, ...] = (
+    "NEXT_PUBLIC_API_URL",
+    "NEXT_PUBLIC_API_BASE_URL",
+    "NEXT_PUBLIC_BACKEND_URL",
+    "VITE_API_URL",
+    "VITE_API_BASE_URL",
+    "VITE_BACKEND_URL",
+    "REACT_APP_API_URL",
+    "REACT_APP_API_BASE_URL",
+    "REACT_APP_BACKEND_URL",
+    "NUXT_PUBLIC_API_URL",
+    "NG_API_URL",
+    "SVELTEKIT_API_URL",
+    "API_URL",
+    "API_BASE_URL",
+    "BACKEND_URL",
+)
+
+PACKAGE_MANAGER_LOCKS = (
+    ("package-lock.json", "npm"),
+    ("pnpm-lock.yaml", "pnpm"),
+    ("yarn.lock", "yarn"),
+    ("bun.lockb", "bun"),
+)
+
+
+@dataclass
+class FrontendDetection:
+    framework: str | None
+    package_manager: str | None
+    build_command: str | None
+    output_directory: str | None
+    api_url_names: list[str]
+    directory: Path
+
+    @property
+    def detected(self) -> bool:
+        return self.framework is not None
+
+
+def read_package_json(directory: Path) -> dict | None:
+    pkg = directory / "package.json"
+    if not pkg.exists():
+        return None
+    try:
+        data = json.loads(pkg.read_text(encoding="utf-8", errors="ignore"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def frontend_framework_from_deps(package: dict) -> str | None:
+    deps: dict = {}
+    for section in ("dependencies", "devDependencies", "peerDependencies"):
+        raw = package.get(section)
+        if isinstance(raw, dict):
+            deps.update(raw)
+    for framework, needles in _FRAMEWORK_DEPS:
+        if any(needle in deps for needle in needles):
+            return framework
+    return None
+
+
+def _detect_package_manager(directory: Path) -> str | None:
+    for lock, manager in PACKAGE_MANAGER_LOCKS:
+        if (directory / lock).exists():
+            return manager
+    return None
+
+
+def _detect_build_command(directory: Path) -> str | None:
+    package = read_package_json(directory)
+    if not package:
+        return None
+    scripts = package.get("scripts")
+    if isinstance(scripts, dict):
+        builder = scripts.get("build") or scripts.get("deploy")
+        if isinstance(builder, str) and builder:
+            return builder
+    return None
+
+
+def _detect_framework_from_config(directory: Path) -> str | None:
+    for name in (
+        "next.config.js",
+        "next.config.mjs",
+        "next.config.ts",
+        "next-env.d.ts",
+    ):
+        if (directory / name).exists():
+            return "Next.js"
+    for name in ("vite.config.js", "vite.config.ts", "vite.config.mjs"):
+        if (directory / name).exists():
+            return "Vite"
+    if (directory / "nuxt.config.js").exists() or (directory / "nuxt.config.ts").exists():
+        return "Nuxt"
+    if (directory / "astro.config.js").exists() or (directory / "astro.config.ts").exists():
+        return "Astro"
+    if (directory / "svelte.config.js").exists() or (directory / "svelte.config.ts").exists():
+        return "SvelteKit"
+    return None
+
+
+def detect_frontend(directory: Path) -> FrontendDetection:
+    """Classify *directory* as a frontend application if the evidence supports it."""
+    detected = FrontendDetection(
+        framework=None,
+        package_manager=None,
+        build_command=None,
+        output_directory=None,
+        api_url_names=[],
+        directory=directory,
+    )
+
+    if strong_frontend_marker(directory):
+        detected.framework = _detect_framework_from_config(directory)
+        detected.package_manager = _detect_package_manager(directory)
+        detected.build_command = _detect_build_command(directory)
+        detected.api_url_names = scan_env_references(directory, FRONTEND_API_ENV_NAMES)
+        return detected
+
+    package = read_package_json(directory)
+    if package:
+        framework = frontend_framework_from_deps(package)
+        if framework:
+            detected.framework = framework
+            detected.package_manager = _detect_package_manager(directory)
+            detected.build_command = _detect_build_command(directory)
+            detected.api_url_names = scan_env_references(directory, FRONTEND_API_ENV_NAMES)
+            return detected
+
+    if (directory / "index.html").exists():
+        detected.framework = "Static HTML"
+        detected.api_url_names = scan_env_references(directory, FRONTEND_API_ENV_NAMES)
+        return detected
+
+    return detected