@velum-labs/routekit-eval-setup 1.0.0

package/dist/questions.d.ts

@@ -0,0 +1,7 @@
+import type { EvalSetupStage, EvalSetupState } from "@velum-labs/routekit-eval-contracts";
+import type { RepositoryInspection, SetupQuestion } from "./types.js";
+export declare const questionForStage: (stage: EvalSetupStage, inspection?: RepositoryInspection) => SetupQuestion | undefined;
+export declare const withOpenQuestion: (state: EvalSetupState, inspection?: RepositoryInspection) => {
+    readonly state: EvalSetupState;
+    readonly question?: SetupQuestion;
+};

package/dist/questions.js

@@ -0,0 +1,67 @@
+const firstThree = (values, fallback) => {
+    const unique = [...new Set(values.filter((value) => value.trim().length > 0))].slice(0, 3);
+    return [unique[0] ?? fallback[0], unique[1] ?? fallback[1], unique[2] ?? fallback[2]];
+};
+export const questionForStage = (stage, inspection) => {
+    switch (stage) {
+        case "surface":
+            return {
+                id: stage,
+                prompt: "Which model-backed workflow should RouteKit optimize first?",
+                options: firstThree(inspection?.surfaces.map((surface) => surface.model === undefined
+                    ? `${surface.name} (${surface.path})`
+                    : `${surface.name} on ${surface.model}`) ?? [], ["Repository default", "The primary user-facing flow", "Stop setup"])
+            };
+        case "data":
+            return {
+                id: stage,
+                prompt: "Which representative inputs should this eval measure?",
+                options: firstThree(inspection?.materials.map((material) => `${material.path} (${material.kind})`) ?? [], ["Existing tests and fixtures", "Sanitized real examples", "Generate seed cases"])
+            };
+        case "criteria":
+            return {
+                id: stage,
+                prompt: "What makes an answer acceptable for this workflow?",
+                options: ["Correct and complete", "Valid structured output", "Correct tool behavior"]
+            };
+        case "constraints":
+            return {
+                id: stage,
+                prompt: "What should RouteKit optimize after candidates meet the quality floor?",
+                options: ["Lowest cost", "Lowest latency", "Highest quality"]
+            };
+        case "candidates":
+            return {
+                id: stage,
+                prompt: "Enter exactly three unique provider/model IDs: two candidates, then a distinct judge.",
+                options: [
+                    "Compare my current model with one cheaper candidate",
+                    "Compare two models I name with a separate judge",
+                    "Help me find three explicit model IDs"
+                ]
+            };
+        case "spend-approval":
+            return {
+                id: stage,
+                prompt: "The suite is validated. How should RouteKit proceed with paid model calls?",
+                options: ["Run a three-case pilot", "Run the full comparison", "Save without running"]
+            };
+        case "publish":
+            return {
+                id: stage,
+                prompt: "Should RouteKit publish the proposed winner and fallbacks for this profile?",
+                options: ["Publish this policy", "Keep the proposal unpublished", "Run another comparison"]
+            };
+        case "completed":
+            return undefined;
+    }
+};
+export const withOpenQuestion = (state, inspection) => {
+    const question = questionForStage(state.stage, inspection);
+    if (question === undefined)
+        return { state };
+    return {
+        state: { ...state, openQuestion: question.prompt },
+        question
+    };
+};

package/dist/runner.d.ts

@@ -0,0 +1,8 @@
+import { Context, Layer } from "effect";
+import type { EvalSetupRunnerShape } from "./types.js";
+declare const EvalSetupRunner_base: Context.ServiceClass<EvalSetupRunner, "@velum-labs/routekit-eval-setup/EvalSetupRunner", EvalSetupRunnerShape>;
+export declare class EvalSetupRunner extends EvalSetupRunner_base {
+    static layer(service: EvalSetupRunnerShape): Layer.Layer<EvalSetupRunner, never, never>;
+}
+export declare const EvalSetupRunnerNoop: Layer.Layer<EvalSetupRunner, never, never>;
+export {};

package/dist/runner.js

