springdocker 1.0.1__py3-none-any.whl

springdocker/dockerfile.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DockerfileOptions:
+    build_tool: str
+    java_version: int = 25
+    use_buildkit_cache: bool = True
+    use_jlink: bool = True
+    non_root: bool = True
+    tuned_jvm_flags: bool = True
+    must_have_modules: tuple[str, ...] = ()
+    runtime_image: str = "temurin"
+    platform_aware: bool = True
+
+
+@dataclass(frozen=True)
+class DockerfileSection:
+    lines: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class DockerfileDocument:
+    sections: tuple[DockerfileSection, ...]
+
+    def render(self) -> str:
+        lines: list[str] = []
+        for section in self.sections:
+            lines.extend(section.lines)
+        return "\n".join(lines)
+
+
+def _build_setup(build_tool: str) -> tuple[list[str], str, str]:
+    if build_tool == "maven":
+        return (
+            [
+                "COPY mvnw pom.xml ./",
+                "COPY .mvn ./.mvn",
+                "RUN chmod +x mvnw",
+                "COPY src ./src",
+            ],
+            "./mvnw -B -q package -DskipTests",
+            "target/*.jar",
+        )
+    return (
+        [
+            "COPY gradlew build.gradle settings.gradle ./",
+            "COPY gradle ./gradle",
+            "RUN chmod +x gradlew",
+            "COPY src ./src",
+        ],
+        "./gradlew --no-daemon bootJar -x test",
+        "build/libs/*-SNAPSHOT.jar",
+    )
+
+
+def _section(*lines: str) -> DockerfileSection:
+    return DockerfileSection(lines=tuple(lines))
+
+
+def _validate_options(options: DockerfileOptions) -> None:
+    if options.build_tool not in {"maven", "gradle"}:
+        raise ValueError("build tool must be 'maven' or 'gradle'")
+    if options.java_version < 17:
+        raise ValueError("java version must be >= 17")
+    if options.runtime_image not in {"temurin", "distroless"}:
+        raise ValueError("runtime_image must be 'temurin' or 'distroless'")
+
+
+def _compose_dockerfile(options: DockerfileOptions) -> DockerfileDocument:
+    setup, build_cmd, jar_path = _build_setup(options.build_tool)
+    build_step = (
+        "RUN --mount=type=cache,sharing=locked,target=/root/.m2 " + build_cmd
+        if options.use_buildkit_cache and options.build_tool == "maven"
+        else "RUN --mount=type=cache,sharing=locked,target=/root/.gradle " + build_cmd
+        if options.use_buildkit_cache and options.build_tool == "gradle"
+        else f"RUN {build_cmd}"
+    )
+
+    jvm_args: list[str] = []
+    if options.tuned_jvm_flags:
+        jvm_args.extend(
+            [
+                "-XX:MaxRAMPercentage=75",
+                "-XX:+ExitOnOutOfMemoryError",
+                "-Djava.io.tmpdir=/tmp",
+            ]
+        )
+
+    sections: list[DockerfileSection] = [
+        _section(
+            "# syntax=docker/dockerfile:1",
+            "# Generated by springdocker",
+            f"# Java {options.java_version} | build-tool: {options.build_tool}",
+            "",
+        )
+    ]
+    if options.platform_aware:
+        sections.append(_section("ARG TARGETPLATFORM", "ARG BUILDPLATFORM", ""))
+    sections.append(
+        _section(
+            f"FROM --platform=$BUILDPLATFORM eclipse-temurin:{options.java_version}-jdk AS build",
+            "WORKDIR /app",
+            *setup,
+            build_step,
+            "",
+        )
+    )
+
+    if options.use_jlink:
+        must_have_csv = ",".join(options.must_have_modules).replace('"', '\\"')
+        sections.append(
+            _section(
+                f"FROM --platform=$BUILDPLATFORM eclipse-temurin:{options.java_version}-jdk AS jre-builder",
+                "WORKDIR /jre",
+                f"COPY --from=build /app/{jar_path} app.jar",
+                (
+                    f"RUN jdeps --ignore-missing-deps --recursive --multi-release {options.java_version} "
+                    "--print-module-deps app.jar > modules.txt"
+                ),
+                f'ARG MUSTHAVE_MODULES="{must_have_csv}"',
+                "RUN set -eux; \\",
+                "    MODULES=$( (tr ',' '\\n' < modules.txt; printf '%s\\n' \"$MUSTHAVE_MODULES\" | tr ',' '\\n') \\",
+                "      | sed 's/^[[:space:]]*//;s/[[:space:]]*$//' | grep -v '^$' | sort -u | paste -sd, -); \\",
+                "    jlink --add-modules \"$MODULES\" --strip-debug --no-man-pages --no-header-files --compress=2 --output /opt/java",
+                "",
+            )
+        )
+
+    if options.runtime_image == "distroless":
+        runtime_base = (
+            "gcr.io/distroless/base-debian12:nonroot"
+            if options.use_jlink
+            else f"gcr.io/distroless/java{options.java_version}-debian12:nonroot"
+        )
+        distroless_lines = [
+            f"FROM --platform=$TARGETPLATFORM {runtime_base}",
+            "WORKDIR /app",
+            "VOLUME /tmp",
+            f"COPY --from=build /app/{jar_path} app.jar",
+            "EXPOSE 8080",
+            "EXPOSE 8081",
+        ]
+        if options.use_jlink:
+            distroless_lines.extend(
+                [
+                    "COPY --from=jre-builder /opt/java /opt/java",
+                    "ENV JAVA_HOME=/opt/java",
+                    'ENV PATH="${JAVA_HOME}/bin:${PATH}"',
+                ]
+            )
+        if options.non_root:
+            distroless_lines.append("USER nonroot")
+        sections.append(_section(*distroless_lines))
+    else:
+        temurin_lines = [f"FROM --platform=$TARGETPLATFORM eclipse-temurin:{options.java_version}-jre"]
+        if options.non_root:
+            temurin_lines.extend(
+                [
+                    "RUN groupadd --system --gid 1001 javauser && useradd --system --uid 1001 --gid 1001 --no-create-home --shell /usr/sbin/nologin javauser",
+                    "RUN install -d -o 1001 -g 1001 -m 755 /app && install -d -o 1001 -g 1001 -m 1777 /tmp",
+                ]
+            )
+        else:
+            temurin_lines.append("RUN install -d -m 755 /app && install -d -m 1777 /tmp")
+
+        temurin_lines.extend(
+            [
+                "WORKDIR /app",
+                "VOLUME /tmp",
+                f"COPY --from=build {'--chown=1001:1001 ' if options.non_root else ''}/app/{jar_path} app.jar",
+                "EXPOSE 8080",
+                "EXPOSE 8081",
+            ]
+        )
+        sections.append(_section(*temurin_lines))
+
+    if options.use_jlink and options.runtime_image != "distroless":
+        sections.append(
+            _section(
+                "COPY --from=jre-builder /opt/java /opt/java",
+                "ENV JAVA_HOME=/opt/java",
+                'ENV PATH="${JAVA_HOME}/bin:${PATH}"',
+            )
+        )
+
+    entrypoint = ["java", *jvm_args, "-jar", "app.jar"]
+    tail_lines: list[str] = []
+    if options.non_root and options.runtime_image != "distroless":
+        tail_lines.append("USER 1001")
+    tail_lines.append("ENTRYPOINT [" + ", ".join(f'"{arg}"' for arg in entrypoint) + "]")
+    tail_lines.append(
+        "# Runtime hardening tip: run with --read-only --cap-drop=ALL --security-opt=no-new-privileges --tmpfs /tmp"
+    )
+    tail_lines.append("")
+    sections.append(_section(*tail_lines))
+    return DockerfileDocument(sections=tuple(sections))
+
+
+def build_dockerfile(options: DockerfileOptions) -> str:
+    _validate_options(options)
+    return _compose_dockerfile(options).render()
+
+
+def explain_dockerfile_text(text: str) -> dict[str, object]:
+    lines = text.splitlines()
+    if "# Generated by springdocker" not in text:
+        raise ValueError("Dockerfile was not generated by springdocker")
+
+    header_match = re.search(r"# Java (\d+) \| build-tool: (maven|gradle)", text)
+    java_version = int(header_match.group(1)) if header_match else None
+    build_tool = header_match.group(2) if header_match else None
+
+    features: list[dict[str, object]] = []
+    if sum(1 for line in lines if line.startswith("FROM ")) >= 2:
+        features.append(
+            {
+                "name": "multi-stage build",
+                "enabled": True,
+                "reason": "Separates the build stage from the runtime stage.",
+            }
+        )
+    if "jdeps" in text and "jlink" in text:
+        features.append(
+            {
+                "name": "jlink runtime",
+                "enabled": True,
+                "reason": "Builds a smaller custom runtime from the detected module list.",
+            }
+        )
+    if "--mount=type=cache" in text:
+        features.append(
+            {
+                "name": "BuildKit cache",
+                "enabled": True,
+                "reason": "Caches Maven or Gradle dependencies between builds.",
+            }
+        )
+    if "TARGETPLATFORM" in text and "BUILDPLATFORM" in text:
+        features.append(
+            {
+                "name": "multi-architecture build",
+                "enabled": True,
+                "reason": "Uses Buildx platform arguments for arm64 and amd64 builds.",
+            }
+        )
+    if "gcr.io/distroless" in text:
+        features.append(
+            {
+                "name": "distroless runtime",
+                "enabled": True,
+                "reason": "Uses a minimal distroless runtime image.",
+            }
+        )
+    if "VOLUME /tmp" in text:
+        features.append(
+            {
+                "name": "read-only filesystem ready",
+                "enabled": True,
+                "reason": "Keeps /tmp writable when the container root filesystem is read-only.",
+            }
+        )
+    if "USER 1001" in text or "USER nonroot" in text or "gcr.io/distroless" in text:
+        features.append(
+            {
+                "name": "non-root runtime",
+                "enabled": True,
+                "reason": "Runs the application as an unprivileged container user.",
+            }
+        )
+    if "-XX:MaxRAMPercentage=75" in text:
+        features.append(
+            {
+                "name": "tuned JVM flags",
+                "enabled": True,
+                "reason": "Applies container-friendly JVM memory and failure defaults.",
+            }
+        )
+
+    must_have_match = re.search(r'ARG MUSTHAVE_MODULES="([^"]*)"', text)
+    must_have_modules = tuple(
+        module for module in (part.strip() for part in (must_have_match.group(1) if must_have_match else "").split(",")) if module
+    )
+    if must_have_modules:
+        features.append(
+            {
+                "name": "must-have modules",
+                "enabled": True,
+                "reason": "Includes manually curated modules that jdeps cannot infer reliably.",
+            }
+        )
+
+    summary_parts = []
+    if build_tool and java_version is not None:
+        summary_parts.append(f"This {build_tool} Dockerfile targets Java {java_version}.")
+    if any(feature["name"] == "multi-stage build" for feature in features):
+        summary_parts.append("It uses a multi-stage build to keep the runtime image separate from compilation.")
+    if any(feature["name"] == "jlink runtime" for feature in features):
+        summary_parts.append("It builds a custom runtime with jlink.")
+    if any(feature["name"] == "non-root runtime" for feature in features):
+        summary_parts.append("It runs as a non-root user.")
+    if any(feature["name"] == "BuildKit cache" for feature in features):
+        summary_parts.append("It uses BuildKit cache mounts to speed up repeat builds.")
+    if any(feature["name"] == "multi-architecture build" for feature in features):
+        summary_parts.append("It is Buildx-friendly for amd64 and arm64 image builds.")
+    if any(feature["name"] == "read-only filesystem ready" for feature in features):
+        summary_parts.append("It keeps /tmp writable for read-only root filesystem deployments.")
+    if any(feature["name"] == "tuned JVM flags" for feature in features):
+        summary_parts.append("It applies container-oriented JVM defaults.")
+    if must_have_modules:
+        summary_parts.append("It adds curated modules for reflection or dynamic-loading edge cases.")
+
+    if not summary_parts:
+        summary_parts.append("No recognized springdocker optimizations were detected.")
+
+    notes = [
+        "Only Dockerfiles generated by springdocker are supported in v1.",
+        "Explanation is based on static text signals in the file.",
+    ]
+
+    return {
+        "source": "springdocker-generated Dockerfile",
+        "build_tool": build_tool,
+        "java_version": java_version,
+        "stage_count": sum(1 for line in lines if line.startswith("FROM ")),
+        "features": features,
+        "summary": " ".join(summary_parts),
+        "notes": notes,
+    }

