javi-forge 1.6.1 → 1.7.0

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 { ensureImage, getImageName, isDockerAvailable, openShell, runInContainer, } from "../lib/docker.js";
+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,7 +345,7 @@ 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 ─────────────────────────────────────────────────────────────
@@ -199,19 +358,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 {
+                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,12 +392,78 @@ 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 ─────────────────────────────────────────────────────────────────────
+    // ── Runner execution ─────────────────────────────────────────────────────────
+    if (resolved.source === "auto" && primary) {
+        // Legacy zero-config path — unchanged single-stack behavior.
+        await runLegacySteps(stackInfo, primary, {
+            projectDir,
+            mode,
+            noDocker,
+            timeout,
+            onStep,
+        });
+    }
+    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";
+        const semgrepAvailable = await isSemgrepAvailable();
+        if (semgrepAvailable) {
+            report(onStep, stepSecurity, "Security scan (Semgrep)", "running");
+            try {
+                await runSemgrep(projectDir);
+                report(onStep, stepSecurity, "Security scan passed", "done");
+            }
+            catch (e) {
+                report(onStep, stepSecurity, "Security scan failed", "error", String(e));
+                throw e;
+            }
+        }
+        else {
+            report(onStep, stepSecurity, "Security scan", "skipped", "Semgrep not available — install semgrep or Docker");
+        }
+    }
+    // ── GHAGGA review (full mode only) ──────────────────────────────────────────
+    if (mode === "full" && !noGhagga) {
+        const stepGhagga = "ghagga";
+        const ghagga = await isGhaggaAvailable();
+        if (ghagga) {
+            report(onStep, stepGhagga, "GHAGGA review", "running");
+            try {
+                await runGhagga(projectDir);
+                report(onStep, stepGhagga, "GHAGGA review passed", "done");
+            }
+            catch (e) {
+                report(onStep, stepGhagga, "GHAGGA review failed", "error", String(e));
+                throw e;
+            }
+        }
+        else {
+            report(onStep, stepGhagga, "GHAGGA review", "skipped", "ghagga not installed");
+        }
+    }
+}
+/** 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);
+            await runStep(stackInfo.lintCmd, projectDir, noDocker, timeout, runner);
             report(onStep, stepLint, "Lint passed", "done");
         }
         catch (e) {
@@ -243,14 +471,13 @@ export async function runCI(options, onStep) {
             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");
+            await runStep(stackInfo.compileCmd, projectDir, noDocker, timeout, runner, "root");
             report(onStep, stepCompile, "Compile passed", "done");
         }
         catch (e) {
@@ -258,12 +485,11 @@ export async function runCI(options, onStep) {
             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);
+            await runStep(stackInfo.testCmd, projectDir, noDocker, timeout, runner);
             report(onStep, stepTest, "Tests passed", "done");
         }
         catch (e) {
@@ -271,54 +497,117 @@ export async function runCI(options, onStep) {
             throw e;
         }
     }
-    // ── Security scan (full mode only) ──────────────────────────────────────────
-    if (mode === "full" && !noSecurity) {
-        const stepSecurity = "security";
-        const semgrepAvailable = await isSemgrepAvailable();
-        if (semgrepAvailable) {
-            report(onStep, stepSecurity, "Security scan (Semgrep)", "running");
-            try {
-                await runSemgrep(projectDir);
-                report(onStep, stepSecurity, "Security scan passed", "done");
+}
+/**
+ * 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.
+ * Any failure aborts the whole run — nothing is ever skipped silently.
+ */
+async function runConfiguredRunner(runner, ctx) {
+    const { projectDir, mode, noDocker, noSecurity, timeout, onStep } = ctx;
+    // ── 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}`,
+                });
             }
-            catch (e) {
-                report(onStep, stepSecurity, "Security scan failed", "error", String(e));
-                throw e;
+            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");
             }
         }
-        else {
-            report(onStep, stepSecurity, "Security scan", "skipped", "Semgrep not available — install semgrep or Docker");
+        catch (e) {
+            report(onStep, stepImage, "Building Docker image", "error", String(e));
+            throw e;
         }
     }
-    // ── GHAGGA review (full mode only) ──────────────────────────────────────────
-    if (mode === "full" && !noGhagga) {
-        const stepGhagga = "ghagga";
-        const ghagga = await isGhaggaAvailable();
-        if (ghagga) {
-            report(onStep, stepGhagga, "GHAGGA review", "running");
+    // ── 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 runGhagga(projectDir);
-                report(onStep, stepGhagga, "GHAGGA review passed", "done");
+                await runStep(`command -v ${tool}`, projectDir, noDocker, timeout, runner, undefined, 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",
+            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 = `${phase.id}:${runner.name}`;
+        for (const cmd of phase.cmds) {
+            report(onStep, stepId, `${phase.label} [${runner.name}]: ${cmd}`, "running");
+            try {
+                await runStep(cmd, projectDir, noDocker, timeout, runner, phase.user, imageName);
+                report(onStep, stepId, `${phase.label} [${runner.name}] passed`, "done");
             }
             catch (e) {
-                report(onStep, stepGhagga, "GHAGGA review failed", "error", String(e));
+                report(onStep, stepId, `${phase.label} [${runner.name}] failed`, "error", String(e));
                 throw e;
             }
         }
-        else {
-            report(onStep, stepGhagga, "GHAGGA review", "skipped", "ghagga not installed");
-        }
     }
 }
-// =============================================================================
-// Step runners
-// =============================================================================
-async function runStep(command, projectDir, noDocker, timeout, user) {
+async function runStep(command, projectDir, noDocker, timeout, runner, user, imageOverride) {
     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 +618,17 @@ async function runStep(command, projectDir, noDocker, timeout, user) {
         });
     }
     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);
+        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 +766,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