@@ -0,0 +1,16 @@
+import { Context, Effect, Layer } from "effect";
+import { EvalSetupRunnerError } from "./errors.js";
+export class EvalSetupRunner extends Context.Service()("@velum-labs/routekit-eval-setup/EvalSetupRunner") {
+    static layer(service) {
+        return Layer.succeed(EvalSetupRunner, EvalSetupRunner.of(service));
+    }
+}
+const unavailable = (operation) => Effect.fail(new EvalSetupRunnerError({
+    operation,
+    detail: "EvalSetupRunner is not configured"
+}));
+export const EvalSetupRunnerNoop = EvalSetupRunner.layer({
+    validate: () => Effect.void,
+    estimate: () => Effect.succeed({ callCount: 0, pricingKnown: false }),
+    publish: () => unavailable("publishing an activation")
+});

package/dist/service.d.ts

@@ -0,0 +1,24 @@
+import { EVAL_SETUP_VERSION } from "@velum-labs/routekit-eval-contracts";
+import { Context, Effect, Layer, Path } from "effect";
+import { type EvalSetupRunnerError, EvalSetupTransitionError } from "./errors.js";
+import { OriEvalAuthoring } from "./ori-authoring.js";
+import { EvalSetupRunner } from "./runner.js";
+import type { SetupAnswerResult, SetupEstimate, SetupRunResult, SetupStatus } from "./types.js";
+export type EvalSetupError = EvalSetupRunnerError | EvalSetupTransitionError;
+export type EvalSetupShape = {
+    readonly prepare: (repositoryRoot: string, profileId: string, options?: Readonly<{
+        description?: string;
+    }>) => Effect.Effect<SetupAnswerResult, EvalSetupError>;
+    readonly status: (repositoryRoot: string, profileId: string) => Effect.Effect<SetupStatus | undefined, EvalSetupError>;
+    readonly answer: (repositoryRoot: string, profileId: string, answer: string) => Effect.Effect<SetupAnswerResult, EvalSetupError>;
+    readonly validate: (repositoryRoot: string, profileId: string) => Effect.Effect<SetupAnswerResult, EvalSetupError>;
+    readonly estimate: (repositoryRoot: string, profileId: string, _mode?: "pilot" | "full") => Effect.Effect<SetupEstimate, EvalSetupError>;
+    readonly runApproved: (repositoryRoot: string, profileId: string) => Effect.Effect<SetupRunResult, EvalSetupError>;
+    readonly publishApproved: (repositoryRoot: string, profileId: string) => Effect.Effect<SetupRunResult, EvalSetupError>;
+};
+declare const EvalSetup_base: Context.ServiceClass<EvalSetup, "@velum-labs/routekit-eval-setup/EvalSetup", EvalSetupShape>;
+export declare class EvalSetup extends EvalSetup_base {
+}
+export declare const makeEvalSetup: Effect.Effect<EvalSetupShape, never, Path.Path | OriEvalAuthoring | EvalSetupRunner>;
+export declare const EvalSetupLive: Layer.Layer<EvalSetup, never, Path.Path | OriEvalAuthoring | EvalSetupRunner>;
+export { EVAL_SETUP_VERSION };

package/dist/service.js

