javi-forge 1.7.0 → 1.8.0

package/dist/commands/ci.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import fs from "fs-extra";
 import { CI_STACKS, findCIConfig, loadCIConfig, } from "../lib/ci-config.js";
 import { refreshContextDir } from "../lib/context.js";
-import { ensureImage, getImageName, isDockerAvailable, openShell, runInContainer, } from "../lib/docker.js";
+import { ensureImage, isDockerAvailable, openShell, runInContainer, } from "../lib/docker.js";
 import { execFileAsync } from "../lib/exec.js";
 // =============================================================================
 // Stack detection
@@ -349,6 +349,10 @@ export async function runCI(options, onStep) {
         return;
     }
     // ── Check Docker ─────────────────────────────────────────────────────────────
+    // Image resolved by the prologue for the auto path — threaded into the
+    // executor so nothing downstream re-derives it. Set iff
+    // `resolved.source === "auto" && !noDocker`.
+    let autoImage;
     if (!noDocker) {
         const stepDocker = "docker-check";
         report(onStep, stepDocker, "Checking Docker", "running");
@@ -364,7 +368,7 @@ export async function runCI(options, onStep) {
             const stepImage = "docker-image";
             report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, "running");
             try {
-                await ensureImage({
+                autoImage = await ensureImage({
                     stack: stackInfo.stackType,
                     javaVersion: stackInfo.javaVersion,
                 });
@@ -393,30 +397,22 @@ export async function runCI(options, onStep) {
         report(onStep, stepContext, "Refresh .context/ directory", "error", String(e));
     }
     // ── Runner execution ─────────────────────────────────────────────────────────
-    if (resolved.source === "auto" && primary) {
-        // Legacy zero-config path — unchanged single-stack behavior.
-        await runLegacySteps(stackInfo, primary, {
+    // ONE executor for every resolution source. Naming is a function of
+    // `resolved.source` alone — never of `resolved.runners.length`, which would
+    // silently rename a single-runner CONFIG.
+    const naming = resolved.source === "auto" ? NAMING_MODE.BARE : NAMING_MODE.SUFFIXED;
+    for (const runner of resolved.runners) {
+        await runRunner(runner, {
             projectDir,
             mode,
             noDocker,
+            noSecurity,
             timeout,
             onStep,
+            naming,
+            preresolvedImage: resolved.source === "auto" ? autoImage : undefined,
         });
     }
-    else {
-        // Configured (or --stack override) runners execute in declared order,
-        // each in its own working directory.
-        for (const runner of resolved.runners) {
-            await runConfiguredRunner(runner, {
-                projectDir,
-                mode,
-                noDocker,
-                noSecurity,
-                timeout,
-                onStep,
-            });
-        }
-    }
     // ── Security scan (full mode only) ──────────────────────────────────────────
     if (mode === "full" && !noSecurity) {
         const stepSecurity = "security";
@@ -456,90 +452,70 @@ export async function runCI(options, onStep) {
         }
     }
 }
-/** Legacy zero-config execution — identical to the pre-mixed-stack behavior. */
-async function runLegacySteps(stackInfo, runner, ctx) {
-    const { projectDir, mode, noDocker, timeout, onStep } = ctx;
-    if (stackInfo.lintCmd) {
-        const stepLint = "lint";
-        report(onStep, stepLint, `Lint: ${stackInfo.lintCmd}`, "running");
-        try {
-            await runStep(stackInfo.lintCmd, projectDir, noDocker, timeout, runner);
-            report(onStep, stepLint, "Lint passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepLint, "Lint failed", "error", String(e));
-            throw e;
-        }
-    }
-    if (stackInfo.compileCmd) {
-        const stepCompile = "compile";
-        report(onStep, stepCompile, `Compile: ${stackInfo.compileCmd}`, "running");
-        try {
-            // Run as root inside the container to rm/build output dirs owned by any host user,
-            // then chown back to runner so subsequent test steps can read the output.
-            await runStep(stackInfo.compileCmd, projectDir, noDocker, timeout, runner, "root");
-            report(onStep, stepCompile, "Compile passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepCompile, "Compile failed", "error", String(e));
-            throw e;
-        }
-    }
-    if (mode === "full" && stackInfo.testCmd) {
-        const stepTest = "test";
-        report(onStep, stepTest, `Test: ${stackInfo.testCmd}`, "running");
-        try {
-            await runStep(stackInfo.testCmd, projectDir, noDocker, timeout, runner);
-            report(onStep, stepTest, "Tests passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepTest, "Tests failed", "error", String(e));
-            throw e;
-        }
-    }
-}
+// =============================================================================
+// Step runners
+// =============================================================================
+/**
+ * Step-id and label naming, keyed on `resolved.source` and nothing else.
+ * `bare` is the zero-config (auto) presentation; `suffixed` carries the runner
+ * name, including for a CONFIG that happens to declare exactly one runner.
+ */
+const NAMING_MODE = {
+    BARE: "bare",
+    SUFFIXED: "suffixed",
+};
 /**
- * Execute one configured runner: resolve the image (default stack image,
- * explicit/digest-pinned image, or deterministic build-context build),
- * verify required tools fail-closed, then run setup/lint/compile/test/
- * security commands in order, inside the runner's working directory.
+ * Execute one resolved runner, whatever its source: resolve the image (already
+ * built by the prologue for auto, otherwise the default stack image, an
+ * explicit/digest-pinned image, or a deterministic build-context build), verify
+ * required tools fail-closed, then run setup/lint/compile/test/security
+ * commands in order, inside the runner's working directory.
  * Any failure aborts the whole run — nothing is ever skipped silently.
  */
-async function runConfiguredRunner(runner, ctx) {
-    const { projectDir, mode, noDocker, noSecurity, timeout, onStep } = ctx;
+async function runRunner(runner, ctx) {
+    const { projectDir, mode, noDocker, noSecurity, timeout, onStep, naming } = ctx;
+    const bare = naming === NAMING_MODE.BARE;
     // ── Image resolution (Docker mode only) ────────────────────────────────────
     let imageName;
     if (!noDocker) {
-        const stepImage = `docker-image:${runner.name}`;
-        try {
-            if (runner.buildContext) {
-                report(onStep, stepImage, `Building image for ${runner.name} from ${runner.buildContext}`, "running");
-                imageName = await ensureImage({
-                    stack: runner.stack,
-                    buildContext: path.resolve(projectDir, runner.buildContext),
-                    imageTag: `javi-forge-ci-${runner.name}`,
-                });
-            }
-            else if (runner.image) {
-                // Explicit image (digest pins pass through verbatim).
-                imageName = runner.image;
-                report(onStep, stepImage, `Using configured image ${runner.image}`, "done");
-            }
-            else {
-                report(onStep, stepImage, `Building image for ${runner.name} (${runner.stack})`, "running");
-                imageName = await ensureImage({
-                    stack: runner.stack,
-                    javaVersion: runner.javaVersion,
-                });
+        if (ctx.preresolvedImage) {
+            // Auto path: the prologue already built the image BEFORE the .context/
+            // refresh. Reuse it verbatim so no second `docker-image` step appears
+            // and the global step order is unchanged.
+            imageName = ctx.preresolvedImage;
+        }
+        else {
+            const stepImage = `docker-image:${runner.name}`;
+            try {
+                if (runner.buildContext) {
+                    report(onStep, stepImage, `Building image for ${runner.name} from ${runner.buildContext}`, "running");
+                    imageName = await ensureImage({
+                        stack: runner.stack,
+                        buildContext: path.resolve(projectDir, runner.buildContext),
+                        imageTag: `javi-forge-ci-${runner.name}`,
+                    });
+                }
+                else if (runner.image) {
+                    // Explicit image (digest pins pass through verbatim).
+                    imageName = runner.image;
+                    report(onStep, stepImage, `Using configured image ${runner.image}`, "done");
+                }
+                else {
+                    report(onStep, stepImage, `Building image for ${runner.name} (${runner.stack})`, "running");
+                    imageName = await ensureImage({
+                        stack: runner.stack,
+                        javaVersion: runner.javaVersion,
+                    });
+                }
+                if (!runner.image) {
+                    report(onStep, stepImage, `Docker image ready (${imageName})`, "done");
+                }
             }
-            if (!runner.image) {
-                report(onStep, stepImage, `Docker image ready (${imageName})`, "done");
+            catch (e) {
+                report(onStep, stepImage, "Building Docker image", "error", String(e));
+                throw e;
             }
         }
-        catch (e) {
-            report(onStep, stepImage, "Building Docker image", "error", String(e));
-            throw e;
-        }
     }
     // ── Required tools (fail closed, before any phase) ─────────────────────────
     if (runner.requiredTools.length > 0) {
@@ -550,7 +526,14 @@ async function runConfiguredRunner(runner, ctx) {
         report(onStep, stepTools, `Checking required tools [${runner.name}]: ${runner.requiredTools.join(", ")}`, "running");
         for (const tool of runner.requiredTools) {
             try {
-                await runStep(`command -v ${tool}`, projectDir, noDocker, timeout, runner, undefined, imageName);
+                await runStep({
+                    command: `command -v ${tool}`,
+                    projectDir,
+                    noDocker,
+                    timeout,
+                    runner,
+                    image: imageName,
+                });
             }
             catch {
                 const message = `runner "${runner.name}": required tool "${tool}" not found in ${envDesc} — ` +
@@ -574,6 +557,7 @@ async function runConfiguredRunner(runner, ctx) {
         {
             id: "test",
             label: "Test",
+            doneLabel: "Tests",
             cmds: runner.testCmds,
             skip: mode !== "full",
         },
@@ -587,21 +571,34 @@ async function runConfiguredRunner(runner, ctx) {
     for (const phase of phases) {
         if (phase.skip)
             continue;
-        const stepId = `${phase.id}:${runner.name}`;
+        const stepId = bare ? phase.id : `${phase.id}:${runner.name}`;
+        // `doneLabel` is BARE-only: suffixed mode keeps the historical
+        // `${label} [${name}] passed` composition.
+        const subject = bare ? (phase.doneLabel ?? phase.label) : phase.label;
+        const suffix = bare ? "" : ` [${runner.name}]`;
         for (const cmd of phase.cmds) {
-            report(onStep, stepId, `${phase.label} [${runner.name}]: ${cmd}`, "running");
+            report(onStep, stepId, `${phase.label}${suffix}: ${cmd}`, "running");
             try {
-                await runStep(cmd, projectDir, noDocker, timeout, runner, phase.user, imageName);
-                report(onStep, stepId, `${phase.label} [${runner.name}] passed`, "done");
+                await runStep({
+                    command: cmd,
+                    projectDir,
+                    noDocker,
+                    timeout,
+                    runner,
+                    user: phase.user,
+                    image: imageName,
+                });
+                report(onStep, stepId, `${subject}${suffix} passed`, "done");
             }
             catch (e) {
-                report(onStep, stepId, `${phase.label} [${runner.name}] failed`, "error", String(e));
+                report(onStep, stepId, `${subject}${suffix} failed`, "error", String(e));
                 throw e;
             }
         }
     }
 }
-async function runStep(command, projectDir, noDocker, timeout, runner, user, imageOverride) {
+async function runStep(options) {
+    const { command, projectDir, noDocker, timeout, runner, user, image } = options;
     if (noDocker) {
         // Run natively, in the runner's working directory.
         const cwd = path.join(projectDir, runner.directory);
@@ -618,10 +615,15 @@ async function runStep(command, projectDir, noDocker, timeout, runner, user, ima
         });
     }
     else {
-        // The image is always resolved upstream (per-runner ensureImage,
-        // explicit config image, or the default per-stack image). Docker
-        // receives it verbatim and never re-detects anything.
-        const image = imageOverride ?? runner.image ?? getImageName(runner.stack);
+        // The image is always resolved upstream (prologue build for auto,
+        // per-runner ensureImage, explicit config image, or the default
+        // per-stack image). Docker receives it verbatim and never re-detects
+        // anything, so a missing image is a bug — fail loudly instead of
+        // silently re-deriving a name that may not be the one that was built.
+        if (!image) {
+            throw new Error(`internal invariant violated: no Docker image resolved for runner "${runner.name}" — ` +
+                "the image must be resolved before any step runs");
+        }
         const workdir = runner.directory !== "."
             ? `/home/runner/work/${runner.directory}`
             : "/home/runner/work";

package/dist/constants.d.ts

@@ -9,6 +9,8 @@ export declare const MODULES_DIR: string;
 export declare const WORKFLOWS_DIR: string;
 /** CI-local directory */
 export declare const CI_LOCAL_DIR: string;
+/** Git hook assets directory (installed by `javi-forge ci init`) */
+export declare const HOOK_ASSETS_DIR: string;
 /** Security hooks template directory */
 export declare const SECURITY_HOOKS_DIR: string;
 /** Local AI stack template directory */

package/dist/constants.js

@@ -11,6 +11,8 @@ export const MODULES_DIR = path.join(FORGE_ROOT, "modules");
 export const WORKFLOWS_DIR = path.join(FORGE_ROOT, "workflows");
 /** CI-local directory */
 export const CI_LOCAL_DIR = path.join(FORGE_ROOT, "ci-local");
+/** Git hook assets directory (installed by `javi-forge ci init`) */
+export const HOOK_ASSETS_DIR = path.join(FORGE_ROOT, "assets", "hooks");
 /** Security hooks template directory */
 export const SECURITY_HOOKS_DIR = path.join(TEMPLATES_DIR, "security-hooks");
 /** Local AI stack template directory */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javi-forge",
-	"version": "1.7.0",
+  "version": "1.8.0",
   "description": "Project scaffolding and AI-ready CI bootstrap",
   "type": "module",
   "bin": {

package/ci-local/docker/python.Dockerfile

@@ -1,7 +0,0 @@
-FROM python:3.12-slim
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
-RUN pip install --no-cache-dir pytest ruff pylint poetry
-RUN useradd -m -s /bin/bash runner
-USER runner
-WORKDIR /home/runner/work
-ENTRYPOINT ["/bin/bash", "-c"]