agentera 3.0.0-dev.4 → 3.0.0-dev.46

package/dist/cli/commands/verify.js

@@ -1,9 +1,11 @@
 import { main as evalSkillsMain } from "../../eval/evalSkills.js";
 import { main as semanticEvalMain } from "../../eval/semanticEval.js";
+import { evaluateHybridRoute } from "../../eval/hybridRouteEvaluation.js";
+import { routeEvaluationExitCode } from "./route.js";
 export const VERIFY_FAMILIES = ["eval"];
 export const RETIRED_VERIFY_FAMILIES = ["smoke"];
 export const VERIFY_TARGETS = {
-    eval: ["skills", "semantic"],
+    eval: ["skills", "semantic", "routing"],
 };
 export const VERIFY_FORMATS = ["text", "json"];
 export const VERIFY_DIAGNOSTIC_LINE_LIMIT = 20;
@@ -43,14 +45,14 @@ export function validateVerifyRequest(args) {
     if (family === "eval" && target === "skills" && args.run && args.dryRun) {
         throw new Error("unsupported eval skills request combines --run and --dry-run; choose one mode. " +
             "Safe default: omit --run to list the bounded dry-run plan without invoking a runtime. " +
-            "Syntax: agentera verify eval skills [--run] [--skill NAME] [--timeout SECONDS] [--parallel N] [--runtime auto|claude|opencode] [--format text|json]. " +
+            "Syntax: agentera verify eval skills [--run] [--skill NAME] [--timeout SECONDS] [--parallel N] [--runtime auto|opencode|cursor] [--format text|json]. " +
             "Example: agentera verify eval skills --dry-run --format json");
     }
     if (family === "eval" && target === "skills") {
         const runtime = String(args.runtime ?? "auto");
-        if (!["auto", "claude", "opencode"].includes(runtime)) {
-            throw new Error(`unsupported eval skills runtime '${runtime}'; valid runtimes: auto, claude, opencode. ` +
-                "Syntax: agentera verify eval skills [--run] [--runtime auto|claude|opencode] [--format text|json]. " +
+        if (!["auto", "opencode", "cursor"].includes(runtime)) {
+            throw new Error(`unsupported eval skills runtime '${runtime}'; valid runtimes: auto, opencode, cursor. ` +
+                "Syntax: agentera verify eval skills [--run] [--runtime auto|opencode|cursor] [--format text|json]. " +
                 "Example: agentera verify eval skills --format json");
         }
         if ((args.parallel ?? 1) < 1 || (args.timeout ?? 120) < 1) {
@@ -63,7 +65,7 @@ export function validateVerifyRequest(args) {
         throw new Error("semantic verify requires explicit fixture path(s); broad fixture discovery is not a safe default. " +
             "Valid targets for eval: skills, semantic. " +
             "Syntax: agentera verify eval semantic <fixture> [<fixture>...] [--format text|json]. " +
-            "Example: agentera verify eval semantic fixtures/semantic/hej-bare-message.md --format json");
+            "Example: agentera verify eval semantic fixtures/semantic/bare-agentera-message.md --format json");
     }
     return [family, target, outputFormat];
 }
@@ -92,11 +94,11 @@ function runVerifyEngine(family, target, args) {
         }
         else {
             // Pin a concrete runtime for safe discovery unless explicitly chosen.
-            const dryRunRuntime = runtime !== "auto" ? runtime : "claude";
+            const dryRunRuntime = runtime !== "auto" ? runtime : "opencode";
             engineArgs.push("--parallel", parallel, "--timeout", timeout, "--runtime", dryRunRuntime, "--dry-run");
             safety = {
                 mode: "dry-run",
-                summary: "default lists skill prompts without invoking Claude Code, OpenCode, or long-running evals",
+                summary: "default lists skill prompts without invoking OpenCode, Cursor, or long-running evals",
                 live: false,
                 long_running_default: false,
             };
@@ -115,6 +117,20 @@ function runVerifyEngine(family, target, args) {
         const result = runInProcess(["eval", "semantic", ...fixtures], (out) => semanticEvalMain(fixtures, (l) => out(l)));
         return { result, safety };
     }
+    if (family === "eval" && target === "routing") {
+        const safety = {
+            mode: "offline-frozen-corpus",
+            summary: "runs the contract-owned frozen synthetic corpus only; it never sends requests or invokes a semantic host",
+            live: false,
+            long_running_default: false,
+        };
+        const result = runInProcess(["eval", "routing"], (out) => {
+            const report = evaluateHybridRoute();
+            out(JSON.stringify(report, null, 2) + "\n");
+            return routeEvaluationExitCode(report);
+        });
+        return { result, safety };
+    }
     throw new Error(`unhandled verify target ${family}/${target}`);
 }
 function runInProcess(command, invoke) {
@@ -207,4 +223,3 @@ export function cmdVerify(args, io = {}) {
     }
     return result.returncode;
 }
-//# sourceMappingURL=verify.js.map

package/dist/cli/contracts/bundleStatus.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/orientationState.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/dispatch/argvParser.js

@@ -0,0 +1,32 @@
+/** Shared argv flag helpers for dispatch-layer parsers. */
+/** Read `--flag` or `--flag=value` at argv[index]. */
+export function readArgvFlag(argv, index, name) {
+    const a = argv[index];
+    if (a === name)
+        return argv[index + 1] ?? null;
+    if (a.startsWith(name + "="))
+        return a.slice(name.length + 1);
+    return null;
+}
+/** True when argv[index] is `name` or `name=value`. */
+export function matchesArgvFlag(argv, index, name) {
+    const a = argv[index];
+    return a === name || a.startsWith(name + "=");
+}
+/**
+ * Factory matching the inline `value(name)` closures used across dispatch parsers.
+ * Space-separated values advance the outer loop index via setIndex.
+ */
+export function makeArgvValueReader(argv, getIndex, setIndex) {
+    return (name) => {
+        const i = getIndex();
+        const a = argv[i];
+        if (a === name) {
+            setIndex(i + 1);
+            return argv[i + 1] ?? null;
+        }
+        if (a.startsWith(name + "="))
+            return a.slice(name.length + 1);
+        return null;
+    };
+}

package/dist/cli/dispatch/check.js

@@ -0,0 +1,372 @@
+import { cmdLint } from "../commands/lint.js";
+import { cmdCompact } from "../commands/compact.js";
+import { cmdSchema } from "../commands/schema.js";
+import { cmdValidate, cmdValidateCapability, cmdValidateCapabilityContract, cmdValidateArtifact, cmdValidateState, isDelegatedValidateFamily, VALIDATE_FAMILY_NAMES, cmdValidateActivationConjunction, } from "../commands/validate.js";
+import { makeArgvValueReader } from "./argvParser.js";
+import { asEnvelopeFormat, classifyParseError, detectTopLevelFormat } from "./shared.js";
+import { emitInvalidInput } from "../errors.js";
+import { StateWriteInputError } from "../../state/write/errors.js";
+import { cmdDurability, entityDurabilityFailure, emitDurabilityFailure, requestedDurabilityFormat, validateDurabilityArgs, } from "../commands/durability.js";
+import { resolveSourceRoot } from "../../core/sourceRoot.js";
+import { StateRetrievalFailure } from "../../state/directRetrieval.js";
+/** Minimal flag parser for the `lint` command surface. */
+export function parseLintArgs(argv) {
+    const args = { artifact: "", file: null, text: null, strict: false, format: "text" };
+    let sawArtifact = false;
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
+        const a = argv[i];
+        let v;
+        if ((v = value("--artifact")) !== null) {
+            args.artifact = v;
+            sawArtifact = true;
+        }
+        else if ((v = value("--file")) !== null) {
+            args.file = v;
+        }
+        else if ((v = value("--text")) !== null) {
+            args.text = v;
+        }
+        else if (a === "--strict") {
+            args.strict = true;
+        }
+        else if ((v = value("--format")) !== null) {
+            if (v !== "text" && v !== "json") {
+                return { error: `argument --format: invalid choice: '${v}' (choose from 'text', 'json')` };
+            }
+            args.format = v;
+        }
+        else {
+            return { error: `unrecognized arguments: ${a}` };
+        }
+    }
+    if (!sawArtifact)
+        return { error: "the following arguments are required: --artifact" };
+    if (args.file !== null && args.text !== null) {
+        return { error: "argument --text: not allowed with argument --file" };
+    }
+    return args;
+}
+export function runLint(argv, io, prog = "agentera lint") {
+    const parsed = parseLintArgs(argv);
+    if ("error" in parsed) {
+        return emitInvalidInput(io, {
+            format: detectTopLevelFormat(argv),
+            body: classifyParseError(parsed.error),
+        });
+    }
+    try {
+        return cmdLint(parsed, io);
+    }
+    catch (exc) {
+        return emitInvalidInput(io, {
+            format: asEnvelopeFormat(parsed.format),
+            body: { class: "unsupported_target", message: exc.message },
+        });
+    }
+}
+export function compactModeOf(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--apply")
+            return "fix";
+        if (argv[i] === "--mode")
+            return argv[i + 1] ?? "check";
+        if (argv[i].startsWith("--mode="))
+            return argv[i].slice("--mode=".length);
+    }
+    return "check";
+}
+export function parseCompactArgs(argv) {
+    const args = { project: null, mode: "check", format: "text" };
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
+        const a = argv[i];
+        let v;
+        if (a === "--apply") {
+            args.mode = "fix";
+        }
+        else if ((v = value("--project")) !== null)
+            args.project = v;
+        else if ((v = value("--mode")) !== null) {
+            if (v !== "check" && v !== "fix") {
+                return { error: `argument --mode: invalid choice: '${v}' (choose from 'check', 'fix')` };
+            }
+            args.mode = v;
+        }
+        else if ((v = value("--format")) !== null) {
+            if (v !== "text" && v !== "json") {
+                return { error: `argument --format: invalid choice: '${v}' (choose from 'text', 'json')` };
+            }
+            args.format = v;
+        }
+        else
+            return { error: `unrecognized arguments: ${a}` };
+    }
+    return args;
+}
+export function runCompact(argv, io, prog) {
+    const parsed = parseCompactArgs(argv);
+    if ("error" in parsed) {
+        return emitInvalidInput(io, {
+            format: "text",
+            body: classifyParseError(parsed.error),
+        });
+    }
+    try {
+        return cmdCompact(parsed, io);
+    }
+    catch (exc) {
+        if (exc instanceof StateWriteInputError)
+            return emitInvalidInput(io, { format: asEnvelopeFormat(parsed.format), body: exc.body });
+        return emitInvalidInput(io, {
+            format: asEnvelopeFormat(parsed.format),
+            body: { class: "unsupported_target", message: exc.message },
+        });
+    }
+}
+export function parseDurabilityArgs(argv) {
+    const args = { project: null, artifact: null, format: "text" };
+    let i = 0;
+    const value = makeArgvValueReader(argv, () => i, (n) => {
+        i = n;
+    });
+    for (; i < argv.length; i++) {
+        const token = argv[i];
+        let parsed;
+        if ((parsed = value("--project")) !== null)
+            args.project = parsed;
+        else if ((parsed = value("--artifact")) !== null)
+            args.artifact = parsed;
+        else if ((parsed = value("--id")) !== null)
+            args.id = parsed;
+        else if ((parsed = value("--number")) !== null) {
+            if (!/^[1-9][0-9]*$/.test(parsed))
+                return { error: `argument --number: invalid int value: '${parsed}'` };
+            const number = Number(parsed);
+            if (!Number.isSafeInteger(number))
+                return { error: `argument --number: invalid int value: '${parsed}'` };
+            args.number = number;
+        }
+        else if ((parsed = value("--limit")) !== null) {
+            if (!/^[1-9][0-9]*$/.test(parsed))
+                return { error: `argument --limit: invalid int value: '${parsed}'` };
+            const limit = Number(parsed);
+            if (!Number.isSafeInteger(limit))
+                return { error: `argument --limit: invalid int value: '${parsed}'` };
+            args.limit = limit;
+        }
+        else if ((parsed = value("--format")) !== null) {
+            if (parsed !== "text" && parsed !== "json" && parsed !== "yaml") {
+                return { error: `argument --format: invalid choice: '${parsed}' (choose from 'text', 'json', 'yaml')` };
+            }
+            args.format = parsed;
+        }
+        else
+            return { error: `unrecognized arguments: ${token}` };
+    }
+    if (args.number !== undefined && !args.artifact) {
+        return { error: "the following arguments are required: --artifact when --number is supplied" };
+    }
+    return args;
+}
+export function runDurability(argv, io, prog) {
+    const format = requestedDurabilityFormat(argv);
+    const sourceRoot = resolveSourceRoot();
+    const parsed = parseDurabilityArgs(argv);
+    if ("error" in parsed) {
+        return emitDurabilityFailure(entityDurabilityFailure(parsed.error), format, io);
+    }
+    try {
+        validateDurabilityArgs(parsed, sourceRoot);
+        return cmdDurability(parsed, io);
+    }
+    catch (exc) {
+        if (exc instanceof StateRetrievalFailure)
+            return emitDurabilityFailure(exc, format, io);
+        return emitDurabilityFailure(entityDurabilityFailure(exc.message, parsed.artifact, parsed.id ?? undefined), format, io);
+    }
+}
+export function runValidate(argv, io, prog) {
+    const requestedFormat = detectTopLevelFormat(argv);
+    let family = null;
+    let capabilityTarget = null;
+    let artifactFlag = null;
+    let fileFlag = null;
+    let cwdFlag = null;
+    let format = "text";
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "--format") {
+            const v = argv[++i];
+            if (v !== "text" && v !== "json") {
+                return emitInvalidInput(io, {
+                    format,
+                    body: {
+                        class: "invalid_choice",
+                        message: `argument --format: invalid choice: '${v}' (choose from 'text', 'json')`,
+                        valid_values: ["text", "json"],
+                    },
+                });
+            }
+            format = v;
+        }
+        else if (a.startsWith("--format=")) {
+            const v = a.slice("--format=".length);
+            if (v !== "text" && v !== "json") {
+                return emitInvalidInput(io, {
+                    format,
+                    body: {
+                        class: "invalid_choice",
+                        message: `argument --format: invalid choice: '${v}' (choose from 'text', 'json')`,
+                        valid_values: ["text", "json"],
+                    },
+                });
+            }
+            format = v;
+        }
+        else if (a === "--artifact" || a.startsWith("--artifact=")) {
+            artifactFlag = a === "--artifact" ? argv[++i] : a.slice("--artifact=".length);
+        }
+        else if (a === "--file" || a.startsWith("--file=")) {
+            fileFlag = a === "--file" ? argv[++i] : a.slice("--file=".length);
+        }
+        else if (a === "--cwd" || a.startsWith("--cwd=")) {
+            cwdFlag = a === "--cwd" ? argv[++i] : a.slice("--cwd=".length);
+        }
+        else if (a.startsWith("--")) {
+            return emitInvalidInput(io, {
+                format: requestedFormat,
+                body: {
+                    class: "unrecognized_argument",
+                    message: `unrecognized arguments: ${a}`,
+                },
+            });
+        }
+        else if (family === null) {
+            family = a;
+        }
+        else if (capabilityTarget === null) {
+            capabilityTarget = a;
+        }
+        else {
+            return emitInvalidInput(io, {
+                format: requestedFormat,
+                body: {
+                    class: "unrecognized_argument",
+                    message: `unrecognized arguments: ${a}`,
+                },
+            });
+        }
+    }
+    if (family === null) {
+        return emitInvalidInput(io, {
+            format,
+            body: {
+                class: "missing_argument",
+                message: "the following arguments are required: validate_family",
+                valid_values: [...VALIDATE_FAMILY_NAMES],
+                example: "agentera check validate cross-capability",
+            },
+        });
+    }
+    try {
+        if (family === "capability") {
+            if (capabilityTarget === null) {
+                return emitInvalidInput(io, {
+                    format,
+                    body: {
+                        class: "missing_argument",
+                        message: "the following arguments are required: target",
+                        example: "agentera check validate capability plan",
+                    },
+                });
+            }
+            return cmdValidateCapability(capabilityTarget, { format }, io);
+        }
+        if (family === "capability-contract") {
+            return cmdValidateCapabilityContract({ format }, io);
+        }
+        if (family === "activation-conjunction") {
+            return cmdValidateActivationConjunction(io);
+        }
+        if (family === "artifact") {
+            if (artifactFlag === null) {
+                return emitInvalidInput(io, {
+                    format,
+                    body: {
+                        class: "missing_argument",
+                        message: "the following arguments are required: --artifact",
+                        example: "agentera check validate artifact --artifact plan",
+                    },
+                });
+            }
+            return cmdValidateArtifact({ artifact: artifactFlag, file: fileFlag, cwd: cwdFlag, format }, io);
+        }
+        if (family === "state") {
+            return cmdValidateState({ cwd: cwdFlag, format }, io);
+        }
+        if (isDelegatedValidateFamily(family)) {
+            return cmdValidate(family, { format }, io);
+        }
+        return emitInvalidInput(io, {
+            format,
+            body: {
+                class: "unsupported_target",
+                message: `unsupported validate family '${family}'; valid families are listed in valid_values.`,
+                valid_values: [...VALIDATE_FAMILY_NAMES],
+            },
+        });
+    }
+    catch (exc) {
+        return emitInvalidInput(io, {
+            format,
+            body: {
+                class: "unsupported_target",
+                message: exc.message,
+            },
+        });
+    }
+}
+export function runSchema(argv, io, prog) {
+    let format = "json";
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        let v = null;
+        if (a === "--format")
+            v = argv[++i];
+        else if (a.startsWith("--format="))
+            v = a.slice("--format=".length);
+        else {
+            return emitInvalidInput(io, {
+                format: asEnvelopeFormat(format),
+                body: { class: "unrecognized_argument", message: `unrecognized arguments: ${a}` },
+            });
+        }
+        if (v !== "json" && v !== "yaml") {
+            return emitInvalidInput(io, {
+                format: asEnvelopeFormat(format),
+                body: {
+                    class: "invalid_choice",
+                    message: `argument --format: invalid choice: '${v}' (choose from 'json', 'yaml')`,
+                    valid_values: ["json", "yaml"],
+                },
+            });
+        }
+        format = v;
+    }
+    try {
+        return cmdSchema({ format }, io);
+    }
+    catch (exc) {
+        return emitInvalidInput(io, {
+            format: asEnvelopeFormat(format),
+            body: { class: "unsupported_target", message: exc.message },
+        });
+    }
+}

package/dist/cli/dispatch/commands.js

@@ -0,0 +1,27 @@
+import { CAPABILITY_ROUTING_NAMES } from "../commands/capability.js";
+import { DIAGNOSTIC_TOP_LEVEL_COMMANDS } from "./projections.js";
+/**
+ * Top-level commands routed by `dispatch/main` (includes migration aliases still
+ * accepted at the CLI surface).
+ */
+export const DISPATCHER_TOP_LEVEL_COMMANDS = [
+    "prime",
+    "app-home",
+    "doctor",
+    "usage",
+    "upgrade",
+    "verify",
+    "report",
+    "stats",
+    "schema",
+    "lint",
+    "check",
+    "state",
+    "query",
+    "compact",
+    "validate",
+    "route",
+    ...CAPABILITY_ROUTING_NAMES,
+];
+/** Set view for doctor in-process CLI probe checks. */
+export const DISPATCHER_COMMANDS = new Set(DIAGNOSTIC_TOP_LEVEL_COMMANDS);