@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/repository-trajectory-protocol.js

@@ -0,0 +1,42 @@
+import { Schema } from "effect";
+export const RepositoryTrajectoryPolicyV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    caseId: Schema.String,
+    purpose: Schema.Literal("routing-signal"),
+    validationRecipeIds: Schema.Array(Schema.String),
+    protectedPaths: Schema.Array(Schema.String),
+    thresholds: Schema.Struct({
+        maximumToolCalls: Schema.Finite,
+        maximumFailedToolCalls: Schema.Finite,
+        maximumRepeatedFailedActions: Schema.Finite
+    }),
+    requirements: Schema.Struct({
+        passingValidationAfterLastMutation: Schema.Boolean,
+        noProtectedPathMutations: Schema.Boolean
+    }),
+    rationale: Schema.String
+});
+export function assertRepositoryTrajectoryPolicyV1(value) {
+    const policy = Schema.decodeUnknownSync(RepositoryTrajectoryPolicyV1)(value);
+    const { maximumToolCalls, maximumFailedToolCalls, maximumRepeatedFailedActions } = policy.thresholds;
+    if (policy.caseId.trim().length === 0 ||
+        policy.rationale.trim().length < 40 ||
+        policy.validationRecipeIds.length === 0 ||
+        new Set(policy.validationRecipeIds).size !== policy.validationRecipeIds.length ||
+        new Set(policy.protectedPaths).size !== policy.protectedPaths.length ||
+        policy.validationRecipeIds.some((id) => id.trim().length === 0) ||
+        policy.protectedPaths.some((path) => path.trim().length === 0) ||
+        !Number.isSafeInteger(maximumToolCalls) ||
+        !Number.isSafeInteger(maximumFailedToolCalls) ||
+        !Number.isSafeInteger(maximumRepeatedFailedActions) ||
+        maximumToolCalls < 16 ||
+        maximumToolCalls > 200 ||
+        maximumFailedToolCalls < 4 ||
+        maximumFailedToolCalls > Math.min(50, maximumToolCalls) ||
+        maximumRepeatedFailedActions < 2 ||
+        maximumRepeatedFailedActions > Math.min(10, maximumFailedToolCalls) ||
+        !policy.requirements.passingValidationAfterLastMutation ||
+        !policy.requirements.noProtectedPathMutations) {
+        throw new Error("repository trajectory policy requires bounded integer thresholds, post-mutation validation, protected-path discipline, and a substantive rationale");
+    }
+}

package/dist/service.js

