@oscharko-dev/keiko-cli 0.2.0

package/dist/doctor.js

@@ -0,0 +1,108 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { SDK_VERSION } from "@oscharko-dev/keiko-sdk";
+import { hasBuiltKeikoLayout, localPackageRoot, resolvePreferredInstallLayout, } from "./install-layout.js";
+function readVersion(packageJsonPath) {
+    if (!existsSync(packageJsonPath))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof parsed.version === "string" ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveLocalPackageInstall(cwd) {
+    const packageRoot = localPackageRoot(cwd);
+    const cliEntry = resolve(packageRoot, "dist", "cli", "index.js");
+    const version = readVersion(join(packageRoot, "package.json"));
+    if (!hasBuiltKeikoLayout(packageRoot) || version === undefined)
+        return undefined;
+    return { packageRoot, cliEntry, version };
+}
+function resolveRunningEntry(argv) {
+    const entry = argv?.[1];
+    if (typeof entry !== "string")
+        return undefined;
+    const windowsAbsolute = /^[A-Za-z]:[\\/]/.test(entry);
+    if (!isAbsolute(entry) && !windowsAbsolute)
+        return undefined;
+    return entry;
+}
+function staleBinaryWarning(report) {
+    const runningEntry = report.runningEntry;
+    if (runningEntry === undefined)
+        return undefined;
+    if (report.localBuildBin !== undefined && runningEntry !== report.localBuildBin) {
+        return ("You are running Keiko from a different binary than this checkout's built CLI entry.\n" +
+            `  running: ${runningEntry}\n` +
+            `  local build: ${report.localBuildBin}\n` +
+            "Use `npm run keiko:start` or `node ./dist/cli/index.js start` from this checkout.");
+    }
+    const localInstall = report.localPackageInstall;
+    if (localInstall !== undefined && runningEntry !== localInstall.cliEntry) {
+        return ("You are running a different Keiko binary than the package installed in this workspace.\n" +
+            `  running: ${report.runningVersion} (${runningEntry})\n` +
+            `  local install: ${localInstall.version} (${localInstall.cliEntry})\n` +
+            "Use the local package script (`npm run keiko:start`) or remove the stale global install.");
+    }
+    return undefined;
+}
+export function collectDoctorReport(deps = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const runningEntry = resolveRunningEntry(deps.argv ?? process.argv);
+    const localBuildBin = resolvePreferredInstallLayout(cwd)?.binPath;
+    const localPackageInstall = resolveLocalPackageInstall(cwd);
+    const report = {
+        cwd,
+        runningEntry,
+        runningVersion: SDK_VERSION,
+        localBuildBin,
+        localPackageInstall,
+        warning: undefined,
+    };
+    return { ...report, warning: staleBinaryWarning(report) };
+}
+function windowsRemediation() {
+    return [
+        "Windows remediation:",
+        "  1. Run `where.exe keiko` to see which global shim wins on PATH.",
+        "  2. Prefer `npm run keiko:start` from the project checkout.",
+        "  3. If a stale global install is found, run `npm uninstall -g @oscharko-dev/keiko`.",
+        "  4. For a direct local launch, run `node .\\dist\\cli\\index.js start`.",
+    ].join("\n");
+}
+function posixRemediation() {
+    return [
+        "macOS/Linux remediation:",
+        "  1. Run `which keiko` to see which global binary wins on PATH.",
+        "  2. Prefer `npm run keiko:start` from the project checkout.",
+        "  3. If a stale global install is found, run `npm uninstall -g @oscharko-dev/keiko`.",
+        "  4. For a direct local launch, run `node ./dist/cli/index.js start`.",
+    ].join("\n");
+}
+export function emitDoctorWarning(io, deps = {}) {
+    const report = collectDoctorReport(deps);
+    if (report.warning === undefined)
+        return;
+    io.err(`keiko warning: stale launch path detected.\n${report.warning}\n`);
+}
+export function runDoctorCli(_args, io, _env, deps = {}) {
+    const report = collectDoctorReport(deps);
+    io.out(`Keiko doctor\n`);
+    io.out(`  cwd: ${report.cwd}\n`);
+    io.out(`  running version: ${report.runningVersion}\n`);
+    io.out(`  running entry: ${report.runningEntry ?? "(unavailable)"}\n`);
+    io.out(`  local built CLI: ${report.localBuildBin ?? "(not found)"}\n`);
+    io.out(`  local installed package: ${report.localPackageInstall?.cliEntry ?? "(not found)"}\n`);
+    io.out(`  local installed version: ${report.localPackageInstall?.version ?? "(not found)"}\n`);
+    if (report.warning !== undefined) {
+        io.out(`\nDiagnosis:\n${report.warning}\n\n`);
+    }
+    else {
+        io.out("\nDiagnosis:\nNo stale-launch mismatch detected.\n\n");
+    }
+    io.out(`${process.platform === "win32" ? windowsRemediation() : posixRemediation()}\n`);
+    return 0;
+}

package/dist/evaluate.d.ts

@@ -0,0 +1,8 @@
+import { type EnvSource } from "@oscharko-dev/keiko-model-gateway";
+import { type EvalRunnerDeps } from "@oscharko-dev/keiko-evaluations";
+import type { CliIo } from "./runner.js";
+export interface EvaluateDeps {
+    readonly runner?: EvalRunnerDeps | undefined;
+}
+export declare function runEvaluateCli(args: readonly string[], io: CliIo, env?: EnvSource, deps?: EvaluateDeps): Promise<number>;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../src/evaluate.ts"],"names":[],"mappings":"AASA,OAAO,EAOL,KAAK,SAAS,EAGf,MAAM,mCAAmC,CAAC;AAI3C,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,iCAAiC,CAAC;AAIzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAWzC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CAC9C;AA+ID,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,KAAK,EACT,GAAG,GAAE,SAAc,EACnB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,MAAM,CAAC,CAqBjB"}

package/dist/evaluate.js

@@ -0,0 +1,270 @@
+// `keiko evaluate` — runs the evaluation harness (ADR-0012 D10). Offline (default, deterministic, no
+// network) replays each fixture's scripted transcript; --live builds a GatewayModelPort and fails
+// CLOSED (exit 1, names the required env vars) when no config/credentials resolve — it NEVER silently
+// falls back to offline. Dry-run-safe by construction: fixtures choose their own apply mode. Mirrors
+// runGenTestsCli structurally (injected CliIo + deps, testable without process.*). Exit 0 when all
+// applicable dimensions pass AND surface parity passes; 1 on dimension/parity failure or runtime
+// error; 2 on usage error (unknown flag, mutual exclusion, unknown suite/fixture name).
+import { writeFileSync } from "node:fs";
+import { ConfigInvalidError, GatewayError, assertConfiguredModel, findConfiguredCapability, listConfiguredCapabilities, redact, } from "@oscharko-dev/keiko-model-gateway";
+import { createAuditRedactor, deepRedactStrings } from "@oscharko-dev/keiko-evidence";
+import { keikoApiKeySecretValues } from "@oscharko-dev/keiko-security";
+import { parseRunRequest } from "@oscharko-dev/keiko-server";
+import { fixtureByName, fixturesForSuite, isSuiteName, renderEvalSummary, runEvaluationSuite, } from "@oscharko-dev/keiko-evaluations";
+import { runGenTestsCli } from "./gen-tests.js";
+import { loadGatewayConfigFromFile } from "./gateway-config.js";
+import { runInvestigateCli } from "./investigate.js";
+const USAGE = `Usage:
+  keiko evaluate [--suite <unit-tests|bug-investigation|all>] [--fixture <name>]
+                 [--live] [--model <id>] [--config PATH] [--json] [--output <path>]
+
+Runs the evaluation harness against the built-in fixtures. Offline by default
+(deterministic, no network); pass --live to evaluate against a configured model.
+--suite and --fixture are mutually exclusive.
+`;
+function flagValue(args, name) {
+    const i = args.indexOf(name);
+    if (i === -1) {
+        return undefined;
+    }
+    const value = args[i + 1];
+    return value === undefined || value.startsWith("--") ? null : value;
+}
+const VALUE_FLAGS = ["--suite", "--fixture", "--model", "--config", "--output"];
+const BOOLEAN_FLAGS = ["--live", "--json"];
+function readValueFlags(args) {
+    const values = {};
+    for (const flag of VALUE_FLAGS) {
+        const value = flagValue(args, flag);
+        if (value === null) {
+            return null;
+        }
+        values[flag] = value;
+    }
+    return values;
+}
+function isValueFlag(value) {
+    return VALUE_FLAGS.includes(value);
+}
+function isBooleanFlag(value) {
+    return BOOLEAN_FLAGS.includes(value);
+}
+function findUsageError(args) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === undefined) {
+            continue;
+        }
+        if (isValueFlag(arg)) {
+            const value = args[i + 1];
+            if (value === undefined || value.startsWith("--")) {
+                return `missing value for ${arg}`;
+            }
+            i += 1;
+            continue;
+        }
+        if (isBooleanFlag(arg)) {
+            continue;
+        }
+        return arg.startsWith("--") ? `unknown flag ${arg}` : `unexpected argument ${arg}`;
+    }
+    return undefined;
+}
+function parseArgs(args) {
+    const values = readValueFlags(args);
+    if (values === null) {
+        return null;
+    }
+    return {
+        suite: values["--suite"],
+        fixture: values["--fixture"],
+        live: args.includes("--live"),
+        model: values["--model"],
+        config: values["--config"],
+        json: args.includes("--json"),
+        output: values["--output"],
+    };
+}
+// Resolves the fixture set from --suite / --fixture, enforcing mutual exclusion and name validity.
+function selectFixtures(parsed) {
+    if (parsed.suite !== undefined && parsed.fixture !== undefined) {
+        return { usageError: "Error: --suite and --fixture are mutually exclusive.\n" };
+    }
+    if (parsed.fixture !== undefined) {
+        const fixture = fixtureByName(parsed.fixture);
+        return fixture === undefined
+            ? { usageError: `Error: unknown fixture "${parsed.fixture}".\n` }
+            : { fixtures: [fixture] };
+    }
+    const suite = parsed.suite ?? "all";
+    if (!isSuiteName(suite)) {
+        return { usageError: `Error: unknown suite "${suite}".\n` };
+    }
+    return { fixtures: fixturesForSuite(suite) };
+}
+// In live mode, deep-redact the scorecard before serialization so that any model content that
+// leaked into workflow report fields (e.g. fixture reasons) is scrubbed by the same audit
+// redactor applied at evidence-persist time. Offline scorecard is static harness text — safe as-is.
+function redactedScorecard(scorecard, live, env) {
+    if (!live) {
+        return scorecard;
+    }
+    const redactFn = createAuditRedactor({ additionalSecrets: keikoApiKeySecretValues(env) }, env);
+    return deepRedactStrings(scorecard, redactFn);
+}
+function writeScorecard(path, output) {
+    writeFileSync(path, `${JSON.stringify(output, null, 2)}\n`, { encoding: "utf8", flag: "wx" });
+}
+function emit(scorecard, parsed, io, env) {
+    const output = redactedScorecard(scorecard, parsed.live, env);
+    // Emit --json to stdout BEFORE attempting the file write so that a file-already-exists
+    // error (EEXIST from writeScorecard) does not silently suppress the JSON output.
+    if (parsed.json) {
+        io.out(`${JSON.stringify(output, null, 2)}\n`);
+    }
+    if (parsed.output !== undefined) {
+        writeScorecard(parsed.output, output);
+    }
+    if (!parsed.json) {
+        io.out(`${renderEvalSummary(scorecard)}\n`);
+    }
+}
+// Exit 0 only when every scored dimension passed (zero failures) AND surface parity passed.
+function exitCodeFor(scorecard) {
+    if (!scorecard.surfaceParity.allPassed) {
+        return 1;
+    }
+    return scorecard.dimensions.some((d) => d.failCount > 0) ? 1 : 0;
+}
+export async function runEvaluateCli(args, io, env = {}, deps = {}) {
+    if (args.includes("--help")) {
+        io.out(USAGE);
+        return 0;
+    }
+    const usageError = findUsageError(args);
+    if (usageError !== undefined) {
+        io.err(`Error: ${usageError}.\n${USAGE}`);
+        return 2;
+    }
+    const parsed = parseArgs(args);
+    if (parsed === null) {
+        io.err(USAGE);
+        return 2;
+    }
+    const selection = selectFixtures(parsed);
+    if ("usageError" in selection) {
+        io.err(selection.usageError);
+        return 2;
+    }
+    return runSuite(parsed, selection.fixtures, io, env, deps);
+}
+async function runSuite(parsed, fixtures, io, env, deps) {
+    try {
+        const liveModelId = resolveLiveModelId(parsed, io, env);
+        if (typeof liveModelId === "number") {
+            return liveModelId;
+        }
+        const scorecard = await runEvaluationSuite({
+            mode: parsed.live ? "live" : "offline",
+            fixtures,
+            ...(liveModelId === undefined ? {} : { modelIdOverride: liveModelId }),
+            ...(parsed.config === undefined ? {} : { configPath: parsed.config }),
+        }, 
+        // Provide Date.now as the default wall-clock so a real `keiko evaluate` prints the actual
+        // current time. Tests override this via deps.runner.now for deterministic evaluatedAt.
+        {
+            env,
+            now: Date.now,
+            configLoader: loadGatewayConfigFromFile,
+            surfaceParity: {
+                runGenTestsCli,
+                runInvestigateCli,
+                parseRunRequest,
+            },
+            ...deps.runner,
+        });
+        emit(scorecard, parsed, io, env);
+        return exitCodeFor(scorecard);
+    }
+    catch (error) {
+        if (isOutputAlreadyExistsError(error)) {
+            io.err(`Error: output file already exists: ${parsed.output ?? "<unknown>"}\n`);
+            return 1;
+        }
+        return handleRunError(error, parsed, io);
+    }
+}
+function resolveLiveModelId(parsed, io, env) {
+    if (!parsed.live) {
+        return parsed.model;
+    }
+    try {
+        const path = parsed.config ?? env.KEIKO_CONFIG_FILE;
+        if (path === undefined) {
+            throw new ConfigInvalidError("no config source; pass --config PATH or set KEIKO_CONFIG_FILE");
+        }
+        const config = loadGatewayConfigFromFile(path, env);
+        if (parsed.model !== undefined) {
+            assertLiveEvaluationModel(config, parsed.model);
+            return parsed.model;
+        }
+        const modelId = selectLiveEvaluationModel(config);
+        if (modelId === undefined) {
+            io.err("Error: no configured workflow-capable chat model is available.\n");
+            return 1;
+        }
+        return modelId;
+    }
+    catch (error) {
+        if (error instanceof GatewayError) {
+            io.err(`Error: model gateway configuration problem — ${redact(error.message)}\n` +
+                `Provide a gateway config with --config PATH or KEIKO_CONFIG_FILE.\n`);
+            return 1;
+        }
+        throw error;
+    }
+}
+function isLiveEvaluationCapable(capability) {
+    return (capability?.kind === "chat" &&
+        capability.workflowEligible &&
+        capability.toolCalling &&
+        capability.structuredOutput);
+}
+const COST_RANK = { low: 0, medium: 1, high: 2 };
+function selectLiveEvaluationModel(config) {
+    let best;
+    for (const capability of listConfiguredCapabilities(config)) {
+        if (!isLiveEvaluationCapable(capability)) {
+            continue;
+        }
+        if (best === undefined || COST_RANK[capability.costClass] < COST_RANK[best.costClass]) {
+            best = capability;
+        }
+    }
+    return best?.id;
+}
+function assertLiveEvaluationModel(config, modelId) {
+    assertConfiguredModel(config, modelId);
+    if (!isLiveEvaluationCapable(findConfiguredCapability(config, modelId))) {
+        throw new ConfigInvalidError(`model '${modelId}' is not workflow-capable; live evaluation requires chat + tool-calling + structured-output`);
+    }
+}
+function isOutputAlreadyExistsError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EEXIST");
+}
+// Live-mode fail-closed: a GatewayError (incl. ConfigInvalidError) means no resolvable config or
+// credentials. Name the required env vars and exit 1 — never fall back to offline silently.
+function handleRunError(error, parsed, io) {
+    if (error instanceof GatewayError) {
+        io.err(`Error: model gateway configuration problem — ${redact(error.message)}\n` +
+            (parsed.live
+                ? "Live evaluation requires a configured provider. Pass --config PATH or set " +
+                    "KEIKO_CONFIG_FILE.\n"
+                : ""));
+        return 1;
+    }
+    throw error;
+}

