javi-forge 1.6.1 → 1.7.1

package/dist/lib/ci-config.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Versioned mixed-runner CI config (`.javi-forge/ci.yaml`) — schema and loader.
+ *
+ * Hybrid repositories declare every required runner explicitly and in order.
+ * Single-stack repositories need no config: auto-detection stays the default.
+ *
+ * Validation is fail-closed: any schema violation produces a CIConfigError
+ * listing every problem, and no partially-valid config is ever returned.
+ * YAML parsing uses the `yaml` package, already a runtime dependency.
+ */
+import type { Stack } from "../types/index.js";
+export declare const CI_CONFIG_VERSION = 1;
+/** Default config locations, in discovery order, relative to the project root. */
+export declare const CI_CONFIG_CANDIDATES: readonly [".javi-forge/ci.yaml", ".javi-forge/ci.yml"];
+export interface CIRunnerConfig {
+    /** Unique runner name (used in step ids and reports) */
+    name: string;
+    /** Toolchain stack — selects the default CI image and default commands */
+    stack: Stack;
+    /** Working directory relative to the project root (default: ".") */
+    directory: string;
+    /** Explicit container image (mutually exclusive with `buildContext`) */
+    image?: string;
+    /** Docker build context directory (mutually exclusive with `image`) */
+    buildContext?: string;
+    /** Dependency setup commands, run before lint/build/test */
+    setup: string[];
+    lint: string[];
+    build: string[];
+    test: string[];
+    security: string[];
+    /** Tools that must exist in the runner environment (validated fail-closed) */
+    requires: string[];
+}
+export interface CIConfig {
+    version: number;
+    runners: CIRunnerConfig[];
+}
+export interface CIConfigValidationError {
+    path: string;
+    message: string;
+}
+export declare class CIConfigError extends Error {
+    readonly errors: CIConfigValidationError[];
+    constructor(errors: CIConfigValidationError[], source?: string);
+}
+/** Stacks accepted by the CI config schema and the --stack override. */
+export declare const CI_STACKS: readonly string[];
+/**
+ * Parse and validate CI config YAML text. Throws CIConfigError listing every
+ * validation problem; never returns a partially valid config.
+ */
+export declare function parseCIConfig(rawYaml: string, source?: string): CIConfig;
+/**
+ * Load and validate a CI config file. Fails closed: a missing file or any
+ * validation error throws — no config is ever silently ignored.
+ */
+export declare function loadCIConfig(configPath: string): Promise<CIConfig>;
+/**
+ * Discover the default CI config for a project directory.
+ * Returns the config path, or null when the project has no config
+ * (single-stack auto-detection stays the default).
+ */
+export declare function findCIConfig(projectDir: string): Promise<string | null>;
+//# sourceMappingURL=ci-config.d.ts.map

package/dist/lib/ci-config.js

