dockermind 0.1.2__py3-none-any.whl

dockermind/__init__.py

@@ -0,0 +1,5 @@
+"""
+Dockermind -- Smart Dockerfile generation CLI for Node.js and Python projects.
+"""
+
+__version__ = "0.1.1"

dockermind/analyzer.py

@@ -0,0 +1,285 @@
+"""
+Project analyzer -- detects project type, framework, version, port, and scripts.
+
+Only Node.js and Python are supported in v1.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+
+from dockermind.utils import file_exists, read_file, extract_port_from_source, yellow
+
+
+# ---------------------------------------------------------------------------
+# Analysis result dataclass
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class AnalysisResult:
+    """Everything dockermind needs to know about the target project."""
+
+    # Core detection
+    language: str | None = None          # "node" | "python" | None
+    framework: str | None = None         # "express" | "fastapi" | "flask" | None
+
+    # Runtime version
+    node_version: str = "18"             # Default Node version
+    python_version: str = "3.11"         # Default Python version
+
+    # Scripts (Node)
+    has_build_script: bool = False
+    build_script: str | None = None
+    start_script: str | None = None
+
+    # Entry point (Python)
+    python_entry_module: str | None = None  # e.g. "main:app"
+    uses_uvicorn: bool = False
+
+    # Port
+    port: int | None = None
+    port_is_default: bool = False        # True if we fell back to a default
+
+    # Package manager
+    has_package_lock: bool = False
+    has_yarn_lock: bool = False
+    has_pnpm_lock: bool = False
+
+    # Raw Python dependency names (lowercase) for native-package inference
+    python_deps: set[str] = field(default_factory=set)
+
+    # Warnings generated during analysis
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def runtime_version(self) -> str:
+        """Return the resolved runtime version string."""
+        if self.language == "node":
+            return self.node_version
+        return self.python_version
+
+
+# ---------------------------------------------------------------------------
+# Analyzer
+# ---------------------------------------------------------------------------
+
+
+class Analyzer:
+    """Analyse a project directory and return an AnalysisResult."""
+
+    def __init__(self, project_path: str) -> None:
+        if not os.path.isdir(project_path):
+            raise FileNotFoundError(f"Project path does not exist: {project_path}")
+        self.path = project_path
+
+    def run(self) -> AnalysisResult:
+        """Run full analysis pipeline and return the result."""
+        result = AnalysisResult()
+
+        has_node = file_exists(self.path, "package.json")
+        has_python = (
+            file_exists(self.path, "requirements.txt")
+            or file_exists(self.path, "pyproject.toml")
+        )
+
+        # Language detection -- only one allowed
+        if has_node and has_python:
+            # Hard stop: ambiguous multi-runtime projects are not supported.
+            raise SystemExit(
+                "Error: Multiple backend runtimes detected (Node.js and Python).\n"
+                "Please run dockermind inside the specific service directory."
+            )
+
+        if has_node:
+            result.language = "node"
+            self._analyse_node(result)
+        elif has_python:
+            result.language = "python"
+            self._analyse_python(result)
+        else:
+            # Unsupported or empty project
+            result.language = None
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Node.js analysis
+    # ------------------------------------------------------------------
+
+    def _analyse_node(self, result: AnalysisResult) -> None:
+        """Populate *result* with Node.js-specific details."""
+        raw = read_file(self.path, "package.json")
+        if not raw:
+            result.warnings.append("package.json exists but could not be read.")
+            return
+
+        try:
+            pkg = json.loads(raw)
+        except json.JSONDecodeError:
+            result.warnings.append("package.json is not valid JSON.")
+            return
+
+        # -- Node version from engines field --
+        engines = pkg.get("engines", {})
+        requested_version = engines.get("node", "")
+        if requested_version:
+            result.node_version = self._parse_node_version(requested_version)
+        # else: stays at default "18"
+
+        # -- Scripts --
+        scripts = pkg.get("scripts", {})
+        if "build" in scripts:
+            result.has_build_script = True
+            result.build_script = scripts["build"]
+        result.start_script = scripts.get("start")
+
+        # -- Framework detection --
+        all_deps = {
+            **pkg.get("dependencies", {}),
+            **pkg.get("devDependencies", {}),
+        }
+        if "express" in all_deps:
+            result.framework = "express"
+        elif "fastify" in all_deps:
+            result.framework = "fastify"
+        elif "koa" in all_deps:
+            result.framework = "koa"
+        # For v1 we just note whatever framework; Dockerfile is the same.
+
+        # -- Lock file detection --
+        result.has_package_lock = file_exists(self.path, "package-lock.json")
+        result.has_yarn_lock = file_exists(self.path, "yarn.lock")
+        result.has_pnpm_lock = file_exists(self.path, "pnpm-lock.yaml")
+
+        # -- Port detection --
+        result.port = self._detect_node_port(pkg)
+        if result.port is None:
+            result.port = 3000
+            result.port_is_default = True
+            result.warnings.append(
+                "Could not detect port from source. Defaulting to 3000."
+            )
+
+    def _parse_node_version(self, version_spec: str) -> str:
+        """Extract a major version number from an engines.node specifier.
+
+        Examples:
+            ">=18"          -> "18"
+            "^20.0.0"       -> "20"
+            "18.x"          -> "18"
+            ">=18 <22"      -> "18"
+        """
+        match = re.search(r"(\d{1,3})", version_spec)
+        if match:
+            return match.group(1)
+        return "18"  # safe fallback
+
+    def _detect_node_port(self, pkg: dict) -> int | None:
+        """Try to detect port from source files or scripts."""
+        # Check common entry points for .listen(PORT)
+        candidates = ["server.js", "index.js", "app.js", "src/index.js", "src/server.js",
+                       "src/app.js", "dist/index.js", "server.ts", "index.ts", "src/index.ts"]
+
+        for filename in candidates:
+            source = read_file(self.path, filename)
+            if source:
+                port = extract_port_from_source(source)
+                if port:
+                    return port
+
+        return None
+
+    # ------------------------------------------------------------------
+    # Python analysis
+    # ------------------------------------------------------------------
+
+    def _analyse_python(self, result: AnalysisResult) -> None:
+        """Populate *result* with Python-specific details."""
+
+        # Gather all dependency names
+        deps_lower: set[str] = set()
+
+        # From requirements.txt
+        reqs = read_file(self.path, "requirements.txt")
+        if reqs:
+            for line in reqs.splitlines():
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                # "fastapi==0.100.0" -> "fastapi"
+                dep_name = re.split(r"[>=<!~\[]", line)[0].strip().lower()
+                if dep_name:
+                    deps_lower.add(dep_name)
+
+        # From pyproject.toml (simple parse -- no toml library needed for v1)
+        pyproject = read_file(self.path, "pyproject.toml")
+        if pyproject:
+            # Quick regex extraction for dependencies list
+            for match in re.finditer(r'"([a-zA-Z0-9_-]+)', pyproject):
+                deps_lower.add(match.group(1).lower())
+
+        # Expose raw deps for native-package inference in dockerfile_generator
+        result.python_deps = deps_lower
+
+        # -- Framework detection --
+        if "fastapi" in deps_lower:
+            result.framework = "fastapi"
+            result.port = 8000
+        elif "flask" in deps_lower:
+            result.framework = "flask"
+            result.port = 5000
+        else:
+            # Unknown Python framework -- set a sensible default
+            result.framework = None
+            result.port = 8000
+            result.warnings.append(
+                "No recognised framework (FastAPI/Flask). Defaulting to port 8000."
+            )
+
+        # -- Uvicorn detection --
+        if "uvicorn" in deps_lower:
+            result.uses_uvicorn = True
+
+        # -- Detect entry module --
+        result.python_entry_module = self._detect_python_entry(result)
+
+        # -- Python version from pyproject.toml requires-python --
+        if pyproject:
+            match = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', pyproject)
+            if match:
+                ver_match = re.search(r"(\d+\.\d+)", match.group(1))
+                if ver_match:
+                    result.python_version = ver_match.group(1)
+
+    def _detect_python_entry(self, result: AnalysisResult) -> str | None:
+        """Detect the Python entry module (e.g. 'main:app')."""
+
+        # Look for common entry files
+        candidates = ["main.py", "app.py", "application.py", "server.py",
+                       "src/main.py", "src/app.py"]
+
+        for filename in candidates:
+            source = read_file(self.path, filename)
+            if source is None:
+                continue
+
+            # Look for FastAPI() or Flask() app instantiation
+            app_match = re.search(
+                r"(\w+)\s*=\s*(?:FastAPI|Flask)\s*\(", source
+            )
+            if app_match:
+                app_var = app_match.group(1)
+                module_name = filename.replace("/", ".").replace(".py", "")
+                return f"{module_name}:{app_var}"
+
+        # Fallback: if main.py exists, assume main:app
+        if file_exists(self.path, "main.py"):
+            return "main:app"
+        if file_exists(self.path, "app.py"):
+            return "app:app"
+
+        return None

dockermind/cli.py

@@ -0,0 +1,288 @@
+"""
+Dockermind CLI -- built with Typer.
+
+Commands:
+    dockermind init        Analyse project and generate Dockerfile
+    dockermind build       Build Docker image from generated Dockerfile
+    dockermind run         Run the built Docker image
+    dockermind doctor      Check Docker environment health
+    dockermind version     Show dockermind version
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+import typer
+
+from dockermind import __version__
+from dockermind.analyzer import Analyzer
+from dockermind.compose_generator import generate_compose
+from dockermind.doctor import run_doctor
+from dockermind.dockerfile_generator import generate_dockerfile, generate_dockerignore
+from dockermind.runner import docker_build, docker_run
+from dockermind.utils import (
+    bold,
+    confirm,
+    cyan,
+    dim,
+    file_exists,
+    green,
+    red,
+    write_file,
+    yellow,
+)
+
+# ---------------------------------------------------------------------------
+# Typer app
+# ---------------------------------------------------------------------------
+
+app = typer.Typer(
+    name="dockermind",
+    help="Smart Dockerfile generation CLI for Node.js and Python projects.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+
+def _banner() -> None:
+    """Print the dockermind banner."""
+    typer.echo()
+    typer.echo(f"  {bold('dockermind')} {dim(f'v{__version__}')}")
+    typer.echo(f"  {dim('Smart Dockerfile generation for Node.js & Python')}")
+    typer.echo()
+
+
+# ---------------------------------------------------------------------------
+# init
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def init(
+    path: str = typer.Argument(
+        ".",
+        help="Path to the project directory to analyse.",
+    ),
+    compose: bool = typer.Option(
+        False,
+        "--compose",
+        help="Also generate docker-compose.yml.",
+    ),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Show generated files without writing to disk.",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Overwrite existing Dockerfile without asking.",
+    ),
+) -> None:
+    """Analyse a project and generate an optimised Dockerfile."""
+    _banner()
+
+    project_path = os.path.abspath(path)
+
+    if not os.path.isdir(project_path):
+        typer.echo(red(f"  Error: '{project_path}' is not a valid directory."))
+        raise typer.Exit(code=1)
+
+    typer.echo(dim(f"  Analysing: {project_path}"))
+    typer.echo()
+
+    # -- Run analysis --
+    analyzer = Analyzer(project_path)
+    result = analyzer.run()
+
+    if result.language is None:
+        typer.echo(red("  Error: Could not detect a supported project type."))
+        typer.echo(dim("  Supported: Node.js (package.json) or Python (requirements.txt / pyproject.toml)"))
+        raise typer.Exit(code=1)
+
+    # -- Display analysis summary --
+    typer.echo(f"  {bold('Project Analysis')}")
+    typer.echo("  " + "-" * 40)
+    typer.echo(f"  Language:    {cyan(result.language)}")
+
+    if result.framework:
+        typer.echo(f"  Framework:   {cyan(result.framework)}")
+
+    typer.echo(f"  Version:     {cyan(result.runtime_version)}")
+    typer.echo(f"  Port:        {cyan(str(result.port))}")
+
+    if result.language == "node":
+        typer.echo(f"  Build step:  {cyan('yes' if result.has_build_script else 'no')}")
+        if result.start_script:
+            typer.echo(f"  Start:       {dim(result.start_script)}")
+
+    if result.language == "python":
+        if result.python_entry_module:
+            typer.echo(f"  Entry:       {dim(result.python_entry_module)}")
+        typer.echo(f"  Uvicorn:     {cyan('yes' if result.uses_uvicorn else 'no')}")
+
+    # Show warnings
+    if result.warnings:
+        typer.echo()
+        for w in result.warnings:
+            typer.echo(f"  {yellow(f'Warning: {w}')}")
+
+    typer.echo()
+
+    # -- Generate files --
+    dockerfile_content = generate_dockerfile(result)
+    dockerignore_content = generate_dockerignore(result)
+    compose_content = generate_compose(result) if compose else None
+
+    # -- Dry run: just print and exit --
+    if dry_run:
+        typer.echo(bold("  --- Dockerfile ---"))
+        typer.echo()
+        typer.echo(dockerfile_content)
+
+        typer.echo(bold("  --- .dockerignore ---"))
+        typer.echo()
+        typer.echo(dockerignore_content)
+
+        if compose_content:
+            typer.echo(bold("  --- docker-compose.yml ---"))
+            typer.echo()
+            typer.echo(compose_content)
+
+        raise typer.Exit(code=0)
+
+    # -- Safety: check for existing Dockerfile --
+    dockerfile_path = os.path.join(project_path, "Dockerfile")
+    if os.path.isfile(dockerfile_path) and not force:
+        typer.echo(yellow("  A Dockerfile already exists in this project."))
+        if not confirm("  Overwrite?"):
+            typer.echo(dim("  Aborted."))
+            raise typer.Exit(code=0)
+
+    # -- Write files --
+    files_written: list[str] = []
+
+    write_file(dockerfile_path, dockerfile_content)
+    files_written.append("Dockerfile")
+
+    dockerignore_path = os.path.join(project_path, ".dockerignore")
+    if not os.path.isfile(dockerignore_path):
+        write_file(dockerignore_path, dockerignore_content)
+        files_written.append(".dockerignore")
+    else:
+        typer.echo(dim("  .dockerignore already exists, skipping."))
+
+    if compose_content:
+        compose_path = os.path.join(project_path, "docker-compose.yml")
+        if os.path.isfile(compose_path) and not force:
+            typer.echo(yellow("  docker-compose.yml already exists."))
+            if confirm("  Overwrite?"):
+                write_file(compose_path, compose_content)
+                files_written.append("docker-compose.yml")
+            else:
+                typer.echo(dim("  Skipped docker-compose.yml."))
+        else:
+            write_file(compose_path, compose_content)
+            files_written.append("docker-compose.yml")
+
+    # -- Summary --
+    typer.echo()
+    typer.echo(green("  Generated files:"))
+    for f in files_written:
+        typer.echo(green(f"    - {f}"))
+    typer.echo()
+
+
+# ---------------------------------------------------------------------------
+# build
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def build(
+    path: str = typer.Argument(
+        ".",
+        help="Path to the project directory containing the Dockerfile.",
+    ),
+    tag: str = typer.Option(
+        "dockermind-app",
+        "--tag", "-t",
+        help="Docker image tag.",
+    ),
+) -> None:
+    """Build a Docker image from the project's Dockerfile."""
+    _banner()
+
+    project_path = os.path.abspath(path)
+    dockerfile = os.path.join(project_path, "Dockerfile")
+
+    if not os.path.isfile(dockerfile):
+        typer.echo(red("  Dockerfile not found. Run 'dockermind init' first."))
+        raise typer.Exit(code=1)
+
+    success = docker_build(project_path, tag=tag)
+    raise typer.Exit(code=0 if success else 1)
+
+
+# ---------------------------------------------------------------------------
+# run
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def run(
+    tag: str = typer.Option(
+        "dockermind-app",
+        "--tag", "-t",
+        help="Docker image tag to run.",
+    ),
+    port: int = typer.Option(
+        3000,
+        "--port", "-p",
+        help="Port to map (host:container).",
+    ),
+    detach: bool = typer.Option(
+        False,
+        "--detach", "-d",
+        help="Run container in background.",
+    ),
+) -> None:
+    """Run a Docker container from a built image."""
+    _banner()
+    success = docker_run(tag=tag, port=port, detach=detach)
+    raise typer.Exit(code=0 if success else 1)
+
+
+# ---------------------------------------------------------------------------
+# doctor
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def doctor() -> None:
+    """Check that Docker is installed and running."""
+    _banner()
+    ok = run_doctor()
+    raise typer.Exit(code=0 if ok else 1)
+
+
+# ---------------------------------------------------------------------------
+# version
+# ---------------------------------------------------------------------------
+
+
+@app.command()
+def version() -> None:
+    """Show dockermind version."""
+    typer.echo(f"dockermind v{__version__}")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+if __name__ == "__main__":
+    app()

dockermind/compose_generator.py

@@ -0,0 +1,43 @@
+"""
+Docker Compose generator -- produces docker-compose.yml content from AnalysisResult.
+
+Only generated when the user explicitly requests it via ``dockermind init --compose``.
+"""
+
+from __future__ import annotations
+
+from dockermind.analyzer import AnalysisResult
+
+
+def generate_compose(analysis: AnalysisResult, service_name: str = "app") -> str:
+    """Return docker-compose.yml content as a string.
+
+    Includes:
+      - restart: unless-stopped
+      - correct port mapping
+      - env_file support
+    """
+    port = analysis.port or (3000 if analysis.language == "node" else 8000)
+
+    lines = [
+        "services:",
+        f"  {service_name}:",
+        "    build:",
+        "      context: .",
+        "      dockerfile: Dockerfile",
+        f"    ports:",
+        f'      - "{port}:{port}"',
+        "    restart: unless-stopped",
+        "    env_file:",
+        "      - .env",
+    ]
+
+    # Add environment section with common variables
+    lines += [
+        "    environment:",
+        "      - NODE_ENV=production" if analysis.language == "node" else "      - PYTHONUNBUFFERED=1",
+    ]
+
+    lines.append("")
+
+    return "\n".join(lines)