deployforge 0.1.0__py3-none-any.whl

deployforge/analyzer/project.py

@@ -0,0 +1,389 @@
+"""Project topology analysis.
+
+DeployForge analyzes a repository and identifies:
+
+* the frontend application (if any),
+* the backend application (if any),
+* the database configuration (if any),
+* monorepo workspaces,
+* the backing GitHub repository.
+
+Detection uses multiple signals and never relies on a directory name alone.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from deployforge.analyzer.backend import BackendDetection, detect_backend
+from deployforge.analyzer.database import detect_database
+from deployforge.analyzer.frontend import FrontendDetection, detect_frontend
+from deployforge.analyzer.shared import (
+    is_backend_dir_name,
+    strong_frontend_marker,
+)
+from deployforge.config import ProjectConfig, ProjectConfigManager
+from deployforge.github.integration import (
+    RepoInfo,
+    current_branch,
+    detect_repository,
+    has_local_git,
+)
+
+IGNORED_DIRS = {
+    ".git",
+    ".github",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "dist",
+    "build",
+    ".next",
+    ".deployforge",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".mypy_cache",
+}
+
+
+@dataclass
+class FrontendApp:
+    framework: str
+    directory: Path
+    package_manager: str | None
+    build_command: str | None
+    output_directory: str | None
+    output_file: str | None = None
+    api_url_names: list[str] = field(default_factory=list)
+    provider: str = "vercel"
+
+
+@dataclass
+class BackendApp:
+    framework: str
+    language: str | None
+    directory: Path
+    entrypoint: Path | None
+    start_command: str | None
+    build_command: str | None
+    health_path: str | None
+    cors_env_names: list[str] = field(default_factory=list)
+    provider: str = "render"
+
+
+@dataclass
+class ProjectAnalysis:
+    root: Path
+    name: str
+    frontends: list[FrontendApp]
+    backends: list[BackendApp]
+    database: object
+    workspaces: list[Path]
+    repo: RepoInfo
+    is_monorepo: bool = False
+
+    @property
+    def has_frontend(self) -> bool:
+        return bool(self.frontends)
+
+    @property
+    def has_backend(self) -> bool:
+        return bool(self.backends)
+
+    @property
+    def frontend(self) -> FrontendApp | None:
+        return self.frontends[0] if self.frontends else None
+
+    @property
+    def backend(self) -> BackendApp | None:
+        return self.backends[0] if self.backends else None
+
+
+def suggest_name(root: Path) -> str:
+    raw = root.name or "project"
+    slug = re.sub(r"[^a-zA-Z0-9\-_.]+", "-", raw).strip("-._")
+    return slug.lower() or "project"
+
+
+def read_package_json(root: Path) -> dict | None:
+    path = root / "package.json"
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text(encoding="utf-8", errors="ignore"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return data if isinstance(data, dict) else None
+
+
+def _workspace_globs(root: Path) -> list[str]:
+    globs: list[str] = []
+    if (root / "pnpm-workspace.yaml").exists():
+        try:
+            text = (root / "pnpm-workspace.yaml").read_text(encoding="utf-8", errors="ignore")
+            match = re.search(r"packages:\s*\n((?:\s*-\s*.+\n?)+)", text)
+            if match:
+                for line in match.group(1).splitlines():
+                    line = line.strip()
+                    if line.startswith("-"):
+                        globs.append(line[1:].strip())
+        except OSError:
+            pass
+    package = read_package_json(root)
+    if package:
+        workspaces = package.get("workspaces")
+        if isinstance(workspaces, list):
+            globs.extend(str(entry) for entry in workspaces if isinstance(entry, str))
+        elif isinstance(workspaces, dict):
+            entries = workspaces.get("packages")
+            if isinstance(entries, list):
+                globs.extend(str(entry) for entry in entries if isinstance(entry, str))
+    return globs
+
+
+def _resolve_workspaces(root: Path) -> list[Path]:
+    resolved: list[Path] = []
+    globs = _workspace_globs(root)
+    if not globs:
+        for parent in ("apps", "app", "services"):
+            folder = root / parent
+            if folder.is_dir():
+                resolved.extend(p for p in folder.iterdir() if p.is_dir())
+        return resolved
+    for glob in globs:
+        try:
+            matches = list(root.glob(glob))
+        except OSError:
+            continue
+        for match in matches:
+            if match.is_dir() and match not in resolved:
+                resolved.append(match)
+    if not resolved:
+        for parent in ("apps", "app", "services"):
+            folder = root / parent
+            if folder.is_dir():
+                resolved.extend(p for p in folder.iterdir() if p.is_dir())
+    return resolved
+
+
+def _has_python_backend_markers(directory: Path) -> bool:
+    for name in ("requirements.txt", "manage.py", "Pipfile", "poetry.lock"):
+        if (directory / name).exists():
+            return True
+    if (directory / "pyproject.toml").exists():
+        return True
+    return any(p.suffix == ".py" for p in directory.iterdir() if p.is_file())
+
+
+def _has_node_backend_evidence(directory: Path) -> bool:
+    package = read_package_json(directory)
+    if not package:
+        return False
+    from deployforge.analyzer.shared import backend_framework_from_deps
+
+    return backend_framework_from_deps(package) is not None
+
+
+def _workspace_candidate(directory: Path) -> bool:
+    if strong_frontend_marker(directory):
+        return True
+    if _has_python_backend_markers(directory):
+        return True
+    if _has_node_backend_evidence(directory):
+        return True
+    parent = directory.parent.name
+    return parent in {"apps", "app", "services", "applications"}
+
+
+def _has_markers(directory: Path) -> bool:
+    return bool(
+        strong_frontend_marker(directory)
+        or (directory / "package.json").exists()
+        or (directory / "requirements.txt").exists()
+        or (directory / "pyproject.toml").exists()
+        or (directory / "Pipfile").exists()
+        or (directory / "index.html").exists()
+        or (directory / "main.py").exists()
+        or (directory / "manage.py").exists()
+        or any(p.suffix == ".py" for p in directory.iterdir() if p.is_file())
+    )
+
+
+def discover_candidates(root: Path, is_monorepo: bool) -> list[Path]:
+    if is_monorepo:
+        return [w for w in _resolve_workspaces(root) if _workspace_candidate(w)]
+    candidates: list[Path] = []
+    if _has_markers(root):
+        candidates.append(root)
+    for entry in sorted(root.iterdir()):
+        if not entry.is_dir() or entry.name in IGNORED_DIRS:
+            continue
+        if _has_markers(entry):
+            candidates.append(entry)
+    return candidates
+
+
+def _classify(directory: Path) -> tuple[str, FrontendDetection | BackendDetection] | None:
+    """Return ("frontend", det) or ("backend", det) based on evidence."""
+    if strong_frontend_marker(directory):
+        det = detect_frontend(directory)
+        return ("frontend", det)
+
+    backend_det = detect_backend(directory)
+    if backend_det.detected:
+        return ("backend", backend_det)
+
+    frontend_det = detect_frontend(directory)
+    if frontend_det.detected:
+        return ("frontend", frontend_det)
+
+    if (directory / "package.json").exists():
+        package = read_package_json(directory)
+        if package:
+            frontend_fw = frontend_framework_from_package(package)
+            backend_fw = backend_framework_from_package(package)
+            if frontend_fw and not backend_fw:
+                frontend_det = detect_frontend(directory)
+                if frontend_det.detected:
+                    return ("frontend", frontend_det)
+            if backend_fw and not frontend_fw:
+                backend_det = detect_backend(directory)
+                if backend_det.detected:
+                    return ("backend", backend_det)
+
+    if (directory / "index.html").exists():
+        html_det = detect_frontend(directory)
+        if html_det.detected:
+            return ("frontend", html_det)
+
+    # Weak last signal: directory names are only accepted with additional
+    # Python marker evidence, never for deployment on the name alone.
+    if is_backend_dir_name(directory.name) and _has_python_backend_markers(directory):
+        marker_det = detect_backend(directory)
+        if marker_det.detected:
+            return ("backend", marker_det)
+    return None
+
+
+def frontend_framework_from_package(package: dict) -> str | None:
+    deps: dict = {}
+    for section in ("dependencies", "devDependencies", "peerDependencies"):
+        raw = package.get(section)
+        if isinstance(raw, dict):
+            deps.update(raw)
+    names = set(_dep_names(package))
+    if "next" in names:
+        return "Next.js"
+    if "vue" in names:
+        return "Vue"
+    if "react" in names or "react-dom" in names:
+        return "React"
+    if "svelte" in names:
+        return "Svelte"
+    if "astro" in names:
+        return "Astro"
+    return None
+
+
+def backend_framework_from_package(package: dict) -> str | None:
+    from deployforge.analyzer.shared import backend_framework_from_deps
+
+    return backend_framework_from_deps(package)
+
+
+def _dep_names(package: dict) -> list[str]:
+    deps: list[str] = []
+    for section in ("dependencies", "devDependencies"):
+        raw = package.get(section)
+        if isinstance(raw, dict):
+            deps.extend(raw.keys())
+    return deps
+
+
+def _to_frontend_app(det: FrontendDetection) -> FrontendApp:
+    return FrontendApp(
+        framework=det.framework or "Unknown",
+        directory=det.directory,
+        package_manager=det.package_manager,
+        build_command=det.build_command,
+        output_directory=det.output_directory,
+        api_url_names=det.api_url_names,
+    )
+
+
+def _to_backend_app(det: BackendDetection) -> BackendApp:
+    return BackendApp(
+        framework=det.framework or "Unknown",
+        language=det.language,
+        directory=det.directory,
+        entrypoint=det.entrypoint,
+        start_command=det.start_command,
+        build_command=det.build_command,
+        health_path=det.health_path,
+        cors_env_names=det.cors_env_names,
+    )
+
+
+def _apply_config_overrides(analysis: ProjectAnalysis, config: ProjectConfig) -> ProjectAnalysis:
+    if config.frontend_directory:
+        directory = analysis.root / config.frontend_directory
+        if directory.is_dir():
+            frontend_det = detect_frontend(directory)
+            if frontend_det.detected:
+                analysis.frontends = [_to_frontend_app(frontend_det)]
+                analysis.frontends[0].provider = config.frontend_provider
+    if config.backend_directory:
+        directory = analysis.root / config.backend_directory
+        if directory.is_dir():
+            backend_det = detect_backend(directory)
+            if backend_det.detected:
+                analysis.backends = [_to_backend_app(backend_det)]
+                analysis.backends[0].provider = config.backend_provider
+    return analysis
+
+
+def analyze_project(root: Path, config: ProjectConfig | None = None) -> ProjectAnalysis:
+    """Analyze a project directory and return its topology."""
+    root = root.resolve()
+    config = config or ProjectConfigManager(root).load()
+    is_monorepo = bool(_workspace_globs(root))
+    candidates = discover_candidates(root, is_monorepo)
+
+    frontends: list[FrontendApp] = []
+    backends: list[BackendApp] = []
+    workspaces: list[Path] = _resolve_workspaces(root) if is_monorepo else []
+
+    for candidate in candidates:
+        classified = _classify(candidate)
+        if classified is None:
+            continue
+        kind, det = classified
+        if kind == "frontend" and isinstance(det, FrontendDetection):
+            frontend_app = _to_frontend_app(det)
+            if all(frontend_app.directory != existing.directory for existing in frontends):
+                frontends.append(frontend_app)
+        elif kind == "backend" and isinstance(det, BackendDetection):
+            backend_app = _to_backend_app(det)
+            if all(backend_app.directory != existing.directory for existing in backends):
+                backends.append(backend_app)
+
+    repo = detect_repository(root)
+    has_git = has_local_git(root)
+    if not has_git:
+        repo = RepoInfo(exists=False, branch=current_branch(root) or "main")
+
+    analysis = ProjectAnalysis(
+        root=root,
+        name=suggest_name(root),
+        frontends=frontends,
+        backends=backends,
+        database=detect_database(root),
+        workspaces=workspaces,
+        repo=repo,
+        is_monorepo=is_monorepo,
+    )
+    return _apply_config_overrides(analysis, config)

deployforge/analyzer/shared.py

@@ -0,0 +1,109 @@
+"""Shared detection helpers used by the analyzer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+# Directory names that commonly hold the frontend and backend of an
+# application. These are *one* signal among several, never proof on their own.
+FRONTEND_DIR_NAMES = {"frontend", "client", "web", "app", "website", "ui"}
+BACKEND_DIR_NAMES = {"backend", "server", "api", "service", "api-server"}
+
+BACKEND_FRAMEWORK_DEPS: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("Express", ("express",)),
+    ("NestJS", ("@nestjs/core",)),
+    ("Fastify", ("fastify",)),
+    ("Hapi", ("@hapi/hapi",)),
+)
+
+IGNORED_DIRS = {
+    ".git",
+    "node_modules",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "dist",
+    "build",
+    ".next",
+    ".deployforge",
+}
+
+MAX_FILE_BYTES = 1_000_000
+
+
+def walk_files(directory: Path) -> list[Path]:
+    """All files under *directory*, skipping heavy/ignored folders."""
+    result: list[Path] = []
+    if not directory.exists():
+        return result
+    for path in directory.rglob("*"):
+        if not path.is_file():
+            continue
+        if any(part in IGNORED_DIRS for part in path.parts):
+            continue
+        result.append(path)
+    return result
+
+
+def read_text_safe(path: Path) -> str:
+    """Return *path* contents or ``""`` on read errors."""
+    try:
+        return path.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return ""
+
+
+def scan_env_references(directory: Path, names: tuple[str, ...]) -> list[str]:
+    """Return env var names that are actually referenced in the directory."""
+    found: set[str] = set()
+    for path in walk_files(directory):
+        try:
+            if path.stat().st_size > MAX_FILE_BYTES:
+                continue
+        except OSError:
+            continue
+        text = read_text_safe(path)
+        for name in names:
+            if name in text:
+                found.add(name)
+    return [name for name in names if name in found]
+
+
+def strong_frontend_marker(directory: Path) -> bool:
+    """True when framework-specific frontend config files exist."""
+    markers = (
+        "next.config.js",
+        "next.config.mjs",
+        "next.config.ts",
+        "next-env.d.ts",
+        "vite.config.js",
+        "vite.config.ts",
+        "vite.config.mjs",
+        "nuxt.config.js",
+        "nuxt.config.ts",
+        "astro.config.js",
+        "astro.config.ts",
+        "svelte.config.js",
+        "svelte.config.ts",
+    )
+    return any((directory / name).exists() for name in markers)
+
+
+def is_frontend_dir_name(name: str) -> bool:
+    return name.lower() in FRONTEND_DIR_NAMES
+
+
+def is_backend_dir_name(name: str) -> bool:
+    return name.lower() in BACKEND_DIR_NAMES
+
+
+def backend_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 BACKEND_FRAMEWORK_DEPS:
+        if any(needle in deps for needle in needles):
+            return framework
+    return None