@@ -0,0 +1,297 @@
+/**
+ * Versioned mixed-runner CI config (`.javi-forge/ci.yaml`) — schema and loader.
+ *
+ * Hybrid repositories declare every required runner explicitly and in order.
+ * Single-stack repositories need no config: auto-detection stays the default.
+ *
+ * Validation is fail-closed: any schema violation produces a CIConfigError
+ * listing every problem, and no partially-valid config is ever returned.
+ * YAML parsing uses the `yaml` package, already a runtime dependency.
+ */
+import path from "node:path";
+import fs from "fs-extra";
+import YAML from "yaml";
+// =============================================================================
+// Types
+// =============================================================================
+export const CI_CONFIG_VERSION = 1;
+/** Default config locations, in discovery order, relative to the project root. */
+export const CI_CONFIG_CANDIDATES = [
+    ".javi-forge/ci.yaml",
+    ".javi-forge/ci.yml",
+];
+export class CIConfigError extends Error {
+    errors;
+    constructor(errors, source) {
+        const where = source ? ` in ${source}` : "";
+        const lines = errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n");
+        super(`Invalid CI config${where}:\n${lines}`);
+        this.name = "CIConfigError";
+        this.errors = errors;
+    }
+}
+// =============================================================================
+// Validation
+// =============================================================================
+const VALID_STACKS = [
+    "node",
+    "python",
+    "go",
+    "rust",
+    "java-gradle",
+    "java-maven",
+    "elixir",
+];
+/** Stacks accepted by the CI config schema and the --stack override. */
+export const CI_STACKS = VALID_STACKS;
+const TOP_LEVEL_FIELDS = new Set(["version", "runners"]);
+/** Runner names become docker image tags — keep them tag-safe. */
+const RUNNER_NAME_RE = /^[a-zA-Z0-9_][a-zA-Z0-9._-]*$/;
+/** Required tools are checked via `command -v <tool>` — no shell metachars. */
+const TOOL_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._+~-]*$/;
+const RUNNER_FIELDS = new Set([
+    "name",
+    "stack",
+    "directory",
+    "image",
+    "build-context",
+    "setup",
+    "lint",
+    "build",
+    "test",
+    "security",
+    "requires",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeCommands(value, fieldPath, errors) {
+    if (value === undefined)
+        return [];
+    if (typeof value === "string")
+        return value.trim() ? [value] : [];
+    if (Array.isArray(value)) {
+        const bad = value.some((v) => typeof v !== "string" || !v.trim());
+        if (!bad)
+            return value;
+    }
+    errors.push({
+        path: fieldPath,
+        message: "must be a non-empty string or a list of non-empty strings",
+    });
+    return [];
+}
+function normalizeStringList(value, fieldPath, errors) {
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value) && value.every((v) => typeof v === "string")) {
+        return value;
+    }
+    errors.push({ path: fieldPath, message: "must be a list of strings" });
+    return [];
+}
+function validateRunner(raw, index, errors) {
+    const base = `runners[${index}]`;
+    if (!isRecord(raw)) {
+        errors.push({ path: base, message: "runner must be an object" });
+        return null;
+    }
+    for (const key of Object.keys(raw)) {
+        if (!RUNNER_FIELDS.has(key)) {
+            errors.push({
+                path: `${base}.${key}`,
+                message: `unknown field "${key}"`,
+            });
+        }
+    }
+    const name = raw.name;
+    if (typeof name !== "string" || !name.trim()) {
+        errors.push({
+            path: `${base}.name`,
+            message: "name is required and must be a non-empty string",
+        });
+    }
+    else if (!RUNNER_NAME_RE.test(name.trim())) {
+        errors.push({
+            path: `${base}.name`,
+            message: "name must start with a letter, digit or underscore and contain only [a-zA-Z0-9._-] (it is used as a docker image tag)",
+        });
+    }
+    const stack = raw.stack;
+    if (typeof stack !== "string" || !VALID_STACKS.includes(stack)) {
+        errors.push({
+            path: `${base}.stack`,
+            message: `stack is required and must be one of: ${VALID_STACKS.join(", ")}`,
+        });
+    }
+    let directory = ".";
+    if (raw.directory !== undefined) {
+        if (typeof raw.directory !== "string" || !raw.directory.trim()) {
+            errors.push({
+                path: `${base}.directory`,
+                message: "directory must be a non-empty string",
+            });
+        }
+        else {
+            const normalized = path.posix.normalize(raw.directory);
+            if (path.isAbsolute(raw.directory) ||
+                normalized === ".." ||
+                normalized.startsWith("../")) {
+                errors.push({
+                    path: `${base}.directory`,
+                    message: "directory must stay inside the project root",
+                });
+            }
+            else {
+                directory = normalized;
+            }
+        }
+    }
+    let image;
+    if (raw.image !== undefined) {
+        if (typeof raw.image !== "string" || !raw.image.trim()) {
+            errors.push({
+                path: `${base}.image`,
+                message: "image must be a non-empty string",
+            });
+        }
+        else {
+            image = raw.image;
+        }
+    }
+    let buildContext;
+    if (raw["build-context"] !== undefined) {
+        if (typeof raw["build-context"] !== "string" ||
+            !raw["build-context"].trim()) {
+            errors.push({
+                path: `${base}.build-context`,
+                message: "build-context must be a non-empty string (directory)",
+            });
+        }
+        else {
+            buildContext = raw["build-context"];
+        }
+    }
+    if (image && buildContext) {
+        errors.push({
+            path: `${base}.image`,
+            message: "image and build-context are mutually exclusive — set only one",
+        });
+    }
+    const requires = normalizeStringList(raw.requires, `${base}.requires`, errors);
+    for (const tool of requires) {
+        if (!TOOL_NAME_RE.test(tool)) {
+            errors.push({
+                path: `${base}.requires`,
+                message: `requires entry "${tool}" has unsafe characters — expected a plain tool name like python, ruff or node`,
+            });
+        }
+    }
+    // If anything failed, the caller discards all runners (fail closed).
+    return {
+        name: typeof name === "string" ? name.trim() : "",
+        stack: stack,
+        directory,
+        image,
+        buildContext,
+        setup: normalizeCommands(raw.setup, `${base}.setup`, errors),
+        lint: normalizeCommands(raw.lint, `${base}.lint`, errors),
+        build: normalizeCommands(raw.build, `${base}.build`, errors),
+        test: normalizeCommands(raw.test, `${base}.test`, errors),
+        security: normalizeCommands(raw.security, `${base}.security`, errors),
+        requires,
+    };
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Parse and validate CI config YAML text. Throws CIConfigError listing every
+ * validation problem; never returns a partially valid config.
+ */
+export function parseCIConfig(rawYaml, source) {
+    let doc;
+    try {
+        doc = YAML.parse(rawYaml);
+    }
+    catch (e) {
+        throw new CIConfigError([
+            {
+                path: "<document>",
+                message: `invalid YAML: ${e instanceof Error ? e.message.split("\n")[0] : String(e)}`,
+            },
+        ], source);
+    }
+    const errors = [];
+    if (!isRecord(doc)) {
+        throw new CIConfigError([{ path: "<document>", message: "config must be a YAML object/mapping" }], source);
+    }
+    for (const key of Object.keys(doc)) {
+        if (!TOP_LEVEL_FIELDS.has(key)) {
+            errors.push({ path: key, message: `unknown field "${key}"` });
+        }
+    }
+    if (doc.version !== CI_CONFIG_VERSION) {
+        errors.push({
+            path: "version",
+            message: `version is required and must be the number ${CI_CONFIG_VERSION}`,
+        });
+    }
+    if (!Array.isArray(doc.runners) || doc.runners.length === 0) {
+        errors.push({
+            path: "runners",
+            message: "runners is required and must be a non-empty list",
+        });
+    }
+    const runners = [];
+    if (Array.isArray(doc.runners)) {
+        doc.runners.forEach((raw, index) => {
+            const runner = validateRunner(raw, index, errors);
+            if (runner)
+                runners.push(runner);
+        });
+        const seen = new Set();
+        for (const runner of runners) {
+            if (!runner.name)
+                continue;
+            if (seen.has(runner.name)) {
+                errors.push({
+                    path: "runners",
+                    message: `duplicate runner name "${runner.name}"`,
+                });
+            }
+            seen.add(runner.name);
+        }
+    }
+    if (errors.length > 0) {
+        throw new CIConfigError(errors, source);
+    }
+    return { version: CI_CONFIG_VERSION, runners };
+}
+/**
+ * Load and validate a CI config file. Fails closed: a missing file or any
+ * validation error throws — no config is ever silently ignored.
+ */
+export async function loadCIConfig(configPath) {
+    if (!(await fs.pathExists(configPath))) {
+        throw new CIConfigError([
+            { path: configPath, message: "config file not found" },
+        ]);
+    }
+    const raw = await fs.readFile(configPath, "utf-8");
+    return parseCIConfig(raw, configPath);
+}
+/**
+ * Discover the default CI config for a project directory.
+ * Returns the config path, or null when the project has no config
+ * (single-stack auto-detection stays the default).
+ */
+export async function findCIConfig(projectDir) {
+    for (const candidate of CI_CONFIG_CANDIDATES) {
+        const candidatePath = path.join(projectDir, candidate);
+        if (await fs.pathExists(candidatePath))
+            return candidatePath;
+    }
+    return null;
+}
+//# sourceMappingURL=ci-config.js.map

package/dist/lib/claudemd.js

@@ -48,7 +48,7 @@ const PLUGIN_INSTRUCTIONS = {
 // Internal helpers
 // =============================================================================
 function getStackClaudeMd(stack) {
-    return STACK_CLAUDEMD_MAP[stack] ?? STACK_CLAUDEMD_MAP["default"];
+    return STACK_CLAUDEMD_MAP[stack] ?? STACK_CLAUDEMD_MAP.default;
 }
 export function buildClaudeMd(projectName, stack, entry, contextDir, modules) {
     const lines = [];

package/dist/lib/codex-export.js

@@ -1,5 +1,5 @@
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
 import { PLUGIN_MANIFEST_FILE, PLUGINS_DIR } from "../constants.js";
 import { parseFrontmatter } from "./frontmatter.js";
 const DEFAULT_MODEL = "o4-mini";
@@ -12,15 +12,11 @@ export function skillToCodexToml(raw) {
     const parsed = parseFrontmatter(raw);
     if (!parsed)
         return null;
-    const name = parsed.data["name"];
+    const name = parsed.data.name;
     if (typeof name !== "string" || !name)
         return null;
-    const description = typeof parsed.data["description"] === "string"
-        ? parsed.data["description"]
-        : "";
-    const model = typeof parsed.data["model"] === "string"
-        ? parsed.data["model"]
-        : DEFAULT_MODEL;
+    const description = typeof parsed.data.description === "string" ? parsed.data.description : "";
+    const model = typeof parsed.data.model === "string" ? parsed.data.model : DEFAULT_MODEL;
     const instructions = description
         ? `${description}\n\n${parsed.content}`.trim()
         : parsed.content.trim();

package/dist/lib/common.js

@@ -1,5 +1,5 @@
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
 /**
  * Detect the project stack by looking for well-known build/config files.
  * Returns the first match (precedence order matters).
@@ -18,7 +18,7 @@ export async function detectStack(projectDir) {
     }
     // Node.js
     if (await exists("package.json")) {
-        const pkg = await fs
+        const _pkg = await fs
             .readJson(path.join(projectDir, "package.json"))
             .catch(() => ({}));
         const buildTool = (await exists("pnpm-lock.yaml"))

package/dist/lib/context.js

@@ -1,11 +1,11 @@
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
 import { STACK_CONTEXT_MAP } from "../constants.js";
 // =============================================================================
 // Internal helpers
 // =============================================================================
 function getStackContext(stack) {
-    return STACK_CONTEXT_MAP[stack] ?? STACK_CONTEXT_MAP["default"];
+    return STACK_CONTEXT_MAP[stack] ?? STACK_CONTEXT_MAP.default;
 }
 export function buildIndexMd(projectName, stackCtx, ciProvider, memory) {
     return `# ${projectName} — Project Index

package/dist/{commands → lib}/crash-recovery.js

@@ -3,9 +3,7 @@
  * when checkpoint files are corrupted or lost. Git is the single
  * source of truth for what was actually done.
  */
-import { execFile } from "child_process";
-import { promisify } from "util";
-const execFileAsync = promisify(execFile);
+import { execFileAsync } from "./exec.js";
 // ── Git operations ──
 export async function getGitLog(projectDir, options = {}) {
     const args = [
@@ -41,7 +39,7 @@ const CONVENTIONAL_RE = /^(feat|fix|test|refactor|docs|chore|ci|perf|style|build
 const TASK_ID_RE = /#(\d+)|task[- ](\d+[.\d]*)/i;
 export function parseCommitPhase(message) {
     const match = CONVENTIONAL_RE.exec(message);
-    return match ? match[1] : null;
+    return match ? (match[1] ?? null) : null;
 }
 export function extractTaskId(message) {
     const match = TASK_ID_RE.exec(message);
@@ -59,6 +57,8 @@ export function parseGitLog(raw) {
         if (lines.length === 0)
             continue;
         const headerLine = lines[0];
+        if (!headerLine)
+            continue;
         const parts = headerLine.split("|");
         if (parts.length < 3)
             continue;

package/dist/lib/docker.d.ts

@@ -2,6 +2,12 @@ import type { Stack } from "../types/index.js";
 export interface DockerRunOptions {
     /** Absolute path to mount as /home/runner/work */
     projectDir: string;
+    /**
+     * Pre-resolved image from the CI runner (required). Passed through
+     * verbatim, including digest pins (`name@sha256:...`). runInContainer
+     * never performs marker detection — resolution happens once, upstream.
+     */
+    image: string;
     /** Command to run inside the container */
     command: string;
     /** Timeout in seconds (default: 600) */
@@ -22,6 +28,14 @@ export interface DockerImageOptions {
     javaVersion?: string;
     /** Directory where Dockerfiles are stored (defaults to package-bundled dir) */
     dockerfilesDir?: string;
+    /**
+     * Custom build context directory (must contain a Dockerfile, which is
+     * the source of truth and is never overwritten). Mutually exclusive
+     * with dockerfilesDir.
+     */
+    buildContext?: string;
+    /** Image tag for build-context builds (default: derived from the stack) */
+    imageTag?: string;
 }
 export declare function getImageName(stack: Stack): string;
 export declare function getDockerfileContent(stack: Stack): string;
@@ -30,6 +44,12 @@ export declare function isDockerAvailable(): Promise<boolean>;
  * Ensure a CI Docker image exists and is up-to-date.
  * Rebuilds only if the Dockerfile content has changed (hash-based staleness check).
  * Returns the image name.
+ *
+ * Two modes:
+ *   - per-stack (default): the Dockerfile is generated/managed by javi-forge
+ *   - build-context: the configured context directory provides its own
+ *     Dockerfile (source of truth, never overwritten); fails closed if
+ *     the Dockerfile is missing.
  */
 export declare function ensureImage(options: DockerImageOptions): Promise<string>;
 /**
@@ -40,6 +60,7 @@ export declare function ensureImage(options: DockerImageOptions): Promise<string
 export declare function runInContainer(options: DockerRunOptions): Promise<DockerRunResult>;
 /**
  * Open an interactive shell inside the CI container.
+ * The image must be pre-resolved by the caller (no marker detection here).
  */
-export declare function openShell(projectDir: string): Promise<void>;
+export declare function openShell(projectDir: string, image: string): Promise<void>;
 //# sourceMappingURL=docker.d.ts.map

package/dist/lib/docker.js

@@ -1,9 +1,8 @@
-import { execFile, spawn } from "child_process";
-import crypto from "crypto";
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
-import { promisify } from "util";
-const execFileAsync = promisify(execFile);
+import { execFileAsync } from "./exec.js";
 // =============================================================================
 // Image name
 // =============================================================================
@@ -96,18 +95,40 @@ export async function isDockerAvailable() {
  * Ensure a CI Docker image exists and is up-to-date.
  * Rebuilds only if the Dockerfile content has changed (hash-based staleness check).
  * Returns the image name.
+ *
+ * Two modes:
+ *   - per-stack (default): the Dockerfile is generated/managed by javi-forge
+ *   - build-context: the configured context directory provides its own
+ *     Dockerfile (source of truth, never overwritten); fails closed if
+ *     the Dockerfile is missing.
  */
 export async function ensureImage(options) {
-    const { stack, javaVersion, dockerfilesDir } = options;
-    const imageName = getImageName(stack);
-    // Resolve Dockerfile path
-    const dockerDir = dockerfilesDir ??
-        path.join(path.dirname(new URL(import.meta.url).pathname), "../../ci-local/docker");
-    const dockerfilePath = path.join(dockerDir, `${stack}.Dockerfile`);
-    // Write Dockerfile if it doesn't exist yet (first run)
-    if (!(await fs.pathExists(dockerfilePath))) {
-        await fs.ensureDir(dockerDir);
-        await fs.writeFile(dockerfilePath, getDockerfileContent(stack), "utf-8");
+    const { stack, javaVersion, dockerfilesDir, buildContext, imageTag } = options;
+    let imageName;
+    let dockerfilePath;
+    let contextDir;
+    if (buildContext) {
+        imageName = imageTag ?? getImageName(stack);
+        dockerfilePath = path.join(buildContext, "Dockerfile");
+        contextDir = buildContext;
+        // Fail closed: a build context without a Dockerfile is a config error,
+        // never something to silently work around.
+        if (!(await fs.pathExists(dockerfilePath))) {
+            throw new Error(`build-context "${buildContext}" has no Dockerfile — ` +
+                "add one or use image/stack defaults instead");
+        }
+    }
+    else {
+        imageName = getImageName(stack);
+        const dockerDir = dockerfilesDir ??
+            path.join(path.dirname(new URL(import.meta.url).pathname), "../../ci-local/docker");
+        dockerfilePath = path.join(dockerDir, `${stack}.Dockerfile`);
+        contextDir = dockerDir;
+        // Write Dockerfile if it doesn't exist yet (first run)
+        if (!(await fs.pathExists(dockerfilePath))) {
+            await fs.ensureDir(dockerDir);
+            await fs.writeFile(dockerfilePath, getDockerfileContent(stack), "utf-8");
+        }
     }
     // Staleness check: compare Dockerfile hash with the one embedded in the image label
     const content = await fs.readFile(dockerfilePath, "utf-8");
@@ -138,10 +159,12 @@ export async function ensureImage(options) {
         "-t",
         imageName,
     ];
-    if (javaVersion && (stack === "java-gradle" || stack === "java-maven")) {
+    if (!buildContext &&
+        javaVersion &&
+        (stack === "java-gradle" || stack === "java-maven")) {
         buildArgs.push("--build-arg", `JAVA_VERSION=${javaVersion}`);
     }
-    buildArgs.push(dockerDir);
+    buildArgs.push(contextDir);
     await new Promise((resolve, reject) => {
         const proc = spawn("docker", buildArgs, { stdio: "inherit" });
         proc.on("close", (code) => code === 0
@@ -160,10 +183,16 @@ export async function ensureImage(options) {
  * Streams output to process.stdout/stderr by default.
  */
 export async function runInContainer(options) {
-    const { projectDir, command, timeout = 600, stream = true, user } = options;
-    const stack = await detectStackFromDir(projectDir);
-    const imageName = getImageName(stack);
+    const { projectDir, image, command, timeout = 600, stream = true, user, } = options;
+    // The image is always pre-resolved by the caller (resolveCIRunners →
+    // ensureImage or an explicit/digest-pinned config image). No marker
+    // detection happens on this path — ever.
+    const imageName = image;
     const isInteractive = process.stdin.isTTY && stream;
+    // Use --mount instead of -v: the -v form parses the value as a single
+    // "src:dst[:opt]" colon-separated string, which breaks (and could be
+    // hijacked) when projectDir itself contains a colon. --mount takes
+    // comma-separated key=value pairs and is colon-safe.
     const dockerArgs = [
         "run",
         "--rm",
@@ -173,8 +202,8 @@ export async function runInContainer(options) {
         "--entrypoint",
         "",
         ...(user ? ["--user", user] : []),
-        "-v",
-        `${projectDir}:/home/runner/work`,
+        "--mount",
+        `type=bind,source=${projectDir},target=/home/runner/work`,
         "-e",
         "CI=true",
         imageName,
@@ -204,10 +233,10 @@ export async function runInContainer(options) {
 }
 /**
  * Open an interactive shell inside the CI container.
+ * The image must be pre-resolved by the caller (no marker detection here).
  */
-export async function openShell(projectDir) {
-    const stack = await detectStackFromDir(projectDir);
-    const imageName = getImageName(stack);
+export async function openShell(projectDir, image) {
+    const imageName = image;
     await new Promise((resolve, reject) => {
         const proc = spawn("docker", [
             "run",
@@ -215,8 +244,9 @@ export async function openShell(projectDir) {
             "-it",
             "--entrypoint",
             "",
-            "-v",
-            `${projectDir}:/home/runner/work`,
+            // --mount is colon-safe; see runInContainer for the rationale.
+            "--mount",
+            `type=bind,source=${projectDir},target=/home/runner/work`,
             "-e",
             "CI=true",
             imageName,
@@ -228,26 +258,4 @@ export async function openShell(projectDir) {
         proc.on("error", reject);
     });
 }
-// =============================================================================
-// Internal helpers
-// =============================================================================
-async function detectStackFromDir(projectDir) {
-    if (await fs.pathExists(path.join(projectDir, "build.gradle.kts")))
-        return "java-gradle";
-    if (await fs.pathExists(path.join(projectDir, "build.gradle")))
-        return "java-gradle";
-    if (await fs.pathExists(path.join(projectDir, "pom.xml")))
-        return "java-maven";
-    if (await fs.pathExists(path.join(projectDir, "package.json")))
-        return "node";
-    if (await fs.pathExists(path.join(projectDir, "go.mod")))
-        return "go";
-    if (await fs.pathExists(path.join(projectDir, "Cargo.toml")))
-        return "rust";
-    if ((await fs.pathExists(path.join(projectDir, "pyproject.toml"))) ||
-        (await fs.pathExists(path.join(projectDir, "requirements.txt"))) ||
-        (await fs.pathExists(path.join(projectDir, "setup.py"))))
-        return "python";
-    return "node"; // fallback
-}
 //# sourceMappingURL=docker.js.map