javi-forge 1.6.1 → 1.7.1

package/dist/commands/ci.js

@@ -1,10 +1,10 @@
-import { execFile, spawn } from "child_process";
+import { spawn } from "node:child_process";
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
-import { promisify } from "util";
+import { CI_STACKS, findCIConfig, loadCIConfig, } from "../lib/ci-config.js";
 import { refreshContextDir } from "../lib/context.js";
 import { ensureImage, isDockerAvailable, openShell, runInContainer, } from "../lib/docker.js";
-const execFileAsync = promisify(execFile);
+import { execFileAsync } from "../lib/exec.js";
 // =============================================================================
 // Stack detection
 // =============================================================================
@@ -133,6 +133,136 @@ async function buildCICommands(stack, buildTool, projectDir) {
             return { lintCmd: null, compileCmd: null, testCmd: null };
     }
 }
+function freezeRunner(runner) {
+    return Object.freeze({
+        ...runner,
+        setupCmds: Object.freeze([...runner.setupCmds]),
+        lintCmds: Object.freeze([...runner.lintCmds]),
+        compileCmds: Object.freeze([...runner.compileCmds]),
+        testCmds: Object.freeze([...runner.testCmds]),
+        securityCmds: Object.freeze([...runner.securityCmds]),
+        requiredTools: Object.freeze([...runner.requiredTools]),
+    });
+}
+function freezeRunners(source, runners) {
+    return Object.freeze({ source, runners: Object.freeze(runners) });
+}
+/** Build-tool heuristic for a known stack in a given directory. */
+async function detectBuildTool(stack, dir) {
+    switch (stack) {
+        case "node":
+            if (await fs.pathExists(path.join(dir, "pnpm-lock.yaml")))
+                return "pnpm";
+            if (await fs.pathExists(path.join(dir, "yarn.lock")))
+                return "yarn";
+            return "npm";
+        case "python":
+            if (await fs.pathExists(path.join(dir, "uv.lock")))
+                return "uv";
+            if (await fs.pathExists(path.join(dir, "poetry.lock")))
+                return "poetry";
+            return "pip";
+        case "java-gradle":
+            return "gradle";
+        case "java-maven":
+            return "mvn";
+        case "go":
+            return "go";
+        case "rust":
+            return "cargo";
+        default:
+            return "";
+    }
+}
+function toList(command) {
+    return command ? [command] : [];
+}
+async function resolveConfiguredRunner(projectDir, config) {
+    const runnerDir = path.join(projectDir, config.directory);
+    const buildTool = await detectBuildTool(config.stack, runnerDir);
+    const defaults = await buildCICommands(config.stack, buildTool, runnerDir);
+    return freezeRunner({
+        name: config.name,
+        stack: config.stack,
+        buildTool,
+        javaVersion: "21",
+        directory: config.directory,
+        image: config.image,
+        buildContext: config.buildContext,
+        setupCmds: config.setup,
+        lintCmds: config.lint.length > 0 ? config.lint : toList(defaults.lintCmd),
+        compileCmds: config.build.length > 0 ? config.build : toList(defaults.compileCmd),
+        testCmds: config.test.length > 0 ? config.test : toList(defaults.testCmd),
+        securityCmds: config.security,
+        requiredTools: config.requires,
+    });
+}
+async function resolveExplicitStackRunner(projectDir, stack) {
+    const buildTool = await detectBuildTool(stack, projectDir);
+    const defaults = await buildCICommands(stack, buildTool, projectDir);
+    return freezeRunner({
+        name: stack,
+        stack,
+        buildTool,
+        javaVersion: "21",
+        directory: ".",
+        setupCmds: [],
+        lintCmds: toList(defaults.lintCmd),
+        compileCmds: toList(defaults.compileCmd),
+        testCmds: toList(defaults.testCmd),
+        securityCmds: [],
+        requiredTools: [],
+    });
+}
+/**
+ * Resolve the ordered runner list exactly once per CI run.
+ *
+ * Precedence (fail closed on ambiguity):
+ *   1. --config <path> (or discovered .javi-forge/ci.yaml) → configured runners
+ *   2. --stack <stack> → single explicit runner (single-stack repos only)
+ *   3. otherwise → single auto-detected runner (zero-config default)
+ */
+export async function resolveCIRunners(projectDir, options = {}) {
+    const { config, stack } = options;
+    if (config && stack) {
+        throw new Error("Ambiguous CI options: --config and --stack cannot be used together. " +
+            "Use --config for hybrid repositories.");
+    }
+    if (stack) {
+        if (!CI_STACKS.includes(stack)) {
+            throw new Error(`Unknown stack "${stack}". Valid stacks: ${CI_STACKS.join(", ")}`);
+        }
+        return freezeRunners("stack-override", [
+            await resolveExplicitStackRunner(projectDir, stack),
+        ]);
+    }
+    const configPath = config ?? (await findCIConfig(projectDir));
+    if (configPath) {
+        const ciConfig = await loadCIConfig(configPath);
+        const runners = [];
+        for (const runnerConfig of ciConfig.runners) {
+            runners.push(await resolveConfiguredRunner(projectDir, runnerConfig));
+        }
+        return freezeRunners("config", runners);
+    }
+    // Zero-config default: single auto-detected runner (unchanged behavior).
+    const info = await detectCIStack(projectDir);
+    return freezeRunners("auto", [
+        freezeRunner({
+            name: info.stackType,
+            stack: info.stackType,
+            buildTool: info.buildTool,
+            javaVersion: info.javaVersion,
+            directory: ".",
+            setupCmds: [],
+            lintCmds: toList(info.lintCmd),
+            compileCmds: toList(info.compileCmd),
+            testCmds: toList(info.testCmd),
+            securityCmds: [],
+            requiredTools: [],
+        }),
+    ]);
+}
 // =============================================================================
 // GHAGGA check
 // =============================================================================
