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

package/dist/repository-behavior-protocol.d.ts

@@ -0,0 +1,188 @@
+import { Schema } from "effect";
+export declare const RepositoryEvidenceKindV1: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+export type RepositoryEvidenceKindV1 = typeof RepositoryEvidenceKindV1.Type;
+export declare const RepositoryEvidenceRefV1: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["package", "public-surface", "symbol", "protocol", "schema", "test", "command", "history-episode", "workload-signal", "documentation"]>;
+    readonly id: Schema.String;
+    readonly path: Schema.optionalKey<Schema.String>;
+}>;
+export type RepositoryEvidenceRefV1 = typeof RepositoryEvidenceRefV1.Type;
+export declare const RepositoryCommandRecipeV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+    readonly cwd: Schema.String;
+    readonly executable: Schema.String;
+    readonly args: Schema.$Array<Schema.String>;
+    readonly timeoutMs: Schema.Finite;
+}>;
+export type RepositoryCommandRecipeV1 = typeof RepositoryCommandRecipeV1.Type;
+export declare const RepositoryPackageNodeV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly manifestPath: Schema.String;
+    readonly dependencyPackageIds: Schema.$Array<Schema.String>;
+    readonly publicExports: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryPackageNodeV1 = typeof RepositoryPackageNodeV1.Type;
+export declare const RepositoryPublicSurfaceV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly packageId: Schema.optionalKey<Schema.String>;
+    readonly path: Schema.String;
+    readonly kind: Schema.Literals<readonly ["package-export", "cli-command", "http-endpoint", "documented-example"]>;
+    readonly symbols: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryPublicSurfaceV1 = typeof RepositoryPublicSurfaceV1.Type;
+export declare const RepositoryProtocolNodeV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly path: Schema.String;
+    readonly name: Schema.String;
+    readonly kind: Schema.Literals<readonly ["wire", "schema", "persistence", "internal-boundary"]>;
+}>;
+export type RepositoryProtocolNodeV1 = typeof RepositoryProtocolNodeV1.Type;
+export declare const RepositoryTestNodeV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly path: Schema.String;
+    readonly names: Schema.$Array<Schema.String>;
+    readonly commandIds: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryTestNodeV1 = typeof RepositoryTestNodeV1.Type;
+export declare const RepositoryTestBindingV1: Schema.Struct<{
+    readonly testId: Schema.String;
+    readonly targetIds: Schema.$Array<Schema.String>;
+    readonly signals: Schema.$Array<Schema.Literals<readonly ["direct-import", "symbol-reference", "fixture-reference", "package-ownership", "git-cochange", "coverage", "reviewed-hypothesis"]>>;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "hypothesis"]>;
+}>;
+export type RepositoryTestBindingV1 = typeof RepositoryTestBindingV1.Type;
+export declare const RepositoryChangedPathV1: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly previousPath: Schema.optionalKey<Schema.String>;
+    readonly status: Schema.Literals<readonly ["added", "modified", "deleted", "renamed", "copied"]>;
+    readonly kind: Schema.Literals<readonly ["implementation", "test", "protocol", "schema", "documentation", "operational", "other"]>;
+}>;
+export type RepositoryChangedPathV1 = typeof RepositoryChangedPathV1.Type;
+export declare const RepositoryChangeEpisodeV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly commit: Schema.String;
+    readonly parentCommit: Schema.optionalKey<Schema.String>;
+    readonly occurredAt: Schema.String;
+    readonly subject: Schema.String;
+    readonly body: Schema.String;
+    readonly changedPaths: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly previousPath: Schema.optionalKey<Schema.String>;
+        readonly status: Schema.Literals<readonly ["added", "modified", "deleted", "renamed", "copied"]>;
+        readonly kind: Schema.Literals<readonly ["implementation", "test", "protocol", "schema", "documentation", "operational", "other"]>;
+    }>>;
+    readonly testPaths: Schema.$Array<Schema.String>;
+    readonly implementationPaths: Schema.$Array<Schema.String>;
+    readonly protocolPaths: Schema.$Array<Schema.String>;
+    readonly behaviorChanging: Schema.Boolean;
+    readonly seedEligible: Schema.Boolean;
+}>;
+export type RepositoryChangeEpisodeV1 = typeof RepositoryChangeEpisodeV1.Type;
+export declare const RepositoryWorkloadSignalV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["recurring-cochange", "recurring-behavior-change", "recurring-command", "public-contract", "reviewed-critical"]>;
+    readonly label: Schema.String;
+    readonly episodeIds: Schema.$Array<Schema.String>;
+    readonly pathPatterns: Schema.$Array<Schema.String>;
+    readonly frequency: Schema.Finite;
+    readonly importance: Schema.Literals<readonly ["normal", "high", "critical"]>;
+    readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+}>;
+export type RepositoryWorkloadSignalV1 = typeof RepositoryWorkloadSignalV1.Type;
+export declare const RepositoryBlindSpotV1: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["unmapped-test", "unreconstructible-command", "unsupported-language", "external-service", "history-gap", "unknown-relationship"]>;
+    readonly detail: Schema.String;
+    readonly paths: Schema.$Array<Schema.String>;
+}>;
+export type RepositoryBlindSpotV1 = typeof RepositoryBlindSpotV1.Type;
+export declare const RepositoryBehaviorMapV1: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly repository: Schema.Struct<{
+        readonly root: Schema.String;
+        readonly requestedRef: Schema.String;
+        readonly commit: Schema.String;
+        readonly tree: Schema.String;
+    }>;
+    readonly packages: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly path: Schema.String;
+        readonly manifestPath: Schema.String;
+        readonly dependencyPackageIds: Schema.$Array<Schema.String>;
+        readonly publicExports: Schema.$Array<Schema.String>;
+    }>>;
+    readonly publicSurfaces: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly packageId: Schema.optionalKey<Schema.String>;
+        readonly path: Schema.String;
+        readonly kind: Schema.Literals<readonly ["package-export", "cli-command", "http-endpoint", "documented-example"]>;
+        readonly symbols: Schema.$Array<Schema.String>;
+    }>>;
+    readonly protocols: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly path: Schema.String;
+        readonly name: Schema.String;
+        readonly kind: Schema.Literals<readonly ["wire", "schema", "persistence", "internal-boundary"]>;
+    }>>;
+    readonly commands: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["build", "test", "check", "schema", "custom"]>;
+        readonly cwd: Schema.String;
+        readonly executable: Schema.String;
+        readonly args: Schema.$Array<Schema.String>;
+        readonly timeoutMs: Schema.Finite;
+    }>>;
+    readonly tests: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly path: Schema.String;
+        readonly names: Schema.$Array<Schema.String>;
+        readonly commandIds: Schema.$Array<Schema.String>;
+    }>>;
+    readonly testBindings: Schema.$Array<Schema.Struct<{
+        readonly testId: Schema.String;
+        readonly targetIds: Schema.$Array<Schema.String>;
+        readonly signals: Schema.$Array<Schema.Literals<readonly ["direct-import", "symbol-reference", "fixture-reference", "package-ownership", "git-cochange", "coverage", "reviewed-hypothesis"]>>;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "hypothesis"]>;
+    }>>;
+    readonly historyEpisodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly commit: Schema.String;
+        readonly parentCommit: Schema.optionalKey<Schema.String>;
+        readonly occurredAt: Schema.String;
+        readonly subject: Schema.String;
+        readonly body: Schema.String;
+        readonly changedPaths: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.String;
+            readonly previousPath: Schema.optionalKey<Schema.String>;
+            readonly status: Schema.Literals<readonly ["added", "modified", "deleted", "renamed", "copied"]>;
+            readonly kind: Schema.Literals<readonly ["implementation", "test", "protocol", "schema", "documentation", "operational", "other"]>;
+        }>>;
+        readonly testPaths: Schema.$Array<Schema.String>;
+        readonly implementationPaths: Schema.$Array<Schema.String>;
+        readonly protocolPaths: Schema.$Array<Schema.String>;
+        readonly behaviorChanging: Schema.Boolean;
+        readonly seedEligible: Schema.Boolean;
+    }>>;
+    readonly workloadSignals: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["recurring-cochange", "recurring-behavior-change", "recurring-command", "public-contract", "reviewed-critical"]>;
+        readonly label: Schema.String;
+        readonly episodeIds: Schema.$Array<Schema.String>;
+        readonly pathPatterns: Schema.$Array<Schema.String>;
+        readonly frequency: Schema.Finite;
+        readonly importance: Schema.Literals<readonly ["normal", "high", "critical"]>;
+        readonly confidence: Schema.Literals<readonly ["high", "medium", "review-required"]>;
+    }>>;
+    readonly blindSpots: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["unmapped-test", "unreconstructible-command", "unsupported-language", "external-service", "history-gap", "unknown-relationship"]>;
+        readonly detail: Schema.String;
+        readonly paths: Schema.$Array<Schema.String>;
+    }>>;
+}>;
+export type RepositoryBehaviorMapV1 = typeof RepositoryBehaviorMapV1.Type;
+export declare function assertRepositoryBehaviorMapV1(value: unknown): asserts value is RepositoryBehaviorMapV1;