@@ -0,0 +1,279 @@
+import { EVAL_SETUP_VERSION } from "@velum-labs/routekit-eval-contracts";
+import { Clock, Context, Effect, Layer, Path } from "effect";
+import { EvalSetupTransitionError } from "./errors.js";
+import { authoringRequest, initialHostMetadata, loadHostMetadata, saveHostMetadata } from "./host-metadata.js";
+import { OriEvalAuthoring } from "./ori-authoring.js";
+import { EvalSetupRunner } from "./runner.js";
+const isoNow = Effect.map(Clock.currentTimeMillis, (millis) => new Date(millis).toISOString());
+const asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const asString = (value) => typeof value === "string" && value.trim().length > 0 ? value : undefined;
+const asStringArray = (value) => Array.isArray(value)
+    ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+    : [];
+const questionFromResult = (result) => {
+    if (result.status !== "waiting")
+        return undefined;
+    const tag = asString(result.tag) ?? "untagged";
+    const prompt = asString(result.prompt) ?? asString(result.question);
+    if (prompt === undefined)
+        return undefined;
+    return {
+        id: tag,
+        prompt,
+        options: asStringArray(result.options),
+        ...(asString(result.context) === undefined ? {} : { context: asString(result.context) })
+    };
+};
+const stageFromResult = (result, fallback) => {
+    if (result === undefined)
+        return fallback;
+    if (result.status === "waiting")
+        return asString(result.tag) ?? "waiting";
+    return asString(result.status) ?? fallback;
+};
+const stateView = (host, result) => ({
+    profileId: host.profileId,
+    repositoryRoot: host.repositoryRoot,
+    stage: stageFromResult(result ?? host.lastResult, host.lastResult === undefined ? "prepared" : "unknown"),
+    revision: host.revision,
+    updatedAt: host.updatedAt,
+    answers: host.answers,
+    ...(host.runDirectory === undefined ? {} : { runDirectory: host.runDirectory }),
+    ...(host.scratchWorkspace === undefined ? {} : { scratchWorkspace: host.scratchWorkspace }),
+    ...(host.publishApproved === undefined ? {} : { publishApproved: host.publishApproved })
+});
+const statusOf = (host, result) => {
+    const current = result ?? host.lastResult;
+    const question = current === undefined ? undefined : questionFromResult(current);
+    return {
+        state: stateView(host, current),
+        ...(question === undefined ? {} : { question }),
+        ...(current === undefined ? {} : { result: current })
+    };
+};
+const eventsFor = (host, result) => {
+    const question = result === undefined ? undefined : questionFromResult(result);
+    const events = [];
+    if (question !== undefined) {
+        events.push({
+            type: "question",
+            stage: "surface",
+            prompt: question.prompt
+        });
+    }
+    if (result?.status === "completed") {
+        events.push({ type: "completed", profileId: host.profileId });
+    }
+    return events;
+};
+const mergeHost = (host, result, now, answer) => {
+    const state = asRecord(result.state);
+    const tag = asString(result.tag) ?? asString(host.lastResult?.tag);
+    const rejected = result.status === "waiting" && result.accepted === false;
+    return {
+        ...host,
+        revision: host.revision + (answer === undefined || rejected ? 0 : 1),
+        updatedAt: now,
+        answers: answer === undefined || tag === undefined || rejected
+            ? host.answers
+            : { ...host.answers, [tag]: answer },
+        runDirectory: asString(result.runDirectory) ?? host.runDirectory,
+        scratchWorkspace: asString(result.scratchWorkspace) ??
+            asString(state?.scratchWorkspace) ??
+            host.scratchWorkspace,
+        lastResult: result
+    };
+};
+const requireHost = (host, profileId) => {
+    if (host === undefined) {
+        throw new EvalSetupTransitionError({
+            stage: "absent",
+            detail: `no setup exists for profile ${JSON.stringify(profileId)}`
+        });
+    }
+    return host;
+};
+const requireResult = (host, detail) => {
+    if (host.lastResult === undefined) {
+        throw new EvalSetupTransitionError({
+            stage: host.lastResult === undefined ? "prepared" : stageFromResult(host.lastResult, "unknown"),
+            detail
+        });
+    }
+    return host.lastResult;
+};
+export class EvalSetup extends Context.Service()("@velum-labs/routekit-eval-setup/EvalSetup") {
+}
+export const makeEvalSetup = Effect.gen(function* () {
+    const authoring = yield* OriEvalAuthoring;
+    const runner = yield* EvalSetupRunner;
+    const paths = yield* Path.Path;
+    const loadHost = (repositoryRoot, profileId) => Effect.tryPromise({
+        try: () => loadHostMetadata(repositoryRoot, profileId),
+        catch: (cause) => new EvalSetupTransitionError({
+            stage: "absent",
+            detail: cause instanceof Error ? cause.message : String(cause)
+        })
+    });
+    const persist = (metadata) => Effect.tryPromise({
+        try: () => saveHostMetadata(metadata),
+        catch: (cause) => new EvalSetupTransitionError({
+            stage: metadata.lastResult === undefined ? "prepared" : "unknown",
+            detail: cause instanceof Error ? cause.message : String(cause)
+        })
+    });
+    const prepare = (repositoryRoot, profileId, options) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const now = yield* isoNow;
+        const existing = yield* loadHost(root, profileId);
+        const description = options?.description?.trim();
+        const host = existing ??
+            initialHostMetadata({
+                profileId,
+                repositoryRoot: root,
+                now,
+                ...(description === undefined || description.length === 0
+                    ? {}
+                    : { description: description.slice(0, 1_024) })
+            });
+        const result = yield* authoring.withAuthoring({ profileId, repositoryRoot: root }, (api) => api.prepare({
+            existing: existing === undefined
+                ? undefined
+                : existing.lastResult?.status === "completed" &&
+                    existing.scratchWorkspace === undefined &&
+                    (!Array.isArray(existing.lastResult.evalRuns) ||
+                        existing.lastResult.evalRuns.length === 0)
+                    ? "archive"
+                    : "resume",
+            repository: root,
+            request: authoringRequest(profileId, host.objective)
+        }));
+        const next = mergeHost(host, result, now);
+        yield* persist(next);
+        return { ...statusOf(next, result), events: eventsFor(next, result) };
+    });
+    const status = (repositoryRoot, profileId) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = yield* loadHost(root, profileId);
+        if (host === undefined)
+            return undefined;
+        if (host.runDirectory === undefined)
+            return statusOf(host);
+        const result = yield* authoring.withAuthoring({ profileId, repositoryRoot: root }, (api) => api.status({ runDirectory: host.runDirectory, repository: root }));
+        const next = mergeHost(host, result, yield* isoNow);
+        yield* persist(next);
+        return statusOf(next, result);
+    });
+    const answer = (repositoryRoot, profileId, answerText) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = requireHost(yield* loadHost(root, profileId), profileId);
+        const current = requireResult(host, "setup has no Ori run to answer; call prepare then run");
+        if (current.status === "completed") {
+            return yield* new EvalSetupTransitionError({
+                stage: "completed",
+                detail: "setup is already completed"
+            });
+        }
+        if (answerText.trim().length === 0) {
+            return yield* new EvalSetupTransitionError({
+                stage: stageFromResult(current, "waiting"),
+                detail: "an answer must not be empty"
+            });
+        }
+        const result = yield* authoring.withAuthoring({ profileId, repositoryRoot: root }, (api) => api.answer({
+            answer: answerText,
+            repository: root,
+            ...(host.runDirectory === undefined ? {} : { runDirectory: host.runDirectory })
+        }));
+        const next = mergeHost(host, result, yield* isoNow, answerText.trim());
+        yield* persist(next);
+        return { ...statusOf(next, result), events: eventsFor(next, result) };
+    });
+    const validate = (repositoryRoot, profileId) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = requireHost(yield* loadHost(root, profileId), profileId);
+        const result = requireResult(host, "validation uses Ori's dry-run after an artifact exists");
+        yield* runner.validate(result);
+        return { ...statusOf(host, result), events: [] };
+    });
+    const estimate = (repositoryRoot, profileId, mode) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = requireHost(yield* loadHost(root, profileId), profileId);
+        return yield* runner.estimate(requireResult(host, "estimates require an authored eval manifest"), mode ?? "pilot");
+    });
+    const runApproved = (repositoryRoot, profileId) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = requireHost(yield* loadHost(root, profileId), profileId);
+        if (host.lastResult?.status === "completed" &&
+            Array.isArray(host.lastResult.evalRuns) &&
+            host.lastResult.evalRuns.length > 0) {
+            return yield* new EvalSetupTransitionError({
+                stage: "completed",
+                detail: "the Ori run is already completed"
+            });
+        }
+        if (host.lastResult?.status === "waiting") {
+            return yield* new EvalSetupTransitionError({
+                stage: stageFromResult(host.lastResult, "waiting"),
+                detail: "the run is waiting for a user answer; use eval answer"
+            });
+        }
+        const result = yield* authoring.withAuthoring({ profileId, repositoryRoot: root }, (api) => api.run({
+            repository: root,
+            ...(host.runDirectory === undefined ? {} : { runDirectory: host.runDirectory })
+        }));
+        const next = mergeHost(host, result, yield* isoNow);
+        yield* persist(next);
+        return { ...statusOf(next, result), events: eventsFor(next, result) };
+    });
+    const publishApproved = (repositoryRoot, profileId) => Effect.gen(function* () {
+        const root = paths.resolve(repositoryRoot);
+        const host = requireHost(yield* loadHost(root, profileId), profileId);
+        const result = requireResult(host, "publication requires a completed Ori run");
+        if (result.status !== "completed" ||
+            result.ok !== true ||
+            !Array.isArray(result.evalRuns) ||
+            result.evalRuns.length === 0) {
+            return yield* new EvalSetupTransitionError({
+                stage: stageFromResult(result, "unknown"),
+                detail: "publication requires a successful completed Ori run with eval evidence"
+            });
+        }
+        const published = yield* runner.publish({
+            profileId,
+            description: host.description ?? `${profileId} routing profile`,
+            repositoryRoot: root,
+            objective: host.objective,
+            result
+        });
+        const next = {
+            ...host,
+            publishApproved: true,
+            revision: host.revision + 1,
+            updatedAt: yield* isoNow
+        };
+        yield* persist(next);
+        return {
+            ...statusOf(next, result),
+            comparison: published.comparison,
+            activation: published.activation,
+            events: [
+                { type: "publish-approved", profileId },
+                { type: "completed", profileId }
+            ]
+        };
+    });
+    return EvalSetup.of({
+        prepare,
+        status,
+        answer,
+        validate,
+        estimate,
+        runApproved,
+        publishApproved
+    });
+});
+export const EvalSetupLive = Layer.effect(EvalSetup, makeEvalSetup);
+export { EVAL_SETUP_VERSION };