@@ -98,7 +98,7 @@ const requireHost = (host, profileId) => {
 const requireResult = (host, detail) => {
     if (host.lastResult === undefined) {
         throw new EvalSetupTransitionError({
-            stage: host.lastResult === undefined ? "prepared" : stageFromResult(host.lastResult, "unknown"),
+            stage: "prepared",
             detail
         });
     }

package/dist/services/adversary/service.d.ts

@@ -0,0 +1,64 @@
+import { Context, Effect, Layer } from "effect";
+import { type RepositoryAdversaryGenerationReportV1 } from "../../repository-adversary-protocol.js";
+import type { RepositoryCommandRecipeV1 } from "../../repository-behavior-protocol.js";
+import type { RepositoryTaskSeedV1 } from "../../repository-task-seed-protocol.js";
+import type { RepositoryExecutableSolutionV1 } from "../oracle-builder/service.js";
+export declare const repositoryIntegrationMutationFamilyV1: (path: string) => string;
+export type AdversaryShape = {
+    readonly generateDeterministic: (input: {
+        readonly repositoryRoot: string;
+        readonly seed: RepositoryTaskSeedV1;
+        readonly validationRecipe: RepositoryCommandRecipeV1;
+        readonly repetitions?: number;
+    }) => Effect.Effect<RepositoryAdversaryGenerationResultV1, import("../../errors.js").RepositoryFoundryError>;
+};
+export type RepositoryAdversaryGenerationResultV1 = {
+    readonly report: RepositoryAdversaryGenerationReportV1;
+    readonly solutions: readonly RepositoryExecutableSolutionV1[];
+};
+declare const Adversary_base: Context.ServiceClass<Adversary, "@velum-labs/routekit-eval-setup/Adversary", AdversaryShape>;
+export declare class Adversary extends Adversary_base {
+}
+export declare const generateDeterministicAdversariesV1: (input: {
+    readonly repositoryRoot: string;
+    readonly seed: RepositoryTaskSeedV1;
+    readonly validationRecipe: RepositoryCommandRecipeV1;
+    readonly repetitions?: number;
+}) => Effect.Effect<{
+    report: {
+        readonly version: 1;
+        readonly seedId: string;
+        readonly generationCoverage: {
+            readonly implementationPathCount: number;
+            readonly changedPathCount: number;
+            readonly generatedCrossFileCandidateCount: number;
+            readonly omittedCrossFileCandidateCount: number;
+        };
+        readonly candidates: readonly {
+            readonly version: 1;
+            readonly id: string;
+            readonly solutionId: string;
+            readonly family: string;
+            readonly operator: "condition-negation" | "boundary-operator" | "partial-output-drop" | "cross-file-omission";
+            readonly sourcePath: string;
+            readonly relatedPaths: readonly string[];
+            readonly sourceCommit: string;
+            readonly originalSnippet: string;
+            readonly mutatedSnippet: string;
+            readonly validationRecipeId: string;
+            readonly compilationStatus: "passed" | "failed";
+            readonly validationObservations: readonly {
+                readonly repetition: number;
+                readonly outcome: "pass" | "fail";
+                readonly detail: string;
+            }[];
+            readonly rejectionReasons: readonly string[];
+        }[];
+        readonly admittedCandidateIds: readonly string[];
+        readonly rejectedCandidateIds: readonly string[];
+    };
+    solutions: RepositoryExecutableSolutionV1[];
+}, import("../../errors.js").RepositoryFoundryError, never>;
+export declare const makeAdversary: Effect.Effect<AdversaryShape, never, never>;
+export declare const AdversaryLive: Layer.Layer<Adversary, never, never>;
+export {};

package/dist/services/adversary/service.js

@@ -0,0 +1,330 @@
+import { Context, Effect, Layer } from "effect";
+import { captureGitTreeSnapshotV1, readGitTreeFileV1 } from "../../adapters/git-task-history.js";
+import { replayRepositoryCommandV1 } from "../../adapters/repository-command-runner.js";
+import { assertRepositoryAdversaryGenerationReportV1 } from "../../repository-adversary-protocol.js";
+const MAX_CROSS_FILE_MUTATIONS = 12;
+const MAX_RELATED_PATHS = 16;
+const implementationPaths = (seed) => [
+    ...new Set(seed.capabilityEvidence
+        .filter((evidence) => (evidence.kind === "symbol" ||
+        evidence.kind === "protocol" ||
+        evidence.kind === "schema") &&
+        evidence.path !== undefined)
+        .map((evidence) => evidence.path))
+];
+const changedReferenceRanges = (initialContent, referenceContent) => {
+    if (initialContent === undefined) {
+        return [{ start: 0, end: referenceContent.length }];
+    }
+    const initialLineCounts = new Map();
+    for (const line of initialContent.split("\n")) {
+        initialLineCounts.set(line, (initialLineCounts.get(line) ?? 0) + 1);
+    }
+    const ranges = [];
+    let offset = 0;
+    for (const line of referenceContent.split("\n")) {
+        const remaining = initialLineCounts.get(line) ?? 0;
+        const end = offset + line.length;
+        if (remaining > 0) {
+            initialLineCounts.set(line, remaining - 1);
+        }
+        else {
+            ranges.push({ start: offset, end });
+        }
+        offset = end + 1;
+    }
+    return ranges;
+};
+const mutationCandidates = (path, content, eligibleRanges) => {
+    const candidates = [];
+    const eligible = (index, length) => eligibleRanges.some((range) => index < range.end && index + length > range.start);
+    const addFirstEligible = (pattern, operator, replacement) => {
+        const flags = pattern.flags.includes("g")
+            ? pattern.flags
+            : `${pattern.flags}g`;
+        const matcher = new RegExp(pattern.source, flags);
+        for (const match of content.matchAll(matcher)) {
+            if (match.index === undefined || !eligible(match.index, match[0].length)) {
+                continue;
+            }
+            const mutatedSnippet = replacement(match);
+            candidates.push({
+                operator,
+                originalSnippet: match[0],
+                mutatedSnippet,
+                content: content.slice(0, match.index) +
+                    mutatedSnippet +
+                    content.slice(match.index + match[0].length)
+            });
+            return;
+        }
+    };
+    addFirstEligible(/(?<![=!])===(?!=)/u, "condition-negation", () => "!==");
+    addFirstEligible(/(?<![<>])<=(?!=)/u, "boundary-operator", () => "<");
+    addFirstEligible(/\[\.\.\.[^,\]\n]+,\s*([A-Za-z_$][\w$]*)\]/u, "partial-output-drop", (match) => `[${match[1]}]`);
+    return candidates.map((candidate) => ({
+        ...candidate,
+        content: candidate.content.endsWith("\n")
+            ? candidate.content
+            : `${candidate.content}\n`
+    }));
+};
+export const repositoryIntegrationMutationFamilyV1 = (path) => {
+    const lower = path.toLowerCase();
+    const base = lower.split("/").at(-1) ?? lower;
+    if (/adapter/u.test(base) || /(^|\/)adapters?(\/|$)/u.test(lower)) {
+        return "adapter-change-omission";
+    }
+    if (/schema|protocol|contract/u.test(base)) {
+        return "schema-protocol-change-omission";
+    }
+    if (/(?:^|[._-])(?:index|facade|façade|exports?)(?:[._-]|$)/u.test(base)) {
+        return "facade-export-omission";
+    }
+    if (/reader|decode|parse|deserialize/u.test(base)) {
+        return "reader-change-omission";
+    }
+    if (/writer|encode|serialize|persist/u.test(base)) {
+        return "writer-change-omission";
+    }
+    if (/(?:cli|command|options?|flags?)/u.test(base) ||
+        /(^|\/)(?:cli|commands?)(\/|$)/u.test(lower)) {
+        return "cli-forwarding-change-omission";
+    }
+    if (/service/u.test(base) ||
+        /(^|\/)services?(\/|$)/u.test(lower)) {
+        return "service-change-omission";
+    }
+    return "cross-file-change-omission";
+};
+const crossFileFamily = (changed) => changed.referenceContent === undefined
+    ? "removed-path-resurrection"
+    : changed.initialContent === undefined
+        ? "new-path-deletion"
+        : repositoryIntegrationMutationFamilyV1(changed.path);
+const selectCrossFileMutations = (changedPaths) => {
+    if (changedPaths.length < 2)
+        return [];
+    const byFamily = new Map();
+    for (const changed of [...changedPaths].sort((left, right) => left.path.localeCompare(right.path))) {
+        const family = crossFileFamily(changed);
+        const members = byFamily.get(family) ?? [];
+        members.push(changed);
+        byFamily.set(family, members);
+    }
+    const selected = [];
+    const families = [...byFamily.keys()].sort();
+    for (let familyIndex = 0; selected.length < MAX_CROSS_FILE_MUTATIONS; familyIndex += 1) {
+        let added = false;
+        for (const family of families) {
+            const member = byFamily.get(family)?.[familyIndex];
+            if (member === undefined)
+                continue;
+            selected.push(member);
+            added = true;
+            if (selected.length === MAX_CROSS_FILE_MUTATIONS)
+                break;
+        }
+        if (!added)
+            break;
+    }
+    return selected;
+};
+const validateGeneratedMutationV1 = Effect.fn("Adversary.validateGeneratedMutation")(function* (input) {
+    const candidateId = `adversary-${input.mutation.operator}-${String(input.sequence)}`;
+    const solutionId = `mutation-${input.mutation.operator}-${String(input.sequence)}`;
+    const validation = yield* replayRepositoryCommandV1({
+        repositoryRoot: input.repositoryRoot,
+        commit: input.referenceCommit,
+        recipe: input.validationRecipe,
+        trustedPreparationRecipes: input.seed.environment.trustedPreparationRecipes,
+        candidateValidationRecipes: input.seed.environment.candidateValidationRecipes.filter((recipe) => recipe.id !== input.validationRecipe.id),
+        fileOverrides: input.mutation.fileOverrides,
+        repetitions: input.repetitions
+    });
+    const observations = validation.map((result) => ({
+        repetition: result.repetition,
+        outcome: result.gradeExecuted &&
+            result.exitCode === 0 &&
+            !result.timedOut
+            ? "pass"
+            : "fail",
+        detail: [
+            `exit=${String(result.exitCode)}`,
+            `timeout=${String(result.timedOut)}`,
+            `durationMs=${String(result.durationMs)}`,
+            ...(result.outputTruncated ? ["output=truncated"] : [])
+        ].join("; ")
+    }));
+    const compiled = observations.every((observation) => observation.outcome === "pass");
+    const candidate = {
+        version: 1,
+        id: candidateId,
+        solutionId,
+        family: input.mutation.family,
+        operator: input.mutation.operator,
+        sourcePath: input.mutation.sourcePath,
+        relatedPaths: [...input.mutation.relatedPaths],
+        sourceCommit: input.referenceCommit,
+        originalSnippet: input.mutation.originalSnippet,
+        mutatedSnippet: input.mutation.mutatedSnippet,
+        validationRecipeId: input.validationRecipe.id,
+        compilationStatus: compiled ? "passed" : "failed",
+        validationObservations: observations,
+        rejectionReasons: compiled
+            ? []
+            : ["mutation does not pass the reviewed build or check command"]
+    };
+    const solution = compiled
+        ? {
+            id: solutionId,
+            kind: "mutation",
+            family: input.mutation.family,
+            expectedClass: "wrong",
+            commit: input.referenceCommit,
+            fileOverrides: input.mutation.fileOverrides
+        }
+        : undefined;
+    return { candidate, solution };
+});
+export class Adversary extends Context.Service()("@velum-labs/routekit-eval-setup/Adversary") {
+}
+export const generateDeterministicAdversariesV1 = Effect.fn("Adversary.generateDeterministic")(function* (input) {
+    if (input.seed.referenceCommit === undefined) {
+        const report = {
+            version: 1,
+            seedId: input.seed.id,
+            generationCoverage: {
+                implementationPathCount: implementationPaths(input.seed).length,
+                changedPathCount: 0,
+                generatedCrossFileCandidateCount: 0,
+                omittedCrossFileCandidateCount: 0
+            },
+            candidates: [],
+            admittedCandidateIds: [],
+            rejectedCandidateIds: []
+        };
+        return {
+            report,
+            solutions: []
+        };
+    }
+    if (input.validationRecipe.kind !== "build" &&
+        input.validationRecipe.kind !== "check") {
+        throw new Error("deterministic adversary validation requires a reviewed build or check command");
+    }
+    const snapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.seed.referenceCommit
+    });
+    const initialSnapshot = yield* captureGitTreeSnapshotV1({
+        repositoryRoot: input.repositoryRoot,
+        requestedRef: input.seed.initialState.commit
+    });
+    const candidates = [];
+    const solutions = [];
+    for (const path of implementationPaths(input.seed)) {
+        if (!snapshot.files.includes(path))
+            continue;
+        const content = yield* readGitTreeFileV1({ snapshot, path });
+        const initialContent = initialSnapshot.files.includes(path)
+            ? yield* readGitTreeFileV1({ snapshot: initialSnapshot, path })
+            : undefined;
+        for (const mutation of mutationCandidates(path, content, changedReferenceRanges(initialContent, content))) {
+            const generated = yield* validateGeneratedMutationV1({
+                repositoryRoot: input.repositoryRoot,
+                referenceCommit: input.seed.referenceCommit,
+                seed: input.seed,
+                validationRecipe: input.validationRecipe,
+                repetitions: input.repetitions ?? 2,
+                sequence: candidates.length + 1,
+                mutation: {
+                    operator: mutation.operator,
+                    family: mutation.operator,
+                    sourcePath: path,
+                    relatedPaths: [],
+                    originalSnippet: mutation.originalSnippet,
+                    mutatedSnippet: mutation.mutatedSnippet,
+                    fileOverrides: [{ path, content: mutation.content }]
+                }
+            });
+            candidates.push(generated.candidate);
+            if (generated.solution !== undefined) {
+                solutions.push(generated.solution);
+            }
+        }
+    }
+    const changedPaths = [];
+    for (const path of implementationPaths(input.seed)) {
+        const referenceContent = snapshot.files.includes(path)
+            ? yield* readGitTreeFileV1({ snapshot, path })
+            : undefined;
+        const initialContent = initialSnapshot.files.includes(path)
+            ? yield* readGitTreeFileV1({ snapshot: initialSnapshot, path })
+            : undefined;
+        if (referenceContent !== initialContent) {
+            changedPaths.push({
+                path,
+                ...(referenceContent === undefined ? {} : { referenceContent }),
+                ...(initialContent === undefined ? {} : { initialContent })
+            });
+        }
+    }
+    const selectedCrossFilePaths = selectCrossFileMutations(changedPaths);
+    if (selectedCrossFilePaths.length > 0) {
+        for (const changed of selectedCrossFilePaths) {
+            const relatedPaths = changedPaths
+                .map((entry) => entry.path)
+                .filter((path) => path !== changed.path)
+                .sort()
+                .slice(0, MAX_RELATED_PATHS);
+            const fileOverrides = changed.initialContent === undefined
+                ? [{ path: changed.path, delete: true }]
+                : [{ path: changed.path, content: changed.initialContent }];
+            const generated = yield* validateGeneratedMutationV1({
+                repositoryRoot: input.repositoryRoot,
+                referenceCommit: input.seed.referenceCommit,
+                seed: input.seed,
+                validationRecipe: input.validationRecipe,
+                repetitions: input.repetitions ?? 2,
+                sequence: candidates.length + 1,
+                mutation: {
+                    operator: "cross-file-omission",
+                    family: crossFileFamily(changed),
+                    sourcePath: changed.path,
+                    relatedPaths,
+                    originalSnippet: changed.referenceContent ?? "<path absent>",
+                    mutatedSnippet: changed.initialContent ?? "<path deleted>",
+                    fileOverrides
+                }
+            });
+            candidates.push(generated.candidate);
+            if (generated.solution !== undefined) {
+                solutions.push(generated.solution);
+            }
+        }
+    }
+    const report = {
+        version: 1,
+        seedId: input.seed.id,
+        generationCoverage: {
+            implementationPathCount: implementationPaths(input.seed).length,
+            changedPathCount: changedPaths.length,
+            generatedCrossFileCandidateCount: selectedCrossFilePaths.length,
+            omittedCrossFileCandidateCount: changedPaths.length >= 2
+                ? changedPaths.length - selectedCrossFilePaths.length
+                : 0
+        },
+        candidates,
+        admittedCandidateIds: candidates
+            .filter((candidate) => candidate.compilationStatus === "passed")
+            .map((candidate) => candidate.id),
+        rejectedCandidateIds: candidates
+            .filter((candidate) => candidate.compilationStatus === "failed")
+            .map((candidate) => candidate.id)
+    };
+    assertRepositoryAdversaryGenerationReportV1(report);
+    return { report, solutions };
+});
+export const makeAdversary = Effect.succeed(Adversary.of({ generateDeterministic: generateDeterministicAdversariesV1 }));
+export const AdversaryLive = Layer.effect(Adversary, makeAdversary);