springdocker/errors.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import sys
+
+EXIT_OK = 0
+EXIT_FAILURE = 1
+EXIT_USAGE = 2
+
+
+def print_error(message: str) -> None:
+    print(f"error: {message}", file=sys.stderr)
+
+
+def print_warning(message: str) -> None:
+    print(f"warning: {message}", file=sys.stderr)
+

springdocker/plugins.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from importlib.metadata import EntryPoint, entry_points
+from typing import Any, Protocol, cast
+
+from .dockerfile import DockerfileOptions
+
+DOCKERFILE_MUTATOR_GROUP = "springdocker.dockerfile_mutators"
+
+
+class DockerfileMutator(Protocol):
+    name: str
+
+    def mutate_dockerfile(self, dockerfile_text: str, options: DockerfileOptions) -> str: ...
+
+
+@dataclass(frozen=True)
+class PluginExecution:
+    dockerfile_text: str
+    warnings: tuple[str, ...]
+
+
+def _iter_entry_points(group: str) -> list[EntryPoint]:
+    discovered = entry_points()
+    if hasattr(discovered, "select"):
+        return list(discovered.select(group=group))
+    legacy = cast(dict[str, list[EntryPoint]], discovered)
+    return list(legacy.get(group, []))
+
+
+def _to_mutator(candidate: Any, entry_point_name: str) -> DockerfileMutator:
+    instance = candidate() if isinstance(candidate, type) else candidate
+    if hasattr(instance, "mutate_dockerfile") and callable(instance.mutate_dockerfile):
+        if hasattr(instance, "name"):
+            return cast(DockerfileMutator, instance)
+
+        class _NamedMutator:
+            name = entry_point_name
+
+            def mutate_dockerfile(self, dockerfile_text: str, options: DockerfileOptions) -> str:
+                return cast(str, instance.mutate_dockerfile(dockerfile_text, options))
+
+        return cast(DockerfileMutator, _NamedMutator())
+    if callable(instance):
+        fn = instance
+
+        class _FunctionMutator:
+            name = entry_point_name
+
+            def mutate_dockerfile(self, dockerfile_text: str, options: DockerfileOptions) -> str:
+                return cast(str, fn(dockerfile_text, options))
+
+        return cast(DockerfileMutator, _FunctionMutator())
+    raise TypeError("plugin must define mutate_dockerfile(...) or be a callable")
+
+
+def apply_dockerfile_mutators(dockerfile_text: str, options: DockerfileOptions) -> PluginExecution:
+    if os.environ.get("SPRINGDOCKER_DISABLE_PLUGINS", "").lower() in {"1", "true", "yes", "on"}:
+        return PluginExecution(dockerfile_text=dockerfile_text, warnings=())
+
+    warnings: list[str] = []
+    rendered = dockerfile_text
+    for plugin_entry in _iter_entry_points(DOCKERFILE_MUTATOR_GROUP):
+        try:
+            loaded = plugin_entry.load()
+            mutator = _to_mutator(loaded, plugin_entry.name)
+            mutated = mutator.mutate_dockerfile(rendered, options)
+            if not isinstance(mutated, str):
+                raise TypeError("plugin must return str from mutate_dockerfile")
+            rendered = mutated
+        except Exception as exc:  # pragma: no cover - covered through behavior tests
+            warnings.append(f"plugin '{plugin_entry.name}' failed: {exc}")
+    return PluginExecution(dockerfile_text=rendered, warnings=tuple(warnings))