package/dist/evidence.d.ts

@@ -0,0 +1,9 @@
+import { type EvidenceStore } from "@oscharko-dev/keiko-evidence";
+import type { EnvSource } from "@oscharko-dev/keiko-model-gateway";
+import type { CliIo } from "./runner.js";
+export interface EvidenceCliDeps {
+    readonly store?: EvidenceStore | undefined;
+    readonly env?: EnvSource | undefined;
+}
+export declare function runEvidenceCli(args: readonly string[], io: CliIo, deps?: EvidenceCliDeps): number;
+//# sourceMappingURL=evidence.d.ts.map

package/dist/evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evidence.d.ts","sourceRoot":"","sources":["../src/evidence.ts"],"names":[],"mappings":"AAQA,OAAO,EAQL,KAAK,aAAa,EAGnB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAWzC,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CACtC;AAmID,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,KAAK,EACT,IAAI,GAAE,eAAoB,GACzB,MAAM,CA2BR"}

package/dist/evidence.js

@@ -0,0 +1,129 @@
+// `keiko evidence` — inspects previously written evidence manifests (ADR-0010 D9). `list` prints the
+// EvidenceListEntry[] (text or --json); `show <runId>` prints one EvidenceReport / full manifest
+// (--json). It reads ONLY the contained base dir via the EvidenceStore (default $KEIKO_EVIDENCE_DIR
+// or ./.keiko/evidence, overridable with --evidence-dir). Because manifests are redacted by
+// construction there is no un-redaction path. Exit 0 on success, 1 on a missing runId / read error,
+// 2 on usage (unknown or missing subcommand, invalid runId). Tests inject an in-memory store via deps
+// so no disk is touched.
+import { buildEvidenceReport, renderEvidenceReport, listEvidence, loadEvidence, createNodeEvidenceStore, resolveEvidenceDir, AuditError, InvalidRunIdError, } from "@oscharko-dev/keiko-evidence";
+const USAGE = `Usage:
+  keiko evidence list [--evidence-dir PATH] [--json]
+  keiko evidence show <runId> [--evidence-dir PATH] [--json]
+
+Lists or shows redacted evidence manifests written by \`keiko run\`. Reads only the
+evidence base dir (default $KEIKO_EVIDENCE_DIR or ./.keiko/evidence; override with --evidence-dir).
+`;
+function parseSubcommand(value) {
+    return value === "list" || value === "show" ? value : undefined;
+}
+function parseFlags(args, startIndex) {
+    let json = false;
+    let evidenceDir;
+    let index = startIndex;
+    while (index < args.length) {
+        const arg = args[index];
+        if (arg === "--json") {
+            json = true;
+            index += 1;
+            continue;
+        }
+        if (arg !== "--evidence-dir") {
+            return { ok: false };
+        }
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--")) {
+            return { ok: false };
+        }
+        evidenceDir = value;
+        index += 2;
+    }
+    return { ok: true, json, evidenceDir };
+}
+function invalidArgs(message) {
+    return { ok: false, error: message };
+}
+function resolveStore(evidenceDir, deps) {
+    if (deps.store !== undefined) {
+        return deps.store;
+    }
+    return createNodeEvidenceStore(resolveEvidenceDir(evidenceDir, deps.env));
+}
+function parseEvidenceArgs(args) {
+    const subcommand = parseSubcommand(args[0]);
+    if (subcommand === undefined) {
+        const sub = args[0];
+        return invalidArgs(sub === undefined ? USAGE : `keiko evidence: unknown subcommand: ${sub}\n${USAGE}`);
+    }
+    let index = 1;
+    let runId;
+    if (subcommand === "show") {
+        runId = args[index];
+        if (runId === undefined || runId.startsWith("--")) {
+            return invalidArgs(`keiko evidence: show requires a <runId>.\n${USAGE}`);
+        }
+        index += 1;
+    }
+    const flags = parseFlags(args, index);
+    if (!flags.ok) {
+        return invalidArgs(`keiko evidence: invalid arguments.\n${USAGE}`);
+    }
+    return {
+        ok: true,
+        error: "",
+        parsed: { subcommand, runId, evidenceDir: flags.evidenceDir, json: flags.json === true },
+    };
+}
+function renderListText(entries) {
+    if (entries.length === 0) {
+        return "No evidence manifests found.\n";
+    }
+    const rows = entries.map((e) => `${e.runId}  ${e.taskType}  ${e.outcome}  started=${String(e.startedAt)} finished=${String(e.finishedAt)}`);
+    return `${rows.join("\n")}\n`;
+}
+function runList(store, json, io) {
+    const entries = listEvidence(store);
+    io.out(json ? `${JSON.stringify(entries, null, 2)}\n` : renderListText(entries));
+    return 0;
+}
+function runShow(store, runId, json, io) {
+    const manifest = loadEvidence(store, runId);
+    if (manifest === undefined) {
+        io.err(`keiko evidence: no manifest for runId: ${runId}\n`);
+        return 1;
+    }
+    if (json) {
+        io.out(`${JSON.stringify(manifest, null, 2)}\n`);
+        return 0;
+    }
+    io.out(renderEvidenceReport(buildEvidenceReport(manifest, store.location?.(runId) ?? `${runId}.json`)));
+    return 0;
+}
+// Maps a thrown AuditError to an exit code: an invalid runId is a usage error (2), any other
+// audit/read failure is a runtime error (1). Messages are already redacted at construction.
+function exitForAuditError(error, io) {
+    io.err(`keiko evidence: ${error.message}\n`);
+    return error instanceof InvalidRunIdError ? 2 : 1;
+}
+export function runEvidenceCli(args, io, deps = {}) {
+    const parsed = parseEvidenceArgs(args);
+    if (!parsed.ok || parsed.parsed === undefined) {
+        io.err(parsed.error);
+        return 2;
+    }
+    try {
+        if (parsed.parsed.subcommand === "list") {
+            return runList(resolveStore(parsed.parsed.evidenceDir, deps), parsed.parsed.json, io);
+        }
+        if (parsed.parsed.runId === undefined) {
+            io.err(`keiko evidence: show requires a <runId>.\n${USAGE}`);
+            return 2;
+        }
+        return runShow(resolveStore(parsed.parsed.evidenceDir, deps), parsed.parsed.runId, parsed.parsed.json, io);
+    }
+    catch (error) {
+        if (error instanceof AuditError) {
+            return exitForAuditError(error, io);
+        }
+        throw error;
+    }
+}