package/dist/state-store.d.ts

@@ -0,0 +1,21 @@
+import { type EvalSetupState } from "@velum-labs/routekit-eval-contracts";
+import { Context, Effect, FileSystem, Layer, Path } from "effect";
+import { EvalSetupStateError } from "./errors.js";
+import type { EvalSetupRunCheckpoint } from "./types.js";
+export type EvalSetupStateStoreShape = {
+    readonly load: (repositoryRoot: string, profileId: string) => Effect.Effect<EvalSetupState | undefined, EvalSetupStateError>;
+    readonly save: (state: EvalSetupState) => Effect.Effect<void, EvalSetupStateError>;
+    readonly loadRun: (repositoryRoot: string, profileId: string) => Effect.Effect<EvalSetupRunCheckpoint | undefined, EvalSetupStateError>;
+    readonly saveRun: (repositoryRoot: string, profileId: string, checkpoint: EvalSetupRunCheckpoint) => Effect.Effect<void, EvalSetupStateError>;
+};
+declare const EvalSetupStateStore_base: Context.ServiceClass<EvalSetupStateStore, "@velum-labs/routekit-eval-setup/EvalSetupStateStore", EvalSetupStateStoreShape>;
+export declare class EvalSetupStateStore extends EvalSetupStateStore_base {
+}
+export declare const makeFileEvalSetupStateStore: Effect.Effect<EvalSetupStateStoreShape, never, Path.Path | FileSystem.FileSystem>;
+export declare const EvalSetupStateStoreLive: Layer.Layer<EvalSetupStateStore, never, Path.Path | FileSystem.FileSystem>;
+export declare const initialSetupState: (input: {
+    readonly profileId: string;
+    readonly repositoryRoot: string;
+    readonly now: string;
+}) => EvalSetupState;
+export {};