@@ -151,20 +281,48 @@ async function isGhaggaAvailable() {
 function report(onStep, id, label, status, detail) {
     onStep({ id, label, status, detail });
 }
+/** Detect-step label: legacy format for auto, explicit otherwise. */
+function describeRunners(resolved) {
+    const first = resolved.runners[0];
+    if (resolved.source === "auto" && first) {
+        return `Stack: ${first.stack} (${first.buildTool})`;
+    }
+    if (resolved.source === "stack-override" && first) {
+        return `Stack: ${first.stack} (${first.buildTool}, --stack override)`;
+    }
+    const summary = resolved.runners
+        .map((r) => `${r.name} (${r.stack})`)
+        .join(", ");
+    return `Config: ${resolved.runners.length} runner(s) — ${summary}`;
+}
 export async function runCI(options, onStep) {
     const { projectDir = process.cwd(), mode = "full", noDocker = false, noGhagga = false, noSecurity = false, timeout = 600, } = options;
-    // ── Detect stack ────────────────────────────────────────────────────────────
+    // ── Resolve runners (once — nothing downstream re-detects) ─────────────────
     const stepDetect = "detect";
     report(onStep, stepDetect, "Detecting stack", "running");
-    let stackInfo;
+    let resolved;
     try {
-        stackInfo = await detectCIStack(projectDir);
-        report(onStep, stepDetect, `Stack: ${stackInfo.stackType} (${stackInfo.buildTool})`, "done");
+        resolved = await resolveCIRunners(projectDir, {
+            config: options.config,
+            stack: options.stack,
+        });
+        report(onStep, stepDetect, describeRunners(resolved), "done");
     }
     catch (e) {
         report(onStep, stepDetect, "Detecting stack", "error", String(e));
         throw e;
     }
+    // Legacy single-runner view for the zero-config auto path. Keeping this
+    // shape guarantees single-stack repositories behave exactly as before.
+    const primary = resolved.runners[0];
+    const stackInfo = {
+        stackType: primary?.stack ?? "node",
+        buildTool: primary?.buildTool ?? "npm",
+        javaVersion: primary?.javaVersion ?? "21",
+        lintCmd: primary?.lintCmds[0] ?? null,
+        compileCmd: primary?.compileCmds[0] ?? null,
+        testCmd: primary?.testCmds[0] ?? null,
+    };
     // ── Detect mode ─────────────────────────────────────────────────────────────
     if (mode === "detect")
         return;
@@ -175,8 +333,9 @@ export async function runCI(options, onStep) {
             throw new Error("--shell requires Docker");
         }
         report(onStep, "docker-image", "Building Docker image", "running");
+        let shellImage;
         try {
-            await ensureImage({
+            shellImage = await ensureImage({
                 stack: stackInfo.stackType,
                 javaVersion: stackInfo.javaVersion,
             });
@@ -186,10 +345,14 @@ export async function runCI(options, onStep) {
             report(onStep, "docker-image", "Building Docker image", "error", String(e));
             throw e;
         }
-        await openShell(projectDir);
+        await openShell(projectDir, shellImage);
         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");
@@ -199,19 +362,22 @@ export async function runCI(options, onStep) {
             throw new Error("Docker is not available");
         }
         report(onStep, stepDocker, "Docker available", "done");
-        // Build image
-        const stepImage = "docker-image";
-        report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, "running");
-        try {
-            await ensureImage({
-                stack: stackInfo.stackType,
-                javaVersion: stackInfo.javaVersion,
-            });
-            report(onStep, stepImage, "Docker image ready", "done");
-        }
-        catch (e) {
-            report(onStep, stepImage, "Building Docker image", "error", String(e));
-            throw e;
+        // Build image (auto path only — configured runners ensure their own
+        // image inside the runner loop)
+        if (resolved.source === "auto") {
+            const stepImage = "docker-image";
+            report(onStep, stepImage, `Building image for ${stackInfo.stackType}`, "running");
+            try {
+                autoImage = await ensureImage({
+                    stack: stackInfo.stackType,
+                    javaVersion: stackInfo.javaVersion,
+                });
+                report(onStep, stepImage, "Docker image ready", "done");
+            }
+            catch (e) {
+                report(onStep, stepImage, "Building Docker image", "error", String(e));
+                throw e;
+            }
         }
     }
     // ── Refresh .context/ ────────────────────────────────────────────────────────
@@ -230,46 +396,22 @@ export async function runCI(options, onStep) {
         // Non-fatal: context refresh failure should not block CI
         report(onStep, stepContext, "Refresh .context/ directory", "error", String(e));
     }
-    // ── Lint ─────────────────────────────────────────────────────────────────────
-    if (stackInfo.lintCmd) {
-        const stepLint = "lint";
-        report(onStep, stepLint, `Lint: ${stackInfo.lintCmd}`, "running");
-        try {
-            await runStep(stackInfo.lintCmd, projectDir, noDocker, timeout);
-            report(onStep, stepLint, "Lint passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepLint, "Lint failed", "error", String(e));
-            throw e;
-        }
-    }
-    // ── Compile ──────────────────────────────────────────────────────────────────
-    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, "root");
-            report(onStep, stepCompile, "Compile passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepCompile, "Compile failed", "error", String(e));
-            throw e;
-        }
-    }
-    // ── Test (full mode only) ────────────────────────────────────────────────────
-    if (mode === "full" && stackInfo.testCmd) {
-        const stepTest = "test";
-        report(onStep, stepTest, `Test: ${stackInfo.testCmd}`, "running");
-        try {
-            await runStep(stackInfo.testCmd, projectDir, noDocker, timeout);
-            report(onStep, stepTest, "Tests passed", "done");
-        }
-        catch (e) {
-            report(onStep, stepTest, "Tests failed", "error", String(e));
-            throw e;
-        }
+    // ── Runner execution ─────────────────────────────────────────────────────────
+    // 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,
+        });
     }
     // ── Security scan (full mode only) ──────────────────────────────────────────
     if (mode === "full" && !noSecurity) {
@@ -313,12 +455,156 @@ export async function runCI(options, onStep) {
 // =============================================================================
 // Step runners
 // =============================================================================
-async function runStep(command, projectDir, noDocker, timeout, user) {
+/**
+ * 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 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 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) {
+        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");
+                }
+            }
+            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) {
+        const stepTools = `tools:${runner.name}`;
+        const envDesc = noDocker
+            ? `native environment (directory "${runner.directory}")`
+            : `image ${imageName}`;
+        report(onStep, stepTools, `Checking required tools [${runner.name}]: ${runner.requiredTools.join(", ")}`, "running");
+        for (const tool of runner.requiredTools) {
+            try {
+                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} — ` +
+                    "install it in the runner image/environment or remove it from requires";
+                report(onStep, stepTools, `Missing required tool [${runner.name}]: ${tool}`, "error", message);
+                throw new Error(message);
+            }
+        }
+        report(onStep, stepTools, `Required tools OK [${runner.name}]`, "done");
+    }
+    const phases = [
+        { id: "setup", label: "Setup", cmds: runner.setupCmds, skip: false },
+        { id: "lint", label: "Lint", cmds: runner.lintCmds, skip: false },
+        {
+            id: "compile",
+            label: "Compile",
+            cmds: runner.compileCmds,
+            user: "root",
+            skip: false,
+        },
+        {
+            id: "test",
+            label: "Test",
+            doneLabel: "Tests",
+            cmds: runner.testCmds,
+            skip: mode !== "full",
+        },
+        {
+            id: "security",
+            label: "Security",
+            cmds: runner.securityCmds,
+            skip: mode !== "full" || noSecurity,
+        },
+    ];
+    for (const phase of phases) {
+        if (phase.skip)
+            continue;
+        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}${suffix}: ${cmd}`, "running");
+            try {
+                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, `${subject}${suffix} failed`, "error", String(e));
+                throw e;
+            }
+        }
+    }
+}
+async function runStep(options) {
+    const { command, projectDir, noDocker, timeout, runner, user, image } = options;
     if (noDocker) {
-        // Run natively
+        // Run natively, in the runner's working directory.
+        const cwd = path.join(projectDir, runner.directory);
         await new Promise((resolve, reject) => {
             const proc = spawn("bash", ["-c", command], {
-                cwd: projectDir,
+                cwd,
                 stdio: "inherit",
                 env: { ...process.env, CI: "true" },
             });
@@ -329,9 +615,22 @@ async function runStep(command, projectDir, noDocker, timeout, user) {
         });
     }
     else {
+        // 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";
         const result = await runInContainer({
             projectDir,
-            command: `cd /home/runner/work && ${command}`,
+            image,
+            command: `cd ${workdir} && ${command}`,
             timeout,
             stream: true,
             user,
@@ -469,6 +768,26 @@ export async function installCIHooks(projectDir) {
     for (const hook of hooks) {
         const hookPath = path.join(hooksDir, hook.name);
         try {
+            // Refuse to follow symlinks. .git/hooks/<name> as a symlink to a
+            // sensitive file (e.g., ~/.ssh/authorized_keys) would otherwise be
+            // clobbered by writeFile. lstat reports the link, not the target.
+            let isSymlink = false;
+            try {
+                const stat = await fs.lstat(hookPath);
+                isSymlink = stat.isSymbolicLink();
+            }
+            catch (statErr) {
+                const code = statErr && typeof statErr === "object" && "code" in statErr
+                    ? statErr.code
+                    : "";
+                if (code !== "ENOENT") {
+                    throw statErr;
+                }
+                // ENOENT is expected if the hook file doesn't exist yet.
+            }
+            if (isSymlink) {
+                throw new Error(`refusing to write through a symlink at ${hookPath}`);
+            }
             await fs.writeFile(hookPath, hook.content, { mode: 0o755 });
             installed.push(hook.name);
         }

package/dist/commands/doctor.js

@@ -1,12 +1,10 @@
-import { execFile } from "child_process";
+import path from "node:path";
 import fs from "fs-extra";
-import path from "path";
-import { promisify } from "util";
 import { FORGE_ROOT, MODULES_DIR, PLUGINS_DIR, TEMPLATES_DIR, } from "../constants.js";
 import { detectStack } from "../lib/common.js";
 import { refreshContextDir } from "../lib/context.js";
+import { execFileAsync } from "../lib/exec.js";
 import { listInstalledPlugins } from "../lib/plugin.js";
-const execFileAsync = promisify(execFile);
 /** Resolve a binary name to its full path, returns null if not found */
 async function which(bin) {
     try {

package/dist/commands/init/report.d.ts

@@ -0,0 +1,13 @@
+import type { InitStep } from "../../types/index.js";
+import type { StepCallback } from "./types.js";
+/**
+ * Emit a step progress event via the callback.
+ *
+ * Centralized helper extracted during the init.ts split. Functionally
+ * identical to the original inline report function, with an explicit
+ * `void` return type added for type clarity. Behavior MUST stay
+ * compatible so tests asserting on emitted steps[] (and the ordering
+ * contract test) keep passing through the PR 1-6 extraction.
+ */
+export declare function report(onStep: StepCallback, id: string, label: string, status: InitStep["status"], detail?: string): void;
+//# sourceMappingURL=report.d.ts.map

package/dist/commands/init/report.js

@@ -0,0 +1,13 @@
+/**
+ * Emit a step progress event via the callback.
+ *
+ * Centralized helper extracted during the init.ts split. Functionally
+ * identical to the original inline report function, with an explicit
+ * `void` return type added for type clarity. Behavior MUST stay
+ * compatible so tests asserting on emitted steps[] (and the ordering
+ * contract test) keep passing through the PR 1-6 extraction.
+ */
+export function report(onStep, id, label, status, detail) {
+    onStep({ id, label, status, detail });
+}
+//# sourceMappingURL=report.js.map

package/dist/commands/init/steps/agent-skills.d.ts

@@ -0,0 +1,13 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 17: Generate Agent Skills manifest (skills.json).
+ *
+ * - In dry-run mode, reports what would be created without touching disk.
+ * - Otherwise writes <projectDir>/<AGENT_SKILLS_MANIFEST_FILE> with an empty
+ *   skills array unless the file already exists (idempotent).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export declare const stepAgentSkills: StepFn;
+//# sourceMappingURL=agent-skills.d.ts.map

package/dist/commands/init/steps/agent-skills.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { AGENT_SKILLS_MANIFEST_FILE } from "../../../constants.js";
+import { report } from "../report.js";
+/**
+ * Step 17: Generate Agent Skills manifest (skills.json).
+ *
+ * - In dry-run mode, reports what would be created without touching disk.
+ * - Otherwise writes <projectDir>/<AGENT_SKILLS_MANIFEST_FILE> with an empty
+ *   skills array unless the file already exists (idempotent).
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 6 of 6).
+ */
+export const stepAgentSkills = async (ctx) => {
+    const { projectDir, dryRun, onStep, options } = ctx;
+    const { projectName } = options;
+    const stepId = "agent-skills";
+    report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "running");
+    try {
+        if (!dryRun) {
+            const skillsManifest = {
+                name: projectName,
+                version: "0.1.0",
+                description: `Agent Skills manifest for ${projectName}`,
+                skills: [],
+            };
+            const skillsJsonPath = path.join(projectDir, AGENT_SKILLS_MANIFEST_FILE);
+            if (!(await fs.pathExists(skillsJsonPath))) {
+                await fs.writeJson(skillsJsonPath, skillsManifest, { spaces: 2 });
+                report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", AGENT_SKILLS_MANIFEST_FILE);
+            }
+            else {
+                report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", "already exists");
+            }
+        }
+        else {
+            report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "done", `dry-run: would generate ${AGENT_SKILLS_MANIFEST_FILE}`);
+        }
+    }
+    catch (e) {
+        report(onStep, stepId, "Generate Agent Skills manifest (skills.json)", "error", String(e));
+    }
+};
+//# sourceMappingURL=agent-skills.js.map

package/dist/commands/init/steps/ai-sync.d.ts

@@ -0,0 +1,15 @@
+import type { StepFn } from "../types.js";
+/**
+ * Step 7: AI config sync (delegated to javi-ai).
+ *
+ * - When aiSync is false, reports "skipped".
+ * - When dryRun, reports a done message without invoking javi-ai.
+ * - Otherwise shells out to `npx javi-ai sync --project-dir <projectDir> --target all`.
+ * - Detects soft failures via stderr (e.g. "Raw mode is not supported", "ERROR").
+ * - Hard failures (ENOENT, not found, ERR_MODULE_NOT_FOUND) report a helpful install hint.
+ * - Errors are swallowed and reported as status:"error" — never thrown.
+ *
+ * Extracted VERBATIM from src/commands/init.ts (PR 3 of 6).
+ */
+export declare const stepAISync: StepFn;
+//# sourceMappingURL=ai-sync.d.ts.map