package/dist/gateway-config.d.ts

@@ -0,0 +1,12 @@
+import { type EnvSource, type GatewayConfig } from "@oscharko-dev/keiko-model-gateway";
+export type ConfigPathResolution = {
+    readonly kind: "path";
+    readonly path: string;
+} | {
+    readonly kind: "missing-value";
+} | {
+    readonly kind: "not-configured";
+};
+export declare function resolveConfigPathFromArgs(args: readonly string[], env: EnvSource): ConfigPathResolution;
+export declare function loadGatewayConfigFromFile(path: string, env: EnvSource): GatewayConfig;
+//# sourceMappingURL=gateway-config.d.ts.map

package/dist/gateway-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-config.d.ts","sourceRoot":"","sources":["../src/gateway-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,aAAa,EACnB,MAAM,mCAAmC,CAAC;AAG3C,MAAM,MAAM,oBAAoB,GAC5B;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAClC;IAAE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAExC,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,GAAG,EAAE,SAAS,GACb,oBAAoB,CAWtB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,GAAG,aAAa,CAIrF"}

package/dist/gateway-config.js

@@ -0,0 +1,19 @@
+import { loadConfigFromFile, } from "@oscharko-dev/keiko-model-gateway";
+import { createProviderSecretResolver } from "@oscharko-dev/keiko-server/credential-vault";
+export function resolveConfigPathFromArgs(args, env) {
+    const flagIndex = args.indexOf("--config");
+    if (flagIndex !== -1) {
+        const value = args[flagIndex + 1];
+        return value === undefined || value.startsWith("--")
+            ? { kind: "missing-value" }
+            : { kind: "path", path: value };
+    }
+    return env.KEIKO_CONFIG_FILE === undefined
+        ? { kind: "not-configured" }
+        : { kind: "path", path: env.KEIKO_CONFIG_FILE };
+}
+export function loadGatewayConfigFromFile(path, env) {
+    return loadConfigFromFile(path, env, {
+        secretResolver: createProviderSecretResolver({ configPath: path, env }),
+    });
+}

package/dist/gen-tests.d.ts

@@ -0,0 +1,8 @@
+import { type EnvSource } from "@oscharko-dev/keiko-model-gateway";
+import { type ModelPort } from "@oscharko-dev/keiko-harness";
+import type { CliIo } from "./runner.js";
+export interface GenTestsDeps {
+    readonly model?: ModelPort | undefined;
+}
+export declare function runGenTestsCli(args: readonly string[], io: CliIo, env?: EnvSource, deps?: GenTestsDeps): Promise<number>;
+//# sourceMappingURL=gen-tests.d.ts.map

package/dist/gen-tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen-tests.d.ts","sourceRoot":"","sources":["../src/gen-tests.ts"],"names":[],"mappings":"AAQA,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAK/E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAWzC,MAAM,WAAW,YAAY;IAE3B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CACxC;AAkMD,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,EAAE,EAAE,KAAK,EACT,GAAG,GAAE,SAAc,EACnB,IAAI,GAAE,YAAiB,GACtB,OAAO,CAAC,MAAM,CAAC,CAuCjB"}