bootproof 0.1.0 → 0.4.0

package/dist/infer.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
+import { parse } from "yaml";
+import { repoComposeRepairFile } from "./plan.js";
 function readJson(p) {
     try {
         return JSON.parse(fs.readFileSync(p, "utf8"));
@@ -30,6 +32,125 @@ function readText(repo, rel) {
 function present(repo, paths) {
     return paths.filter(rel => exists(repo, rel));
 }
+const REPO_COMPOSE_FILES = [
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yaml",
+    "compose.yml",
+    "docker-compose.dev.yml",
+    "docker-compose.dev.yaml",
+    "docker/docker-compose.yml",
+    "docker/docker-compose.yaml",
+];
+const VITE_CONFIG_FILES = [
+    "vite.config.js",
+    "vite.config.ts",
+    "vite.config.mjs",
+    "vite.config.cjs",
+];
+function detectRepoComposeFile(repo) {
+    return REPO_COMPOSE_FILES.find(file => exists(repo, file)) ?? null;
+}
+function composePublishedPort(value) {
+    if (typeof value === "number")
+        return null;
+    if (typeof value === "object" && value !== null) {
+        const item = value;
+        const host = Number(item.published);
+        const container = Number(item.target);
+        return Number.isInteger(host) && Number.isInteger(container) ? { host, container } : null;
+    }
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.replace(/\$\{[^}:]+:-?(\d+)\}/g, "$1").split("/")[0];
+    const parts = normalized.split(":").map(part => part.trim());
+    if (parts.length < 2)
+        return null;
+    const host = Number(parts.at(-2));
+    const container = Number(parts.at(-1));
+    return Number.isInteger(host) && Number.isInteger(container) ? { host, container } : null;
+}
+function composeHealthPath(service, containerPort) {
+    const test = service.healthcheck?.test;
+    const text = Array.isArray(test) ? test.join(" ") : typeof test === "string" ? test : "";
+    const url = text.match(/https?:\/\/(?:localhost|127\.0\.0\.1):(\d{2,5})(\/[^\s"'\\]*)?/i);
+    if (!url || Number(url[1]) !== containerPort)
+        return "/";
+    return url[2] || "/";
+}
+function sourceBuildUsesRepo(repo, composeFile, build) {
+    const context = typeof build === "string"
+        ? build
+        : typeof build === "object" && build !== null
+            ? String(build.context ?? ".")
+            : null;
+    if (!context || /^(?:https?|git):/i.test(context))
+        return false;
+    const composeDir = path.dirname(path.join(repo, composeFile));
+    const resolved = path.resolve(composeDir, context);
+    const root = path.resolve(repo);
+    return resolved === root || resolved.startsWith(`${root}${path.sep}`);
+}
+function detectComposeApplications(repo, composeFile) {
+    if (!composeFile)
+        return [];
+    try {
+        const document = parse(readText(repo, composeFile));
+        const applications = [];
+        for (const [name, service] of Object.entries(document?.services ?? {})) {
+            const source = sourceBuildUsesRepo(repo, composeFile, service.build) ? "build" : service.image ? "image" : null;
+            if (!source)
+                continue;
+            const healthCandidates = (Array.isArray(service.ports) ? service.ports : [])
+                .map(composePublishedPort)
+                .filter((port) => Boolean(port))
+                .filter(port => ![3306, 5432, 6379, 27017].includes(port.container))
+                .map(port => `http://localhost:${port.host}${composeHealthPath(service, port.container)}`);
+            if (healthCandidates.length)
+                applications.push({ name, source, healthCandidates: [...new Set(healthCandidates)] });
+        }
+        return applications;
+    }
+    catch {
+        return [];
+    }
+}
+function applyBootProofComposeOverride(repo, repoComposeFile, applications) {
+    if (!repoComposeFile)
+        return applications;
+    const repairFile = repoComposeRepairFile(repoComposeFile);
+    const overridePath = path.join(repo, repairFile);
+    if (!fs.existsSync(overridePath))
+        return applications;
+    try {
+        const document = parse(readText(repo, repairFile));
+        return applications.map(application => {
+            const service = document.services?.[application.name];
+            const port = (Array.isArray(service?.ports) ? service.ports : [])
+                .map(composePublishedPort)
+                .find((candidate) => Boolean(candidate));
+            if (!port)
+                return application;
+            return {
+                ...application,
+                healthCandidates: application.healthCandidates.map(candidate => {
+                    try {
+                        const url = new URL(candidate);
+                        url.hostname = "localhost";
+                        url.port = String(port.host);
+                        return url.toString();
+                    }
+                    catch {
+                        return candidate;
+                    }
+                }),
+            };
+        });
+    }
+    catch {
+        return applications;
+    }
+}
 function packageManagerFromField(field) {
     if (!field)
         return null;
@@ -77,6 +198,45 @@ function pickAppCommand(pkg, pm) {
     }
     return { command: null, source: "no dev/start/serve/preview script found", script: null };
 }
+function shellSegmentExecutable(segment) {
+    let remaining = segment.trim();
+    while (/^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+/.test(remaining)) {
+        remaining = remaining.replace(/^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+/, "");
+    }
+    return remaining.match(/^([A-Za-z0-9_.-]+)/)?.[1] ?? null;
+}
+function projectCliFromScript(scriptCommand, packageManager) {
+    const standardCommands = new Set([
+        "npm", "pnpm", "yarn", "bun", "node", "npx", "corepack",
+        "go", "ruby", "bundle", "make", "python", "python3", "php", "composer",
+        "cd", "echo", "env", "export", "sh", "bash", "true", "false", "test",
+    ]);
+    if (packageManager !== "unknown")
+        standardCommands.add(packageManager);
+    for (const segment of scriptCommand.split(/\s*(?:&&|\|\||;)\s*/)) {
+        const executable = shellSegmentExecutable(segment);
+        if (executable && !standardCommands.has(executable))
+            return executable;
+    }
+    return null;
+}
+function executableAvailable(repo, executable) {
+    const localBin = path.join(repo, "node_modules", ".bin", executable);
+    if (exists(repo, path.relative(repo, localBin)))
+        return true;
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const directory of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            if (fs.existsSync(path.join(directory, `${executable}${extension.toLowerCase()}`))
+                || fs.existsSync(path.join(directory, `${executable}${extension.toUpperCase()}`))) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 function detectNestedFrontend(repo) {
     const preferred = ["superset-frontend", "frontend", "web", "ui", "client"];
     for (const dir of preferred) {
@@ -86,40 +246,176 @@ function detectNestedFrontend(repo) {
     }
     return null;
 }
-function detectArchitecture(repo, pkg, nestedFrontend) {
+function detectMakeCommand(repo, makefile) {
+    for (const target of ["run", "serve", "server", "start", "dev"]) {
+        if (new RegExp(`^${target}:`, "m").test(makefile)) {
+            return { command: `make ${target}`, source: `Makefile target: ${target}` };
+        }
+    }
+    return null;
+}
+function detectGoEntrypoint(repo) {
+    const candidates = [];
+    if (exists(repo, "main.go"))
+        candidates.push("main.go");
+    try {
+        for (const name of fs.readdirSync(path.join(repo, "cmd"))) {
+            if (exists(repo, `cmd/${name}/main.go`))
+                candidates.push(`cmd/${name}/main.go`);
+        }
+    }
+    catch { /* no cmd directory */ }
+    if (candidates.length !== 1)
+        return null;
+    const entry = candidates[0];
+    const sourceText = readText(repo, entry);
+    const packagePath = entry === "main.go" ? "." : `./${path.posix.dirname(entry)}`;
+    return {
+        commandBase: `go run ${packagePath}`,
+        source: `Go main package: ${entry}`,
+        sourceText,
+        dataDirFlag: /(?:String|StringVar)\(\s*["']data["']/m.test(sourceText),
+        portFlag: /(?:Int|IntVar)\(\s*["']port["']/m.test(sourceText),
+    };
+}
+function detectGoService(repo) {
+    if (!exists(repo, "go.mod")) {
+        return {
+            ollamaLike: false,
+            command: null,
+            commandSource: null,
+            port: null,
+            healthCandidates: [],
+            markers: [],
+        };
+    }
+    const moduleFile = readText(repo, "go.mod");
+    const mainFile = readText(repo, "main.go");
+    const commandFile = readText(repo, "cmd/cmd.go");
+    const routesFile = readText(repo, "server/routes.go");
+    const envConfigFile = readText(repo, "envconfig/config.go");
+    const evidence = [moduleFile, mainFile, commandFile, routesFile, envConfigFile].join("\n");
+    const exactModule = /^module\s+github\.com\/ollama\/ollama\s*$/m.test(moduleFile);
+    const ollamaModule = /^module\s+\S*ollama(?:\/\S*)?\s*$/mi.test(moduleFile);
+    const markers = [
+        exactModule || ollamaModule ? "ollama module" : null,
+        /\bOLLAMA_HOST\b/.test(evidence) ? "OLLAMA_HOST" : null,
+        /\b11434\b/.test(evidence) ? "port 11434" : null,
+        /["'`]\/api\/tags["'`]/.test(evidence) ? "/api/tags" : null,
+        /\bUse:\s*["']serve["']|\bollama serve\b/i.test(evidence) ? "serve command" : null,
+    ].filter((marker) => marker !== null);
+    const hasRootEntrypoint = exists(repo, "main.go");
+    const hasServeEvidence = markers.includes("serve command");
+    const strongOllamaEvidence = exactModule || markers.length >= 3;
+    const ollamaLike = hasRootEntrypoint && hasServeEvidence && strongOllamaEvidence;
+    return {
+        ollamaLike,
+        command: ollamaLike ? "go run . serve" : null,
+        commandSource: ollamaLike ? "Ollama Go service entrypoint: main.go + serve command" : null,
+        port: ollamaLike ? 11434 : null,
+        healthCandidates: ollamaLike
+            ? [
+                "http://127.0.0.1:11434/",
+                "http://localhost:11434/",
+                "http://127.0.0.1:11434/api/tags",
+                "http://localhost:11434/api/tags",
+            ]
+            : [],
+        markers,
+    };
+}
+function detectRubyCommand(repo) {
+    if (!exists(repo, "Gemfile") || !exists(repo, "bin/rails"))
+        return null;
+    return { commandBase: "bundle exec rails server -b 127.0.0.1", source: "Rails entrypoint: bin/rails" };
+}
+function detectArchitecture(repo, pkg, nestedFrontend, repoComposeFile) {
     const makefile = readText(repo, "Makefile");
     const pyproject = readText(repo, "pyproject.toml");
     const setupPy = readText(repo, "setup.py");
-    const compose = readText(repo, "docker-compose.yml") + readText(repo, "docker-compose.yaml") + readText(repo, "compose.yaml");
+    const requirements = readText(repo, "requirements.txt");
+    const compose = repoComposeFile ? readText(repo, repoComposeFile) : "";
+    const composer = readJson(path.join(repo, "composer.json"));
     const rootDeps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
     const nestedDeps = { ...(nestedFrontend?.pkg?.dependencies ?? {}), ...(nestedFrontend?.pkg?.devDependencies ?? {}) };
-    const backendMarkers = present(repo, ["pyproject.toml", "setup.py", "go.mod", "go.work", "Makefile", "superset/app.py", "superset/config.py"]);
+    const backendMarkers = present(repo, ["pyproject.toml", "setup.py", "requirements.txt", "manage.py", "go.mod", "go.work", "Gemfile", "config/database.yml", "Makefile", "superset/app.py", "superset/config.py", "artisan", "composer.json"]);
     if (isDirectory(repo, "pkg"))
         backendMarkers.push("pkg/");
-    const frontendMarkers = present(repo, ["package.json", "yarn.lock", "pnpm-lock.yaml", "nx.json"]);
+    const frontendMarkers = present(repo, ["package.json", "yarn.lock", "pnpm-lock.yaml", "nx.json", ...VITE_CONFIG_FILES]);
     if (isDirectory(repo, "public"))
         frontendMarkers.push("public/");
     if (isDirectory(repo, "packages"))
         frontendMarkers.push("packages/");
     if (nestedFrontend)
         frontendMarkers.push(`${nestedFrontend.dir}/package.json`);
-    const serviceMarkers = present(repo, ["docker-compose.yml", "docker-compose.yaml", "compose.yaml", "docker-compose-light.yml"]);
-    const hasPythonBackend = (exists(repo, "pyproject.toml") || exists(repo, "setup.py")) &&
+    const serviceMarkers = present(repo, [...REPO_COMPOSE_FILES, "docker-compose-light.yml"]);
+    const hasFlaskBackend = (exists(repo, "pyproject.toml") || exists(repo, "setup.py")) &&
         (exists(repo, "superset/app.py") || exists(repo, "superset/config.py") || /\bflask\b/i.test(pyproject + setupPy + makefile));
-    const hasFlask = hasPythonBackend && (/\bflask\b/i.test(pyproject + setupPy + makefile) || exists(repo, "superset/app.py"));
+    const hasFlask = hasFlaskBackend && (/\bflask\b/i.test(pyproject + setupPy + makefile) || exists(repo, "superset/app.py"));
+    const hasDjango = exists(repo, "manage.py") && /\bdjango\b/i.test(pyproject + requirements);
+    const hasLargePythonNodeHybrid = exists(repo, "pyproject.toml")
+        && exists(repo, "Makefile")
+        && exists(repo, "package.json")
+        && exists(repo, "pnpm-lock.yaml");
+    const hasPythonBackend = hasFlaskBackend || hasDjango || hasLargePythonNodeHybrid;
     const hasGoBackend = exists(repo, "go.mod") || exists(repo, "go.work");
-    const hasNodeFrontend = Boolean(pkg) && (isDirectory(repo, "public") || isDirectory(repo, "packages") || exists(repo, "nx.json") || hasGoBackend);
+    const hasRubyBackend = exists(repo, "Gemfile");
+    const hasLaravel = exists(repo, "artisan") && Boolean(composer);
+    const hasPhpBackend = hasLaravel;
+    const viteConfig = VITE_CONFIG_FILES.find(file => exists(repo, file)) ?? null;
+    const hasLaravelViteFrontend = hasLaravel && Boolean(pkg) && Boolean(viteConfig);
+    const makeCommand = detectMakeCommand(repo, makefile);
+    const goEntrypoint = detectGoEntrypoint(repo);
+    const goService = detectGoService(repo);
+    const rubyCommand = detectRubyCommand(repo);
+    const hasMakeDrivenBackend = Boolean(makefile && /^[A-Za-z0-9_.-]+:\s*(?:[^=]|$)/m.test(makefile));
+    const hasNodeFrontend = Boolean(pkg) && (isDirectory(repo, "public")
+        || isDirectory(repo, "packages")
+        || exists(repo, "nx.json")
+        || hasGoBackend
+        || hasRubyBackend
+        || hasLaravelViteFrontend
+        || hasLargePythonNodeHybrid);
     const hasReact = Boolean(rootDeps.react || nestedDeps.react);
     const hasReactFrontend = Boolean(nestedFrontend && hasReact);
     const hasCelery = /\bcelery\b/i.test(pyproject + setupPy + makefile + compose);
     const hasCompose = serviceMarkers.length > 0;
+    if (hasLargePythonNodeHybrid) {
+        if (isDirectory(repo, "src"))
+            backendMarkers.push("src/");
+        if (isDirectory(repo, "static"))
+            frontendMarkers.push("static/");
+        if (isDirectory(repo, "devservices"))
+            serviceMarkers.push("devservices/");
+    }
+    if (hasGoBackend) {
+        if (exists(repo, "main.go"))
+            backendMarkers.push("main.go");
+        if (isDirectory(repo, "cmd"))
+            backendMarkers.push("cmd/");
+        if (isDirectory(repo, "server"))
+            backendMarkers.push("server/");
+        backendMarkers.push(...goService.markers);
+    }
     const stack = [];
     if (hasPythonBackend)
         stack.push("python-backend");
     if (hasFlask)
         stack.push("flask");
+    if (hasDjango)
+        stack.push("django");
     if (hasGoBackend)
         stack.push("go-backend");
+    if (hasRubyBackend)
+        stack.push("ruby-backend");
+    if (hasPhpBackend)
+        stack.push("php-backend");
+    if (hasLaravel)
+        stack.push("laravel");
+    if (hasLargePythonNodeHybrid
+        || (hasMakeDrivenBackend && !hasPythonBackend && !hasGoBackend && !hasRubyBackend && !hasPhpBackend)) {
+        stack.push("make-driven");
+    }
     if (hasNodeFrontend)
         stack.push("node-frontend");
     if (hasReactFrontend)
@@ -128,7 +424,7 @@ function detectArchitecture(repo, pkg, nestedFrontend) {
         stack.push("react");
     if (rootDeps.next)
         stack.push("nextjs");
-    if (rootDeps.vite)
+    if (rootDeps.vite || viteConfig)
         stack.push("vite");
     if (rootDeps.express)
         stack.push("express");
@@ -142,6 +438,10 @@ function detectArchitecture(repo, pkg, nestedFrontend) {
         stack.push("docker-compose");
     if (hasCelery)
         stack.push("celery");
+    if (hasLargePythonNodeHybrid)
+        stack.push("large-hybrid-app");
+    if (hasLargePythonNodeHybrid && isDirectory(repo, "devservices"))
+        stack.push("devservices-backed");
     const setupSteps = [];
     if (/^\s*superset db upgrade\s*$/m.test(makefile))
         setupSteps.push("superset db upgrade");
@@ -150,7 +450,6 @@ function detectArchitecture(repo, pkg, nestedFrontend) {
     const flaskCommand = makefile.match(/^\s*(flask run[^\n]*)$/m)?.[1].trim() ?? null;
     const frontendMakeCommand = makefile.match(/^\s*(cd\s+[^;\n]+;\s*(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev-server|dev|start)[^\n]*)$/m)?.[1].trim() ?? null;
     const workerCommand = makefile.match(/^\s*(celery\s+--app=[^\n]*\sworker[^\n]*)$/m)?.[1].trim() ?? null;
-    const makeRunCommand = hasGoBackend && /^run:\s/m.test(makefile) ? "make run" : null;
     return {
         backendMarkers: [...new Set(backendMarkers)],
         frontendMarkers: [...new Set(frontendMarkers)],
@@ -160,29 +459,51 @@ function detectArchitecture(repo, pkg, nestedFrontend) {
         flaskCommand,
         frontendMakeCommand,
         workerCommand,
-        makeRunCommand,
+        makeCommand,
+        goEntrypoint,
+        goService,
+        rubyCommand,
         hasPythonBackend,
+        hasLargePythonNodeHybrid,
         hasFlask,
+        hasDjango,
         hasGoBackend,
+        hasRubyBackend,
+        hasPhpBackend,
+        hasLaravel,
+        hasLaravelViteFrontend,
+        sailCommand: hasLaravel && exists(repo, "vendor/bin/sail") ? "./vendor/bin/sail up" : null,
+        hasMakeDrivenBackend,
         hasNodeFrontend,
     };
 }
-function detectPort(pkg, repo, commands) {
-    const sources = [JSON.stringify(pkg?.scripts ?? {}), readText(repo, "Makefile"), ...commands.filter((v) => Boolean(v))].join("\n");
+function detectPort(pkg, repo, commands, options = {}) {
+    const sources = [
+        options.ignorePackageScripts ? "" : JSON.stringify(pkg?.scripts ?? {}),
+        readText(repo, "Makefile"),
+        ...commands.filter((v) => Boolean(v)),
+    ].join("\n");
     const m = sources.match(/(?:-p|--port)(?:=|\s+|[\\"]+)(\d{2,5})/);
     if (m)
         return { port: Number(m[1]), evidence: `port flag in command evidence: ${m[0].replace(/\\"/g, "").trim()}` };
+    const goDefault = sources.match(/(?:SetDefault\(\s*["']port["']\s*,|(?:Int|IntVar)\(\s*["']port["']\s*,)\s*(\d{2,5})/);
+    if (goDefault)
+        return { port: Number(goDefault[1]), evidence: "port default in Go entrypoint" };
+    const listen = sources.match(/ListenAndServe\(\s*["']:(\d{2,5})["']/);
+    if (listen)
+        return { port: Number(listen[1]), evidence: "HTTP listen address in source" };
     const envEx = readText(repo, ".env.example");
-    const pm = envEx.match(/^PORT=(\d{2,5})/m);
+    const pm = envEx.match(/^(?:APP_)?PORT=(\d{2,5})/m);
     if (pm)
-        return { port: Number(pm[1]), evidence: "PORT in .env.example" };
-    return { port: 3000, evidence: "default assumption (3000); not evidence-based" };
+        return { port: Number(pm[1]), evidence: `${pm[0].split("=")[0]} in .env.example` };
+    const defaultPort = options.defaultPort ?? 3000;
+    return { port: defaultPort, evidence: `default assumption (${defaultPort}); not evidence-based` };
 }
-function detectServices(pkg, repo) {
+function detectServices(pkg, repo, repoComposeFile) {
     const out = [];
     const envEx = readText(repo, ".env.example") + readText(repo, ".env.sample");
     const schema = readText(repo, "prisma/schema.prisma");
-    const compose = readText(repo, "docker-compose.yml") + readText(repo, "docker-compose.yaml") + readText(repo, "compose.yaml");
+    const compose = repoComposeFile ? readText(repo, repoComposeFile) : "";
     const pyproject = readText(repo, "pyproject.toml");
     const deps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
     if (/postgres(ql)?:\/\//i.test(envEx) || /provider\s*=\s*"postgresql"/.test(schema) || deps.pg || /^\s{0,4}postgres:\s*$/m.test(compose))
@@ -229,15 +550,16 @@ function workspacePatterns(repo, pkg) {
     return [...new Set(patterns)];
 }
 function expandWorkspacePattern(repo, pattern) {
-    if (!pattern.includes("*"))
-        return exists(repo, `${pattern}/package.json`) ? [pattern] : [];
-    const beforeStar = pattern.slice(0, pattern.indexOf("*"));
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    if (!normalizedPattern.includes("*"))
+        return exists(repo, `${normalizedPattern}/package.json`) ? [normalizedPattern] : [];
+    const beforeStar = normalizedPattern.slice(0, normalizedPattern.indexOf("*"));
     const base = beforeStar.replace(/\/$/, "");
-    const suffix = pattern.slice(pattern.indexOf("*") + 1).replace(/^\//, "");
+    const suffix = normalizedPattern.slice(normalizedPattern.indexOf("*") + 1).replace(/^\//, "");
     const baseAbs = path.join(repo, base);
     try {
         return fs.readdirSync(baseAbs)
-            .map(name => path.join(base, name, suffix))
+            .map(name => path.posix.join(base, name, suffix))
             .filter(dir => exists(repo, `${dir}/package.json`));
     }
     catch {
@@ -245,6 +567,7 @@ function expandWorkspacePattern(repo, pattern) {
     }
 }
 const TEST_PATH = /(^|[-_/])(e2e|tests?|test-plugins|fixtures?|examples?|samples?|demos?|mocks?)([-_/]|$)/i;
+const DOCUMENTATION_PATH = /(^|[\/])(storybook|docs?)([\/]|$)/i;
 const SCAFFOLD_NAME = /^create-|-(template|example|fixture|sandbox|sample|demo|mock)$/i;
 function scoreWorkspace(repo, dir, wpkg, isRoot) {
     const { command } = pickAppCommand(wpkg, "npm");
@@ -293,6 +616,10 @@ function scoreWorkspace(repo, dir, wpkg, isRoot) {
         score -= 10;
         reasons.push("test/example path downranked");
     }
+    if (DOCUMENTATION_PATH.test(`${dir}/${wpkg?.name ?? ""}`)) {
+        score -= 3;
+        reasons.push("documentation/storybook downranked");
+    }
     if (wpkg?.private !== true && (wpkg?.main || wpkg?.exports) && !command) {
         score -= 2;
         reasons.push("looks like a publishable library");
@@ -343,41 +670,147 @@ export function inferRepo(repoPath, opts = {}) {
     const rootRepo = path.resolve(repoPath);
     const rootPkg = opts.workspace ? readJson(path.join(rootRepo, "package.json")) : pkg;
     const nestedFrontend = detectNestedFrontend(repo);
-    const architecture = detectArchitecture(repo, pkg, nestedFrontend);
+    const repoComposeFile = detectRepoComposeFile(repo);
+    const composeApplicationServices = applyBootProofComposeOverride(repo, repoComposeFile, detectComposeApplications(repo, repoComposeFile));
+    const sourceComposeApplications = composeApplicationServices.filter(service => service.source === "build");
+    const composeHealthCandidates = sourceComposeApplications.length === 1
+        ? sourceComposeApplications[0].healthCandidates
+        : [];
+    const architecture = detectArchitecture(repo, pkg, nestedFrontend, repoComposeFile);
     const pm = detectPackageManager(repo, pkg, nestedFrontend?.dir ?? null);
     const rootApp = pickAppCommand(pkg, pm.pm);
-    const backendCommand = architecture.flaskCommand ?? architecture.makeRunCommand;
+    const rootScriptText = rootApp.script ? String(pkg?.scripts?.[rootApp.script] ?? "") : "";
+    const projectCliCommand = architecture.hasLargePythonNodeHybrid && rootScriptText
+        ? projectCliFromScript(rootScriptText, pm.pm)
+        : null;
+    const projectCliReady = projectCliCommand === null
+        ? null
+        : executableAvailable(repo, projectCliCommand);
+    const assetDevServerCommand = architecture.hasLaravelViteFrontend && /\bvite\b/i.test(rootScriptText)
+        ? rootApp.command
+        : null;
+    const commandEvidence = [
+        architecture.flaskCommand,
+        architecture.makeCommand?.command ?? null,
+        architecture.goEntrypoint?.sourceText ?? null,
+        architecture.goService.command,
+        architecture.rubyCommand?.commandBase ?? null,
+        architecture.sailCommand,
+    ];
+    const { port, evidence: portEvidence } = detectPort(pkg, repo, commandEvidence, {
+        ignorePackageScripts: architecture.hasLaravel,
+        defaultPort: architecture.goService.port
+            ?? (architecture.sailCommand ? 80 : architecture.hasLaravel ? 8000 : 3000),
+    });
+    const goCommand = architecture.goService.command ?? (architecture.goEntrypoint
+        ? [
+            architecture.goEntrypoint.commandBase,
+            architecture.goEntrypoint.portFlag ? `--port ${port}` : "",
+            architecture.goEntrypoint.dataDirFlag ? "--data .bootproof/runtime/go-app" : "",
+        ].filter(Boolean).join(" ")
+        : null);
+    const rubyCommand = architecture.rubyCommand ? `${architecture.rubyCommand.commandBase} -p ${port}` : null;
+    const djangoCommand = architecture.hasDjango ? `python manage.py runserver 127.0.0.1:${port}` : null;
+    const laravelCommand = architecture.hasLaravel
+        ? architecture.sailCommand ?? `php artisan serve --host=127.0.0.1 --port=${port}`
+        : null;
+    const repositoryBackendCommand = architecture.makeCommand?.command ?? goCommand ?? rubyCommand;
+    const backendCommand = architecture.flaskCommand ?? djangoCommand ?? laravelCommand ?? repositoryBackendCommand;
     const nestedFrontendCommand = architecture.frontendMakeCommand;
     const frontendCommand = nestedFrontendCommand ?? rootApp.command;
-    const appCommand = architecture.flaskCommand ?? rootApp.command;
+    const appCommand = architecture.flaskCommand
+        ?? djangoCommand
+        ?? laravelCommand
+        ?? (architecture.hasGoBackend && architecture.hasNodeFrontend && rootApp.command ? rootApp.command : null)
+        ?? repositoryBackendCommand
+        ?? rootApp.command;
+    const selectedProjectCliCommand = rootApp.command === appCommand ? projectCliCommand : null;
+    const selectedProjectCliReady = selectedProjectCliCommand === null ? null : projectCliReady;
     const appCommandSource = architecture.flaskCommand
         ? `Makefile Flask command: ${architecture.flaskCommand}`
-        : rootApp.source;
-    const recognizedApplication = architecture.hasPythonBackend || architecture.hasGoBackend;
+        : djangoCommand && appCommand === djangoCommand
+            ? "Django entrypoint: manage.py"
+            : laravelCommand && appCommand === laravelCommand
+                ? architecture.sailCommand
+                    ? "Laravel Sail entrypoint: vendor/bin/sail"
+                    : "Laravel entrypoint: artisan"
+                : architecture.makeCommand && appCommand === architecture.makeCommand.command
+                    ? architecture.makeCommand.source
+                    : goCommand && appCommand === goCommand
+                        ? architecture.goService.commandSource ?? architecture.goEntrypoint?.source ?? rootApp.source
+                        : rubyCommand && appCommand === rubyCommand
+                            ? architecture.rubyCommand?.source ?? rootApp.source
+                            : selectedProjectCliCommand && selectedProjectCliReady === false
+                                ? `${rootApp.source}; project CLI ${selectedProjectCliCommand} readiness not established`
+                                : rootApp.source;
+    const recognizedApplication = architecture.hasPythonBackend ||
+        architecture.hasGoBackend ||
+        architecture.hasRubyBackend ||
+        architecture.hasPhpBackend ||
+        architecture.hasMakeDrivenBackend ||
+        composeApplicationServices.some(service => service.source === "build");
     const workspaces = opts.workspace ? [] : rankWorkspaces(rootRepo, rootPkg);
     const notApp = looksLikeLibrary(pkg, appCommand, workspaces.some(candidate => candidate.dir !== "."), recognizedApplication);
-    const { port, evidence: portEvidence } = detectPort(pkg, repo, [backendCommand, frontendCommand]);
     const env = detectEnv(repo);
-    const services = detectServices(pkg, repo);
+    const services = detectServices(pkg, repo, repoComposeFile);
     const rootDeps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
-    const dependencyInstallRequired = Boolean(rootApp.command &&
+    const preparationCommands = [];
+    const nodePreparationRequired = Boolean(rootApp.command &&
+        !architecture.hasLaravel &&
         (Object.keys(rootDeps).length > 0 || exists(repo, "yarn.lock") || exists(repo, "pnpm-lock.yaml") || exists(repo, "package-lock.json") || exists(repo, "nx.json")));
+    if (nodePreparationRequired) {
+        const command = installCommand(pm.pm, pm.packageDir);
+        if (command)
+            preparationCommands.push({ id: "install", kind: "install", command, description: "install Node dependencies", source: pm.evidence });
+    }
+    if (goCommand && appCommand === goCommand && exists(repo, "go.sum")) {
+        preparationCommands.push({ id: "go-modules", kind: "install", command: "go mod download", description: "download declared Go modules", source: "go.sum present" });
+    }
+    if (rubyCommand && appCommand === rubyCommand) {
+        preparationCommands.push({ id: "bundle-install", kind: "install", command: "bundle install", description: "install declared Ruby gems", source: "Gemfile and bin/rails present" });
+    }
+    if (laravelCommand && appCommand === laravelCommand) {
+        preparationCommands.push({ id: "composer-install", kind: "install", command: "composer install", description: "install declared PHP dependencies", source: "composer.json and artisan present" });
+    }
+    const dependencyInstallRequired = preparationCommands.length > 0;
     const incompleteAppCommand = Boolean(architecture.hasGoBackend && architecture.hasNodeFrontend && rootApp.command);
     const multiAppCommand = Boolean(rootApp.command && /\b(?:turbo|nx)\s+run\s+dev\b[^\n]*--parallel\b/i.test(rootApp.source));
     const commandScope = multiAppCommand
         ? "multi-workspace development pipeline; no single application health target selected"
         : incompleteAppCommand
             ? "frontend/dev pipeline only; Go backend markers also detected"
-            : architecture.hasPythonBackend && nestedFrontend
-                ? "Python/Flask backend command; React frontend and worker require separate orchestration"
-                : appCommand
-                    ? "application command"
-                    : "no runnable command selected";
+            : architecture.hasLargePythonNodeHybrid && rootApp.command === appCommand
+                ? selectedProjectCliCommand && selectedProjectCliReady === false
+                    ? `large Python/Node hybrid package script; project CLI ${selectedProjectCliCommand} readiness not established`
+                    : "large Python/Node hybrid package script"
+                : architecture.hasFlask && nestedFrontend
+                    ? "Python/Flask backend command; React frontend and worker require separate orchestration"
+                    : djangoCommand && appCommand === djangoCommand
+                        ? "Django application command"
+                        : laravelCommand && appCommand === laravelCommand
+                            ? architecture.sailCommand
+                                ? "Laravel application through Sail"
+                                : "Laravel application command; Vite is an asset development server only"
+                            : goCommand && appCommand === goCommand && nestedFrontend
+                                ? "Go application command serving repository-embedded frontend assets"
+                                : rubyCommand && appCommand === rubyCommand
+                                    ? "Rails application command"
+                                    : architecture.makeCommand && appCommand === architecture.makeCommand.command
+                                        ? "repository-defined Make target"
+                                        : appCommand
+                                            ? "application command"
+                                            : "no runnable command selected";
     const healthCandidates = notApp
         ? []
-        : architecture.hasGoBackend && architecture.hasNodeFrontend
-            ? [`http://localhost:${port}/api/health`, `http://localhost:${port}/`]
-            : [`http://localhost:${port}/`];
+        : !appCommand && composeHealthCandidates.length
+            ? composeHealthCandidates
+            : !appCommand
+                ? []
+                : architecture.goService.ollamaLike
+                    ? architecture.goService.healthCandidates
+                    : architecture.hasGoBackend && architecture.hasNodeFrontend
+                        ? [`http://localhost:${port}/api/health`, `http://localhost:${port}/`]
+                        : [`http://localhost:${port}/`];
     let confidence = 0;
     if (appCommand)
         confidence += 35;
@@ -391,6 +824,8 @@ export function inferRepo(repoPath, opts = {}) {
         confidence += 10;
     if (services.length || env.required.length)
         confidence += 5;
+    if (selectedProjectCliCommand && selectedProjectCliReady === false)
+        confidence = Math.min(confidence, 60);
     return {
         repoPath: repo,
         isApplication: !notApp,
@@ -399,22 +834,35 @@ export function inferRepo(repoPath, opts = {}) {
         backendMarkers: architecture.backendMarkers,
         frontendMarkers: architecture.frontendMarkers,
         serviceMarkers: architecture.serviceMarkers,
+        repoComposeFile,
+        composeApplicationServices,
+        composeHealthCandidates,
         setupSteps: architecture.setupSteps,
         packageManager: pm.pm,
         packageManagerEvidence: pm.evidence,
         packageManagerVersion: pm.version ?? pkg?.engines?.[pm.pm] ?? rootPkg?.engines?.[pm.pm] ?? null,
-        installCommand: installCommand(pm.pm, pm.packageDir),
+        installCommand: preparationCommands.find(command => command.kind === "install")?.command ?? null,
+        preparationCommands,
         dependencyInstallRequired,
         appCommand,
         appCommandSource,
+        selectedPackageScriptName: rootApp.command === appCommand ? rootApp.script : null,
+        selectedPackageScriptCommand: rootApp.command === appCommand ? rootScriptText || null : null,
+        projectCliCommand: selectedProjectCliCommand,
+        projectCliReady: selectedProjectCliReady,
         backendCommand,
         frontendCommand,
+        asset_dev_server_command: assetDevServerCommand,
         workerCommand: architecture.workerCommand,
         commandScope,
         incompleteAppCommand,
         multiAppCommand,
         port,
-        portEvidence,
+        portEvidence: architecture.goService.port
+            ? "known Ollama service port from repository evidence"
+            : portEvidence,
+        observedPort: null,
+        healthCandidateSource: architecture.goService.ollamaLike ? "known_service" : "inferred",
         healthCandidates,
         services,
         requiredEnv: env.required,