package/dist/state-store.js

@@ -0,0 +1,86 @@
+import { EVAL_SETUP_VERSION, EvalComparisonResult, EvalSetupState as EvalSetupStateSchema, PublishedRoutingActivation } from "@velum-labs/routekit-eval-contracts";
+import { Context, Effect, FileSystem, Layer, Path, Schema } from "effect";
+import { EvalSetupStateError } from "./errors.js";
+const EvalSetupRunCheckpointSchema = Schema.Struct({
+    comparison: EvalComparisonResult,
+    activation: PublishedRoutingActivation
+});
+export class EvalSetupStateStore extends Context.Service()("@velum-labs/routekit-eval-setup/EvalSetupStateStore") {
+}
+const safeProfileId = (profileId) => /^[a-z0-9](?:[a-z0-9-]{0,62})$/u.test(profileId);
+const setupDirectory = (paths, root, profileId) => paths.join(root, ".routekit", "eval-setup", profileId);
+const statePath = (paths, root, profileId) => paths.join(setupDirectory(paths, root, profileId), "state.json");
+const runPath = (paths, root, profileId) => paths.join(setupDirectory(paths, root, profileId), "run.json");
+const stateFailure = (operation, cause) => new EvalSetupStateError({
+    operation,
+    detail: cause instanceof Error ? cause.message : String(cause),
+    cause
+});
+const validateProfileId = (profileId) => safeProfileId(profileId)
+    ? Effect.void
+    : Effect.fail(new EvalSetupStateError({
+        operation: "resolving setup state",
+        detail: `invalid profile id ${JSON.stringify(profileId)}`
+    }));
+export const makeFileEvalSetupStateStore = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const paths = yield* Path.Path;
+    const loadDocument = (target, decode) => Effect.gen(function* () {
+        if (!(yield* fs
+            .exists(target)
+            .pipe(Effect.mapError((cause) => stateFailure("checking setup document", cause))))) {
+            return undefined;
+        }
+        const raw = yield* fs
+            .readFileString(target)
+            .pipe(Effect.mapError((cause) => stateFailure("reading setup document", cause)));
+        const json = yield* Effect.try({
+            try: () => JSON.parse(raw),
+            catch: (cause) => stateFailure("parsing setup document", cause)
+        });
+        return yield* decode(json).pipe(Effect.mapError((cause) => stateFailure("decoding setup document", cause)));
+    });
+    const saveDocument = (target, value, revision) => Effect.gen(function* () {
+        const directory = paths.dirname(target);
+        const temporary = paths.join(directory, `setup.${revision}.${crypto.randomUUID()}.tmp`);
+        yield* fs
+            .makeDirectory(directory, { recursive: true, mode: 0o700 })
+            .pipe(Effect.mapError((cause) => stateFailure("creating setup state directory", cause)));
+        yield* Effect.ensuring(Effect.gen(function* () {
+            yield* fs
+                .writeFileString(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
+                .pipe(Effect.mapError((cause) => stateFailure("writing setup document", cause)));
+            yield* fs
+                .rename(temporary, target)
+                .pipe(Effect.mapError((cause) => stateFailure("committing setup document", cause)));
+        }), fs.remove(temporary, { force: true }).pipe(Effect.ignore));
+    });
+    return EvalSetupStateStore.of({
+        load: (repositoryRoot, profileId) => Effect.gen(function* () {
+            yield* validateProfileId(profileId);
+            return yield* loadDocument(statePath(paths, repositoryRoot, profileId), Schema.decodeUnknownEffect(EvalSetupStateSchema));
+        }),
+        save: (state) => Effect.gen(function* () {
+            yield* validateProfileId(state.profileId);
+            yield* saveDocument(statePath(paths, state.repositoryRoot, state.profileId), state, state.revision);
+        }),
+        loadRun: (repositoryRoot, profileId) => Effect.gen(function* () {
+            yield* validateProfileId(profileId);
+            return yield* loadDocument(runPath(paths, repositoryRoot, profileId), Schema.decodeUnknownEffect(EvalSetupRunCheckpointSchema));
+        }),
+        saveRun: (repositoryRoot, profileId, checkpoint) => Effect.gen(function* () {
+            yield* validateProfileId(profileId);
+            yield* saveDocument(runPath(paths, repositoryRoot, profileId), checkpoint, checkpoint.comparison.comparisonId);
+        })
+    });
+});
+export const EvalSetupStateStoreLive = Layer.effect(EvalSetupStateStore, makeFileEvalSetupStateStore);
+export const initialSetupState = (input) => ({
+    version: EVAL_SETUP_VERSION,
+    profileId: input.profileId,
+    repositoryRoot: input.repositoryRoot,
+    stage: "surface",
+    revision: 0,
+    updatedAt: input.now,
+    answers: {}
+});