package/dist/repository-behavior-protocol.js

@@ -0,0 +1,202 @@
+import { Schema } from "effect";
+const NonNegativeInteger = Schema.Finite.pipe(Schema.check(Schema.makeFilter((value) => Number.isInteger(value) && value >= 0
+    ? undefined
+    : "value must be a non-negative integer")));
+export const RepositoryEvidenceKindV1 = Schema.Literals([
+    "package",
+    "public-surface",
+    "symbol",
+    "protocol",
+    "schema",
+    "test",
+    "command",
+    "history-episode",
+    "workload-signal",
+    "documentation"
+]);
+export const RepositoryEvidenceRefV1 = Schema.Struct({
+    kind: RepositoryEvidenceKindV1,
+    id: Schema.String,
+    path: Schema.optionalKey(Schema.String)
+});
+export const RepositoryCommandRecipeV1 = Schema.Struct({
+    id: Schema.String,
+    kind: Schema.Literals(["build", "test", "check", "schema", "custom"]),
+    cwd: Schema.String,
+    executable: Schema.String,
+    args: Schema.Array(Schema.String),
+    timeoutMs: NonNegativeInteger
+});
+export const RepositoryPackageNodeV1 = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    path: Schema.String,
+    manifestPath: Schema.String,
+    dependencyPackageIds: Schema.Array(Schema.String),
+    publicExports: Schema.Array(Schema.String)
+});
+export const RepositoryPublicSurfaceV1 = Schema.Struct({
+    id: Schema.String,
+    packageId: Schema.optionalKey(Schema.String),
+    path: Schema.String,
+    kind: Schema.Literals([
+        "package-export",
+        "cli-command",
+        "http-endpoint",
+        "documented-example"
+    ]),
+    symbols: Schema.Array(Schema.String)
+});
+export const RepositoryProtocolNodeV1 = Schema.Struct({
+    id: Schema.String,
+    path: Schema.String,
+    name: Schema.String,
+    kind: Schema.Literals(["wire", "schema", "persistence", "internal-boundary"])
+});
+export const RepositoryTestNodeV1 = Schema.Struct({
+    id: Schema.String,
+    path: Schema.String,
+    names: Schema.Array(Schema.String),
+    commandIds: Schema.Array(Schema.String)
+});
+export const RepositoryTestBindingV1 = Schema.Struct({
+    testId: Schema.String,
+    targetIds: Schema.Array(Schema.String),
+    signals: Schema.Array(Schema.Literals([
+        "direct-import",
+        "symbol-reference",
+        "fixture-reference",
+        "package-ownership",
+        "git-cochange",
+        "coverage",
+        "reviewed-hypothesis"
+    ])),
+    confidence: Schema.Literals(["high", "medium", "hypothesis"])
+});
+export const RepositoryChangedPathV1 = Schema.Struct({
+    path: Schema.String,
+    previousPath: Schema.optionalKey(Schema.String),
+    status: Schema.Literals(["added", "modified", "deleted", "renamed", "copied"]),
+    kind: Schema.Literals([
+        "implementation",
+        "test",
+        "protocol",
+        "schema",
+        "documentation",
+        "operational",
+        "other"
+    ])
+});
+export const RepositoryChangeEpisodeV1 = Schema.Struct({
+    id: Schema.String,
+    commit: Schema.String,
+    parentCommit: Schema.optionalKey(Schema.String),
+    occurredAt: Schema.String,
+    subject: Schema.String,
+    body: Schema.String,
+    changedPaths: Schema.Array(RepositoryChangedPathV1),
+    testPaths: Schema.Array(Schema.String),
+    implementationPaths: Schema.Array(Schema.String),
+    protocolPaths: Schema.Array(Schema.String),
+    behaviorChanging: Schema.Boolean,
+    seedEligible: Schema.Boolean
+});
+export const RepositoryWorkloadSignalV1 = Schema.Struct({
+    id: Schema.String,
+    kind: Schema.Literals([
+        "recurring-cochange",
+        "recurring-behavior-change",
+        "recurring-command",
+        "public-contract",
+        "reviewed-critical"
+    ]),
+    label: Schema.String,
+    episodeIds: Schema.Array(Schema.String),
+    pathPatterns: Schema.Array(Schema.String),
+    frequency: NonNegativeInteger,
+    importance: Schema.Literals(["normal", "high", "critical"]),
+    confidence: Schema.Literals(["high", "medium", "review-required"])
+});
+export const RepositoryBlindSpotV1 = Schema.Struct({
+    id: Schema.String,
+    kind: Schema.Literals([
+        "unmapped-test",
+        "unreconstructible-command",
+        "unsupported-language",
+        "external-service",
+        "history-gap",
+        "unknown-relationship"
+    ]),
+    detail: Schema.String,
+    paths: Schema.Array(Schema.String)
+});
+export const RepositoryBehaviorMapV1 = Schema.Struct({
+    version: Schema.Literal(1),
+    repository: Schema.Struct({
+        root: Schema.String,
+        requestedRef: Schema.String,
+        commit: Schema.String,
+        tree: Schema.String
+    }),
+    packages: Schema.Array(RepositoryPackageNodeV1),
+    publicSurfaces: Schema.Array(RepositoryPublicSurfaceV1),
+    protocols: Schema.Array(RepositoryProtocolNodeV1),
+    commands: Schema.Array(RepositoryCommandRecipeV1),
+    tests: Schema.Array(RepositoryTestNodeV1),
+    testBindings: Schema.Array(RepositoryTestBindingV1),
+    historyEpisodes: Schema.Array(RepositoryChangeEpisodeV1),
+    workloadSignals: Schema.Array(RepositoryWorkloadSignalV1),
+    blindSpots: Schema.Array(RepositoryBlindSpotV1)
+});
+const uniqueIds = (values, label) => {
+    if (values.some((value) => value.id.trim().length === 0) ||
+        new Set(values.map((value) => value.id)).size !== values.length) {
+        throw new Error(`${label} ids must be non-empty and unique`);
+    }
+};
+export function assertRepositoryBehaviorMapV1(value) {
+    const map = Schema.decodeUnknownSync(RepositoryBehaviorMapV1)(value);
+    uniqueIds(map.packages, "repository package");
+    uniqueIds(map.publicSurfaces, "repository public surface");
+    uniqueIds(map.protocols, "repository protocol");
+    uniqueIds(map.commands, "repository command");
+    uniqueIds(map.tests, "repository test");
+    uniqueIds(map.historyEpisodes, "repository history episode");
+    uniqueIds(map.workloadSignals, "repository workload signal");
+    uniqueIds(map.blindSpots, "repository blind spot");
+    const packageIds = new Set(map.packages.map((entry) => entry.id));
+    for (const entry of map.packages) {
+        if (entry.dependencyPackageIds.some((dependencyId) => !packageIds.has(dependencyId))) {
+            throw new Error(`repository package ${JSON.stringify(entry.id)} refers to an unknown package`);
+        }
+    }
+    const commandIds = new Set(map.commands.map((entry) => entry.id));
+    const testIds = new Set(map.tests.map((entry) => entry.id));
+    const targetIds = new Set([
+        ...map.packages.map((entry) => entry.id),
+        ...map.publicSurfaces.map((entry) => entry.id),
+        ...map.protocols.map((entry) => entry.id)
+    ]);
+    for (const test of map.tests) {
+        if (test.commandIds.some((commandId) => !commandIds.has(commandId))) {
+            throw new Error(`repository test ${JSON.stringify(test.id)} refers to an unknown command`);
+        }
+    }
+    for (const binding of map.testBindings) {
+        if (!testIds.has(binding.testId)) {
+            throw new Error(`repository test binding refers to unknown test ${JSON.stringify(binding.testId)}`);
+        }
+        if (binding.targetIds.length === 0 ||
+            binding.targetIds.some((targetId) => !targetIds.has(targetId))) {
+            throw new Error(`repository test binding for ${JSON.stringify(binding.testId)} has an unknown target`);
+        }
+    }
+    const episodeIds = new Set(map.historyEpisodes.map((entry) => entry.id));
+    for (const signal of map.workloadSignals) {
+        if (signal.frequency !== signal.episodeIds.length ||
+            signal.episodeIds.length === 0 ||
+            signal.episodeIds.some((episodeId) => !episodeIds.has(episodeId))) {
+            throw new Error(`repository workload signal ${JSON.stringify(signal.id)} has invalid episode evidence`);
+        }
+    }
+}