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

package/dist/services/repository-model/service.js

@@ -0,0 +1,250 @@
+import { Context, Effect, Layer } from "effect";
+import { captureGitTreeSnapshotV1, readGitChangeEpisodesV1 } from "../../adapters/git-task-history.js";
+import { discoverRepositoryTestsV1 } from "../../adapters/test-discovery.js";
+import { indexTypeScriptRepositoryV1 } from "../../adapters/typescript-repository-index.js";
+import { assertRepositoryBehaviorMapV1 } from "../../repository-behavior-protocol.js";
+const ownershipRoot = (path) => {
+    const parts = path.split("/");
+    if (parts.length >= 2 &&
+        (parts[0] === "packages" || parts[0] === "apps")) {
+        return parts.slice(0, 2).join("/");
+    }
+    return parts[0] ?? path;
+};
+const behaviorOwnershipRoots = (episode) => [
+    ...new Set(episode.changedPaths
+        .filter((entry) => entry.kind === "implementation" ||
+        entry.kind === "protocol" ||
+        entry.kind === "schema" ||
+        entry.kind === "test")
+        .map((entry) => ownershipRoot(entry.path)))
+].sort();
+const pathWithinRoot = (path, root) => path === root || path.startsWith(`${root}/`);
+const withoutExcludedPackageHistory = (episodes, excludedPackageRoots) => episodes.map((episode) => {
+    const changedPaths = episode.changedPaths.filter((entry) => !excludedPackageRoots.some((root) => pathWithinRoot(entry.path, root)));
+    const testPaths = changedPaths
+        .filter((entry) => entry.kind === "test")
+        .map((entry) => entry.path);
+    const implementationPaths = changedPaths
+        .filter((entry) => entry.kind === "implementation")
+        .map((entry) => entry.path);
+    const protocolPaths = changedPaths
+        .filter((entry) => entry.kind === "protocol" || entry.kind === "schema")
+        .map((entry) => entry.path);
+    const behaviorChanging = implementationPaths.length > 0 || protocolPaths.length > 0;
+    return {
+        ...episode,
+        changedPaths,
+        testPaths,
+        implementationPaths,
+        protocolPaths,
+        behaviorChanging,
+        seedEligible: behaviorChanging &&
+            testPaths.length > 0 &&
+            episode.parentCommit !== undefined
+    };
+});
+const recurringSignals = (episodes) => {
+    const clusters = new Map();
+    const intentOf = (subject) => {
+        const conventional = /^(fix|feat|refactor|perf|build)(?:\([^)]+\))?[!:]/iu.exec(subject);
+        const verb = conventional?.[1]?.toLowerCase() ??
+            /^(fix|repair|add|implement|refactor|optimi[sz]e|harden|prevent|preserve)\b/iu
+                .exec(subject)?.[1]
+                ?.toLowerCase();
+        if (verb === "fix" || verb === "repair" || verb === "harden" || verb === "prevent") {
+            return "repair";
+        }
+        if (verb === "feat" || verb === "add" || verb === "implement") {
+            return "feature";
+        }
+        if (verb === "perf" || verb === "optimize" || verb === "optimise") {
+            return "performance";
+        }
+        return verb === "build" ? "build" : "refactor";
+    };
+    const scopeOf = (episode) => {
+        const conventional = /^(?:fix|feat|refactor|perf|build)\(([^)]+)\)[!:]/iu.exec(episode.subject)?.[1];
+        if (conventional !== undefined) {
+            return conventional
+                .normalize("NFKC")
+                .toLowerCase()
+                .replace(/[^a-z0-9-]+/gu, "-")
+                .replace(/^-|-$/gu, "");
+        }
+        const roots = behaviorOwnershipRoots(episode);
+        return roots.length === 1
+            ? roots[0].replace(/^packages\//u, "").replace(/^apps\//u, "")
+            : roots.length >= 2 && roots.length <= 3
+                ? `cross-${roots
+                    .map((root) => root.replace(/^packages\//u, "").replace(/^apps\//u, ""))
+                    .join("-")}`
+                : undefined;
+    };
+    for (const episode of episodes.filter((entry) => entry.seedEligible)) {
+        const intent = intentOf(episode.subject);
+        const scope = scopeOf(episode);
+        if (scope === undefined)
+            continue;
+        const key = `${intent}:${scope}`;
+        const cluster = clusters.get(key) ?? { intent, scope, episodes: [] };
+        clusters.set(key, {
+            ...cluster,
+            episodes: [...cluster.episodes, episode]
+        });
+    }
+    return [...clusters.values()]
+        .filter((cluster) => cluster.episodes.length >= 2)
+        .sort((left, right) => right.episodes.length - left.episodes.length ||
+        left.intent.localeCompare(right.intent) ||
+        left.scope.localeCompare(right.scope))
+        .map((cluster, index) => {
+        const rootCounts = new Map();
+        for (const episode of cluster.episodes) {
+            for (const root of new Set(episode.changedPaths
+                .filter((entry) => entry.kind === "implementation" ||
+                entry.kind === "protocol" ||
+                entry.kind === "schema" ||
+                entry.kind === "test")
+                .map((entry) => ownershipRoot(entry.path)))) {
+                rootCounts.set(root, (rootCounts.get(root) ?? 0) + 1);
+            }
+        }
+        const minimumSupport = Math.ceil(cluster.episodes.length / 2);
+        const pathPatterns = [...rootCounts.entries()]
+            .filter(([, count]) => count >= minimumSupport)
+            .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]))
+            .slice(0, 6)
+            .map(([root]) => root);
+        const contractChanging = cluster.episodes.some((episode) => episode.changedPaths.some((path) => path.kind === "protocol" || path.kind === "schema"));
+        return {
+            id: `workload-recurring-${String(index + 1).padStart(3, "0")}`,
+            kind: "recurring-behavior-change",
+            label: `${cluster.intent} work in ${cluster.scope}`,
+            episodeIds: cluster.episodes.map((episode) => episode.id),
+            pathPatterns,
+            frequency: cluster.episodes.length,
+            importance: contractChanging || cluster.episodes.length >= 4
+                ? "high"
+                : "normal",
+            confidence: cluster.episodes.length >= 3
+                ? "high"
+                : "medium"
+        };
+    });
+};
+const recurringCochangeSignals = (episodes) => {
+    const clusters = new Map();
+    for (const episode of episodes.filter((entry) => entry.seedEligible)) {
+        const roots = behaviorOwnershipRoots(episode);
+        for (let left = 0; left < roots.length; left += 1) {
+            for (let right = left + 1; right < roots.length; right += 1) {
+                const pair = [roots[left], roots[right]];
+                const key = pair.join("\u0000");
+                const cluster = clusters.get(key);
+                clusters.set(key, {
+                    roots: pair,
+                    episodes: cluster === undefined
+                        ? [episode]
+                        : [...cluster.episodes, episode]
+                });
+            }
+        }
+    }
+    return [...clusters.values()]
+        .filter((cluster) => cluster.episodes.length >= 2)
+        .sort((left, right) => right.episodes.length - left.episodes.length ||
+        left.roots[0].localeCompare(right.roots[0]) ||
+        left.roots[1].localeCompare(right.roots[1]))
+        .map((cluster, index) => {
+        const contractChanging = cluster.episodes.some((episode) => episode.changedPaths.some((entry) => entry.kind === "protocol" || entry.kind === "schema"));
+        const labels = cluster.roots.map((root) => root.replace(/^packages\//u, "").replace(/^apps\//u, ""));
+        return {
+            id: `workload-cochange-${String(index + 1).padStart(3, "0")}`,
+            kind: "recurring-cochange",
+            label: `recurring cochange in ${labels[0]} and ${labels[1]}`,
+            episodeIds: cluster.episodes.map((episode) => episode.id),
+            pathPatterns: [...cluster.roots],
+            frequency: cluster.episodes.length,
+            importance: contractChanging || cluster.episodes.length >= 4
+                ? "high"
+                : "normal",
+            confidence: cluster.episodes.length >= 3
+                ? "high"
+                : "medium"
+        };
+    });
+};
+export class RepositoryModel extends Context.Service()("@velum-labs/routekit-eval-setup/RepositoryModel") {
+}
+export const buildRepositoryBehaviorMapV1 = Effect.fn("RepositoryModel.build")(function* (input) {
+    const snapshot = yield* captureGitTreeSnapshotV1(input);
+    const index = yield* indexTypeScriptRepositoryV1(snapshot);
+    const historyEpisodes = withoutExcludedPackageHistory(yield* readGitChangeEpisodesV1({
+        snapshot,
+        ...(input.maximumHistoryEpisodes === undefined
+            ? {}
+            : { maximumEpisodes: input.maximumHistoryEpisodes })
+    }), index.excludedPackageRoots);
+    const discovery = yield* discoverRepositoryTestsV1({
+        snapshot,
+        packages: index.packages,
+        publicSurfaces: index.publicSurfaces,
+        protocols: index.protocols,
+        commands: index.commands,
+        excludedPackageRoots: index.excludedPackageRoots
+    });
+    const blindSpots = [
+        ...(index.excludedPackageRoots.length === 0
+            ? []
+            : [
+                {
+                    id: "blind-excluded-package-roots",
+                    kind: "unknown-relationship",
+                    detail: "Package-like trees outside the declared pnpm workspace were excluded from automatic ownership and behavior inference.",
+                    paths: index.excludedPackageRoots
+                }
+            ]),
+        ...discovery.unmappedTestPaths.map((path, index) => ({
+            id: `blind-unmapped-test-${String(index + 1).padStart(3, "0")}`,
+            kind: "unmapped-test",
+            detail: "No evidence-backed production or package binding was found.",
+            paths: [path]
+        })),
+        ...(historyEpisodes.some((episode) => episode.seedEligible)
+            ? []
+            : [
+                {
+                    id: "blind-history-gap",
+                    kind: "history-gap",
+                    detail: "No non-merge historical episode combines behavior-changing code with a changed test.",
+                    paths: []
+                }
+            ])
+    ];
+    const map = {
+        version: 1,
+        repository: {
+            root: snapshot.root,
+            requestedRef: snapshot.requestedRef,
+            commit: snapshot.commit,
+            tree: snapshot.tree
+        },
+        packages: index.packages,
+        publicSurfaces: index.publicSurfaces,
+        protocols: index.protocols,
+        commands: index.commands,
+        tests: discovery.tests,
+        testBindings: discovery.testBindings,
+        historyEpisodes,
+        workloadSignals: [
+            ...recurringSignals(historyEpisodes),
+            ...recurringCochangeSignals(historyEpisodes)
+        ],
+        blindSpots
+    };
+    assertRepositoryBehaviorMapV1(map);
+    return map;
+});
+export const makeRepositoryModel = Effect.succeed(RepositoryModel.of({ build: buildRepositoryBehaviorMapV1 }));
+export const RepositoryModelLive = Layer.effect(RepositoryModel, makeRepositoryModel);

package/dist/services/repository-public-artifact/service.d.ts

@@ -0,0 +1,133 @@
+import { Schema } from "effect";
+import { type RepositoryCandidateVisibleTaskV1 as RepositoryCandidateVisibleTask } from "../../repository-benchmark-protocol.js";
+export declare const REPOSITORY_PUBLIC_ARTIFACT_PROJECTION_VERSION_V1: 1;
+export declare const RepositoryPublicArtifactQualityV1: Schema.Struct<{
+    readonly axis: Schema.Literals<readonly ["authenticity", "specification-sufficiency", "oracle-adequacy", "stability", "distinctness", "realism", "leakage", "triviality", "coverage"]>;
+    readonly outcome: Schema.Literals<readonly ["pass", "fail", "review-required"]>;
+}>;
+export type RepositoryPublicArtifactQualityV1 = typeof RepositoryPublicArtifactQualityV1.Type;
+export declare const RepositoryPublicArtifactTerminalCheckpointV1: Schema.Struct<{
+    readonly kind: Schema.Literal<"terminal">;
+    readonly stage: Schema.Literal<"admit">;
+    readonly createdAt: Schema.String;
+    readonly version: Schema.Literal<2>;
+    readonly checkpointId: Schema.String;
+    readonly identityDigest: Schema.String;
+    readonly attemptGeneration: Schema.Finite;
+    readonly sequence: Schema.Finite;
+    readonly loopName: Schema.optionalKey<Schema.String>;
+    readonly loopIteration: Schema.optionalKey<Schema.Finite>;
+    readonly parentDigest: Schema.String;
+    readonly payloadDigest: Schema.String;
+    readonly payloadBytes: Schema.Finite;
+}>;
+export type RepositoryPublicArtifactTerminalCheckpointV1 = typeof RepositoryPublicArtifactTerminalCheckpointV1.Type;
+export declare const RepositoryPublicArtifactInputV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly admitted: Schema.Literal<true>;
+    readonly caseId: Schema.String;
+    readonly capabilityId: Schema.String;
+    readonly familyId: Schema.String;
+    readonly lane: Schema.Literals<readonly ["request", "repository-agent"]>;
+    readonly visible: Schema.Union<readonly [Schema.Struct<{
+        readonly lane: Schema.Literal<"request">;
+        readonly id: Schema.String;
+        readonly request: Schema.Struct<{
+            readonly endpoint: Schema.Literals<readonly ["chat", "responses", "anthropic"]>;
+            readonly method: Schema.Literal<"POST">;
+            readonly path: Schema.String;
+            readonly headers: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly value: Schema.String;
+            }>>;
+            readonly bodyJson: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly lane: Schema.Literal<"repository-agent">;
+        readonly id: Schema.String;
+        readonly requestText: Schema.String;
+        readonly checkoutCommit: Schema.String;
+        readonly allowedTools: Schema.$Array<Schema.Literals<readonly ["read", "search", "edit", "shell", "test"]>>;
+        readonly constraints: Schema.$Array<Schema.String>;
+    }>]>;
+    readonly sourceCommitSha: Schema.String;
+    readonly coverageCellId: Schema.String;
+    readonly basisDigest: Schema.String;
+    readonly behavioralFingerprint: Schema.String;
+    readonly admissionDigest: Schema.String;
+    readonly terminalCheckpoint: Schema.Struct<{
+        readonly kind: Schema.Literal<"terminal">;
+        readonly stage: Schema.Literal<"admit">;
+        readonly createdAt: Schema.String;
+        readonly version: Schema.Literal<2>;
+        readonly checkpointId: Schema.String;
+        readonly identityDigest: Schema.String;
+        readonly attemptGeneration: Schema.Finite;
+        readonly sequence: Schema.Finite;
+        readonly loopName: Schema.optionalKey<Schema.String>;
+        readonly loopIteration: Schema.optionalKey<Schema.Finite>;
+        readonly parentDigest: Schema.String;
+        readonly payloadDigest: Schema.String;
+        readonly payloadBytes: Schema.Finite;
+    }>;
+    readonly quality: Schema.$Array<Schema.Struct<{
+        readonly axis: Schema.Literals<readonly ["authenticity", "specification-sufficiency", "oracle-adequacy", "stability", "distinctness", "realism", "leakage", "triviality", "coverage"]>;
+        readonly outcome: Schema.Literals<readonly ["pass", "fail", "review-required"]>;
+    }>>;
+}>;
+export type RepositoryPublicArtifactInputV1 = typeof RepositoryPublicArtifactInputV1.Type;
+export declare const repositoryPublicArtifactPathIdV1: (caseId: string) => string;
+export declare const RepositoryProjectedPublicArtifactV1: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly kind: Schema.Literals<readonly ["eval-definition", "public-metadata"]>;
+    readonly mediaType: Schema.Literal<"application/json">;
+    readonly content: Schema.String;
+    readonly caseId: Schema.String;
+    readonly admissionDigest: Schema.String;
+    readonly publicArtifactDigest: Schema.String;
+    readonly bytes: Schema.Finite;
+    readonly visibility: Schema.Literal<"public">;
+    readonly fileType: Schema.Literal<"regular">;
+}>;
+export type RepositoryProjectedPublicArtifactV1 = typeof RepositoryProjectedPublicArtifactV1.Type;
+export declare const repositoryPublicArtifactProjectionDigestV1: (projection: {
+    readonly version: 1;
+    readonly admitted: true;
+    readonly caseId: string;
+    readonly sourceCommitSha: string;
+    readonly admissionDigest: string;
+    readonly terminalCheckpointDigest: string;
+    readonly artifacts: readonly RepositoryProjectedPublicArtifactV1[];
+}) => string;
+export declare const RepositoryPublicArtifactProjectionV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly admitted: Schema.Literal<true>;
+    readonly caseId: Schema.String;
+    readonly sourceCommitSha: Schema.String;
+    readonly admissionDigest: Schema.String;
+    readonly terminalCheckpointDigest: Schema.String;
+    readonly projectionDigest: Schema.String;
+    readonly artifacts: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly kind: Schema.Literals<readonly ["eval-definition", "public-metadata"]>;
+        readonly mediaType: Schema.Literal<"application/json">;
+        readonly content: Schema.String;
+        readonly caseId: Schema.String;
+        readonly admissionDigest: Schema.String;
+        readonly publicArtifactDigest: Schema.String;
+        readonly bytes: Schema.Finite;
+        readonly visibility: Schema.Literal<"public">;
+        readonly fileType: Schema.Literal<"regular">;
+    }>>;
+}>;
+export type RepositoryPublicArtifactProjectionV1 = typeof RepositoryPublicArtifactProjectionV1.Type;
+export declare const decodeRepositoryPublicArtifactProjectionV1: (value: unknown) => RepositoryPublicArtifactProjectionV1;
+/**
+ * Creates the only repository-visible representation of an admitted case.
+ *
+ * The input is an explicit strict public DTO, not a foundry result. Hidden
+ * fixtures, oracle bodies, solutions, adversaries, responses, diagnostics,
+ * credentials, and checkpoint payloads therefore have no representable field.
+ */
+export declare const makeRepositoryPublicArtifactProjectionV1: (value: unknown) => RepositoryPublicArtifactProjectionV1;
+export declare const repositoryPublicArtifactVisibleTaskV1: (input: RepositoryPublicArtifactInputV1) => RepositoryCandidateVisibleTask;