package/dist/test/inspection.test.d.ts

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

package/dist/test/inspection.test.js

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { after, test } from "node:test";
+import { layer as NodeServicesLayer } from "@effect/platform-node/NodeServices";
+import { Effect } from "effect";
+import { inspectRepository } from "../inspection.js";
+const roots = [];
+after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
+test("repository inspection finds model surfaces and useful material without build trees", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-eval-setup-inspect-"));
+    roots.push(root);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await mkdir(path.join(root, "test", "fixtures"), { recursive: true });
+    await mkdir(path.join(root, "node_modules", "ignored"), { recursive: true });
+    await writeFile(path.join(root, "src", "support.ts"), 'client.responses.create({ model: "openai/gpt-test" });\n');
+    await writeFile(path.join(root, "src", "system-prompt.md"), "Be accurate.\n");
+    await writeFile(path.join(root, "test", "fixtures", "cases.json"), "[]\n");
+    await writeFile(path.join(root, "node_modules", "ignored", "model.ts"), "model = 'bad/id'\n");
+    const inspection = await Effect.runPromise(inspectRepository(root).pipe(Effect.provide(NodeServicesLayer)));
+    assert.equal(inspection.surfaces.length, 1);
+    assert.equal(inspection.surfaces[0]?.path, "src/support.ts");
+    assert.equal(inspection.surfaces[0]?.model, "openai/gpt-test");
+    assert.equal(inspection.materials.some((item) => item.path === "src/system-prompt.md"), true);
+    assert.equal(inspection.materials.some((item) => item.path.includes("node_modules")), false);
+    assert.equal(inspection.summary.filesRead, 3);
+    assert.equal(inspection.summary.truncated, false);
+});
+test("repository inspection skips oversized files and symlinks that escape the repository", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-eval-setup-bounds-"));
+    const outside = await mkdtemp(path.join(os.tmpdir(), "routekit-eval-setup-outside-"));
+    roots.push(root, outside);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, "src", "oversized.ts"), `client.responses.create({ model: "openai/oversized" });${"x".repeat(300_000)}`);
+    await writeFile(path.join(outside, "secret.ts"), 'client.responses.create({ model: "openai/outside" });\n');
+    await symlink(outside, path.join(root, "src", "outside-link"));
+    const inspection = await Effect.runPromise(inspectRepository(root).pipe(Effect.provide(NodeServicesLayer)));
+    assert.equal(inspection.surfaces.length, 0);
+    assert.equal(inspection.summary.skippedOversizedFiles, 1);
+    assert.equal(inspection.summary.filesRead, 0);
+    assert.equal(inspection.summary.truncated, false);
+});
+test("repository inspection ranks README docs and skips test-file model surfaces", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-eval-setup-docs-"));
+    roots.push(root);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await mkdir(path.join(root, "docs"), { recursive: true });
+    await writeFile(path.join(root, "README.md"), "# RouteKit\n\nOne gateway.\n");
+    await writeFile(path.join(root, "docs", "guide.md"), "# Guide\n");
+    await writeFile(path.join(root, "src", "foo.test.ts"), 'client.responses.create({ model: "openai/hidden" });\n');
+    await writeFile(path.join(root, "src", "support.ts"), 'client.responses.create({ model: "openai/gpt-test" });\n');
+    const inspection = await Effect.runPromise(inspectRepository(root).pipe(Effect.provide(NodeServicesLayer)));
+    assert.equal(inspection.materials[0]?.path, "README.md");
+    assert.equal(inspection.materials[0]?.kind, "doc");
+    assert.equal(inspection.materials.some((item) => item.path === "docs/guide.md" && item.kind === "doc"), true);
+    assert.equal(inspection.surfaces.some((item) => item.path.includes("foo.test.ts")), false);
+    assert.equal(inspection.surfaces[0]?.path, "src/support.ts");
+});
+test("repository inspection synthesizes a docs surface when only README remains", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "routekit-eval-setup-readme-only-"));
+    roots.push(root);
+    await mkdir(path.join(root, "src"), { recursive: true });
+    await writeFile(path.join(root, "README.md"), "# RouteKit\n");
+    await writeFile(path.join(root, "src", "foo.test.ts"), 'client.responses.create({ model: "openai/hidden" });\n');
+    const inspection = await Effect.runPromise(inspectRepository(root).pipe(Effect.provide(NodeServicesLayer)));
+    assert.deepEqual(inspection.surfaces, [{ name: "repository-docs", path: "README.md" }]);
+});

package/dist/test/model-selection.test.d.ts

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

package/dist/test/model-selection.test.js

@@ -0,0 +1,15 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { modelSelectionFromAnswer } from "../model-selection.js";
+test("model selection accepts exactly two candidates followed by a distinct judge", () => {
+    assert.deepEqual(modelSelectionFromAnswer("openai/gpt-a anthropic/claude-b google/gemini-judge"), {
+        candidates: ["openai/gpt-a", "anthropic/claude-b"],
+        judgeModel: "google/gemini-judge"
+    });
+});
+test("model selection rejects canned answers, duplicates, aliases, and extra ids", () => {
+    assert.throws(() => modelSelectionFromAnswer("Current model, a cheaper candidate, and a stronger candidate"), /exactly three explicit provider\/model ids/iu);
+    assert.throws(() => modelSelectionFromAnswer("openai/a openai/a openai/judge"), /three unique model ids/iu);
+    assert.throws(() => modelSelectionFromAnswer("openai/a anthropic/b routekit/auto"), /concrete provider\/model id/iu);
+    assert.throws(() => modelSelectionFromAnswer("openai/a anthropic/b google/judge mistral/extra"), /exactly three explicit provider\/model ids/iu);
+});

package/dist/test/project-authoring.test.d.ts

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