springdocker/project_detect.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class ProjectInfo:
+    root: Path
+    build_tool: str
+    has_spring_markers: bool
+
+
+@dataclass(frozen=True)
+class InspectInfo:
+    root: Path
+    build_tool: str
+    has_spring_markers: bool
+    java_version: int | None
+    spring_boot_version: str | None
+    direct_dependencies: tuple[str, ...]
+    config_exists: bool
+    generated_dockerfiles: tuple[str, ...]
+    reflection_hits: tuple[str, ...]
+    runtime_compatibility: str
+    recommendations: tuple[str, ...]
+
+
+def detect_build_tool(root: Path, explicit: str | None = None) -> str:
+    """Detect Maven or Gradle build tool from project markers."""
+    if explicit:
+        if explicit not in {"maven", "gradle"}:
+            raise ValueError("build tool must be 'maven' or 'gradle'")
+        return explicit
+
+    has_maven = (root / "pom.xml").exists()
+    has_gradle = (root / "gradlew").exists() or any(
+        (root / name).exists() for name in ("build.gradle", "build.gradle.kts")
+    )
+
+    if has_maven and has_gradle:
+        raise ValueError(
+            "Both Maven and Gradle markers found. Pass --build-tool explicitly."
+        )
+    if has_maven:
+        return "maven"
+    if has_gradle:
+        return "gradle"
+    raise ValueError("Could not detect build tool. Expected pom.xml or gradle markers.")
+
+
+def has_spring_project_markers(root: Path) -> bool:
+    """Best-effort Spring Boot marker detection for Java projects."""
+    if (root / "src" / "main" / "resources" / "application.properties").exists():
+        return True
+    if (root / "src" / "main" / "resources" / "application.yml").exists():
+        return True
+
+    # Lightweight content checks in build descriptors.
+    for descriptor in ("pom.xml", "build.gradle", "build.gradle.kts"):
+        path = root / descriptor
+        if not path.exists():
+            continue
+        text = path.read_text(encoding="utf-8", errors="ignore")
+        if "spring-boot" in text or "org.springframework.boot" in text:
+            return True
+    return False
+
+
+def inspect_project(root: Path, explicit_build_tool: str | None = None) -> ProjectInfo:
+    build_tool = detect_build_tool(root, explicit_build_tool)
+    return ProjectInfo(
+        root=root,
+        build_tool=build_tool,
+        has_spring_markers=has_spring_project_markers(root),
+    )
+
+
+def _strip_namespace(element: ET.Element) -> None:
+    for child in element.iter():
+        if "}" in child.tag:
+            child.tag = child.tag.split("}", 1)[1]
+
+
+def _parse_int(text: str | None) -> int | None:
+    if text is None:
+        return None
+    match = re.search(r"\d+", text)
+    if not match:
+        return None
+    return int(match.group(0))
+
+
+def _extract_maven_info(root: Path) -> tuple[int | None, str | None, tuple[str, ...]]:
+    pom = root / "pom.xml"
+    if not pom.exists():
+        return None, None, ()
+
+    try:
+        tree = ET.parse(pom)
+    except ET.ParseError:
+        return None, None, ()
+
+    xml_root = tree.getroot()
+    _strip_namespace(xml_root)
+
+    java_version = None
+    properties = xml_root.find("properties")
+    if properties is not None:
+        for key in ("java.version", "maven.compiler.release", "maven.compiler.source", "maven.compiler.target"):
+            java_version = _parse_int(properties.findtext(key))
+            if java_version is not None:
+                break
+
+    spring_boot_version = None
+    parent = xml_root.find("parent")
+    if parent is not None:
+        version = parent.findtext("version")
+        if version:
+            spring_boot_version = version.strip()
+    if spring_boot_version is None:
+        deps = xml_root.find("dependencyManagement")
+        if deps is not None:
+            spring_boot_version = None
+
+    dependencies: list[str] = []
+    for deps in xml_root.findall("dependencies"):
+        for dep in deps.findall("dependency"):
+            group = (dep.findtext("groupId") or "").strip()
+            artifact = (dep.findtext("artifactId") or "").strip()
+            if group and artifact:
+                dependencies.append(f"{group}:{artifact}")
+
+    return java_version, spring_boot_version, tuple(dependencies)
+
+
+def _extract_gradle_info(root: Path) -> tuple[int | None, str | None, tuple[str, ...]]:
+    for candidate in ("build.gradle", "build.gradle.kts"):
+        path = root / candidate
+        if not path.exists():
+            continue
+        text = path.read_text(encoding="utf-8", errors="ignore")
+
+        spring_boot_version = None
+        m = re.search(r"""org\.springframework\.boot['"]\s+version\s+['"]([^'"]+)['"]""", text)
+        if m:
+            spring_boot_version = m.group(1)
+
+        java_version = None
+        for pattern in (
+            r"JavaLanguageVersion\.of\((\d+)\)",
+            r"sourceCompatibility\s*=\s*['\"]?(\d+)",
+            r"targetCompatibility\s*=\s*['\"]?(\d+)",
+        ):
+            m = re.search(pattern, text)
+            if m:
+                java_version = int(m.group(1))
+                break
+
+        dependencies: list[str] = []
+        for dep_match in re.finditer(
+            r"""(?:implementation|api|compileOnly|runtimeOnly|testImplementation)\s*(?:\(|\s)\s*['"]([^:'"]+):([^:'"]+):([^'"]+)['"]""",
+            text,
+        ):
+            dependencies.append(f"{dep_match.group(1)}:{dep_match.group(2)}")
+
+        return java_version, spring_boot_version, tuple(dependencies)
+
+    return None, None, ()
+
+
+def _find_reflection_hits(root: Path) -> tuple[str, ...]:
+    hits: list[str] = []
+    for path in sorted(root.rglob("*.java")):
+        try:
+            lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
+        except OSError:
+            continue
+        for line_no, line in enumerate(lines, start=1):
+            if any(token in line for token in ("Class.forName(", "getDeclaredMethod(", "getDeclaredField(", "setAccessible(")):
+                hits.append(f"{path.relative_to(root)}:{line_no}:{line.strip()}")
+    return tuple(hits)
+
+
+def _runtime_compatibility(java_version: int | None, spring_boot_version: str | None) -> tuple[str, tuple[str, ...]]:
+    recommendations: list[str] = []
+    if spring_boot_version is None:
+        return "unknown", ("Spring Boot version could not be detected statically.",)
+
+    boot_major = _parse_int(spring_boot_version.split(".", 1)[0])
+    if boot_major is None:
+        return "unknown", ("Spring Boot version could not be parsed cleanly.",)
+
+    if boot_major >= 4:
+        min_java = 21
+    elif boot_major >= 3:
+        min_java = 17
+    else:
+        min_java = 8
+
+    if java_version is None:
+        recommendations.append("Java version could not be detected statically.")
+        return "unknown", tuple(recommendations)
+
+    if java_version < min_java:
+        return "incompatible", (f"Spring Boot {spring_boot_version} generally expects Java {min_java}+.",)
+    if java_version >= min_java:
+        return "compatible", (f"Spring Boot {spring_boot_version} and Java {java_version} look compatible.",)
+    return "unknown", ("Compatibility could not be determined.",)
+
+
+def inspect_project_details(root: Path, explicit_build_tool: str | None = None) -> InspectInfo:
+    project = inspect_project(root, explicit_build_tool)
+    java_version = None
+    spring_boot_version = None
+    direct_dependencies: tuple[str, ...] = ()
+    if project.build_tool == "maven":
+        java_version, spring_boot_version, direct_dependencies = _extract_maven_info(root)
+    else:
+        java_version, spring_boot_version, direct_dependencies = _extract_gradle_info(root)
+
+    compatibility, compatibility_notes = _runtime_compatibility(java_version, spring_boot_version)
+    config_exists = (root / ".springdocker.toml").exists()
+    generated_dockerfiles = tuple(
+        str(path.relative_to(root))
+        for path in sorted(root.glob("Dockerfile*"))
+        if path.is_file()
+    )
+    reflection_hits = _find_reflection_hits(root)
+    recommendations = list(compatibility_notes)
+    if not config_exists:
+        recommendations.append("Run `springdocker init` to create a starter .springdocker.toml file.")
+    if not generated_dockerfiles:
+        recommendations.append("No Dockerfile artifacts found in the project root.")
+    if not direct_dependencies:
+        recommendations.append("No direct dependency list could be extracted statically.")
+    if not reflection_hits:
+        recommendations.append("No direct reflection calls were found in Java source.")
+    else:
+        recommendations.append("Direct reflection calls were found in Java source; review them before using jlink.")
+
+    return InspectInfo(
+        root=project.root,
+        build_tool=project.build_tool,
+        has_spring_markers=project.has_spring_markers,
+        java_version=java_version,
+        spring_boot_version=spring_boot_version,
+        direct_dependencies=direct_dependencies,
+        config_exists=config_exists,
+        generated_dockerfiles=generated_dockerfiles,
+        reflection_hits=reflection_hits,
+        runtime_compatibility=compatibility,
+        recommendations=tuple(recommendations),
+    )