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

package/dist/adapters/typescript-repository-index.d.ts

@@ -0,0 +1,51 @@
+import { Effect } from "effect";
+import { RepositoryFoundryError } from "../errors.js";
+import type { RepositoryCommandRecipeV1, RepositoryPackageNodeV1, RepositoryProtocolNodeV1, RepositoryPublicSurfaceV1 } from "../repository-behavior-protocol.js";
+import { type GitTreeSnapshotV1 } from "./git-task-history.js";
+export type TypeScriptRepositoryIndexV1 = {
+    readonly packages: readonly RepositoryPackageNodeV1[];
+    readonly publicSurfaces: readonly RepositoryPublicSurfaceV1[];
+    readonly protocols: readonly RepositoryProtocolNodeV1[];
+    readonly commands: readonly RepositoryCommandRecipeV1[];
+    readonly excludedPackageRoots: readonly string[];
+};
+export type TypeScriptWorkspaceManifestSelectionV1 = {
+    readonly selectedManifestPaths: readonly string[];
+    readonly excludedPackageRoots: readonly string[];
+};
+export declare const selectTypeScriptWorkspaceManifestPathsV1: (snapshot: GitTreeSnapshotV1) => Effect.Effect<{
+    selectedManifestPaths: string[];
+    excludedPackageRoots: string[];
+}, RepositoryFoundryError, never>;
+export declare const indexTypeScriptRepositoryV1: (snapshot: GitTreeSnapshotV1) => Effect.Effect<{
+    packages: {
+        readonly id: string;
+        readonly name: string;
+        readonly path: string;
+        readonly manifestPath: string;
+        readonly dependencyPackageIds: readonly string[];
+        readonly publicExports: readonly string[];
+    }[];
+    publicSurfaces: {
+        readonly kind: "package-export" | "cli-command" | "http-endpoint" | "documented-example";
+        readonly id: string;
+        readonly path: string;
+        readonly symbols: readonly string[];
+        readonly packageId?: string | undefined;
+    }[];
+    protocols: {
+        readonly id: string;
+        readonly path: string;
+        readonly name: string;
+        readonly kind: "schema" | "wire" | "persistence" | "internal-boundary";
+    }[];
+    commands: {
+        readonly id: string;
+        readonly kind: "schema" | "test" | "build" | "check" | "custom";
+        readonly cwd: string;
+        readonly executable: string;
+        readonly args: readonly string[];
+        readonly timeoutMs: number;
+    }[];
+    excludedPackageRoots: string[];
+}, RepositoryFoundryError, never>;

package/dist/adapters/typescript-repository-index.js

@@ -0,0 +1,226 @@
+import { matchesGlob } from "node:path";
+import { Effect } from "effect";
+import { parse } from "yaml";
+import { RepositoryFoundryError } from "../errors.js";
+import { readGitTreeFileV1 } from "./git-task-history.js";
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "index-repository",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const stableId = (prefix, value) => `${prefix}-${value
+    .toLowerCase()
+    .replace(/^@/u, "")
+    .replace(/[^a-z0-9]+/gu, "-")
+    .replace(/^-|-$/gu, "")}`;
+const uniqueStableId = (prefix, value, used) => {
+    const base = stableId(prefix, value);
+    let id = base;
+    let suffix = 2;
+    while (used.has(id)) {
+        id = `${base}-${String(suffix)}`;
+        suffix += 1;
+    }
+    used.add(id);
+    return id;
+};
+const packagePath = (manifestPath) => manifestPath === "package.json"
+    ? "."
+    : manifestPath.slice(0, -"/package.json".length);
+const pathWithinRoot = (path, root) => path === root || path.startsWith(`${root}/`);
+const stringArray = (value) => Array.isArray(value)
+    ? value.filter((entry) => typeof entry === "string")
+    : [];
+const workspacePatterns = (snapshot, content) => Effect.try({
+    try: () => {
+        const document = parse(content);
+        if (document === null || typeof document !== "object")
+            return [];
+        return stringArray(document.packages)
+            .map((pattern) => pattern.trim().replace(/^\.\//u, ""))
+            .filter((pattern) => pattern.length > 0);
+    },
+    catch: (cause) => failure(`workspace manifest is invalid YAML: ${snapshot.requestedRef}:pnpm-workspace.yaml`, cause)
+});
+const matchesWorkspace = (root, patterns) => {
+    const positive = patterns.filter((pattern) => !pattern.startsWith("!"));
+    if (positive.length === 0)
+        return false;
+    const included = positive.some((pattern) => matchesGlob(root, pattern));
+    if (!included)
+        return false;
+    return !patterns
+        .filter((pattern) => pattern.startsWith("!"))
+        .some((pattern) => matchesGlob(root, pattern.slice(1)));
+};
+const exportKeys = (value) => {
+    if (typeof value === "string" || Array.isArray(value))
+        return ["."];
+    if (value === null || typeof value !== "object")
+        return [];
+    return Object.keys(value).sort();
+};
+const sourceEntryPath = (snapshot, root) => {
+    for (const candidate of [
+        root === "." ? "src/index.ts" : `${root}/src/index.ts`,
+        root === "." ? "src/index.js" : `${root}/src/index.js`,
+        root === "." ? "index.ts" : `${root}/index.ts`
+    ]) {
+        if (snapshot.files.includes(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+const exportedSymbols = (content) => [
+    ...new Set([...content.matchAll(/\bexport\s+(?:declare\s+)?(?:const|class|function|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gu)]
+        .map((match) => match[1])
+        .filter((value) => value !== undefined))
+].sort();
+export const selectTypeScriptWorkspaceManifestPathsV1 = Effect.fn("RepositoryFoundry.selectTypeScriptWorkspaceManifestPaths")(function* (snapshot) {
+    const manifests = snapshot.files.filter((path) => path === "package.json" || path.endsWith("/package.json"));
+    const patterns = snapshot.files.includes("pnpm-workspace.yaml")
+        ? yield* workspacePatterns(snapshot, yield* readGitTreeFileV1({
+            snapshot,
+            path: "pnpm-workspace.yaml"
+        }))
+        : [];
+    const selectedManifestPaths = patterns.length === 0
+        ? manifests
+        : manifests.filter((path) => {
+            const root = packagePath(path);
+            return root === "." || matchesWorkspace(root, patterns);
+        });
+    const selectedManifestPathSet = new Set(selectedManifestPaths);
+    const excludedPackageRoots = manifests
+        .filter((path) => path !== "package.json" && !selectedManifestPathSet.has(path))
+        .map(packagePath)
+        .filter((root, index, roots) => !roots.some((candidate, candidateIndex) => candidateIndex !== index &&
+        candidate.length < root.length &&
+        pathWithinRoot(root, candidate)))
+        .sort();
+    return {
+        selectedManifestPaths,
+        excludedPackageRoots
+    };
+});
+export const indexTypeScriptRepositoryV1 = Effect.fn("RepositoryFoundry.indexTypeScriptRepository")(function* (snapshot) {
+    const { selectedManifestPaths, excludedPackageRoots } = yield* selectTypeScriptWorkspaceManifestPathsV1(snapshot);
+    const parsed = [];
+    for (const path of selectedManifestPaths) {
+        const content = yield* readGitTreeFileV1({ snapshot, path });
+        const value = yield* Effect.try({
+            try: () => JSON.parse(content),
+            catch: (cause) => failure(`package manifest is invalid JSON: ${path}`, cause)
+        });
+        parsed.push({ path, root: packagePath(path), value });
+    }
+    const byName = new Map();
+    for (const manifest of parsed) {
+        const name = typeof manifest.value.name === "string"
+            ? manifest.value.name
+            : manifest.root === "."
+                ? "repository-root"
+                : manifest.root;
+        byName.set(name, stableId("package", name));
+    }
+    const packages = [];
+    const publicSurfaces = [];
+    const commands = [];
+    const publicSurfaceIds = new Set();
+    for (const manifest of parsed) {
+        const name = typeof manifest.value.name === "string"
+            ? manifest.value.name
+            : manifest.root === "."
+                ? "repository-root"
+                : manifest.root;
+        const id = stableId("package", name);
+        const dependencies = [
+            manifest.value.dependencies,
+            manifest.value.devDependencies,
+            manifest.value.peerDependencies,
+            manifest.value.optionalDependencies
+        ]
+            .flatMap((value) => value !== null && typeof value === "object"
+            ? Object.keys(value)
+            : [])
+            .filter((dependency) => byName.has(dependency))
+            .map((dependency) => byName.get(dependency))
+            .filter((dependencyId, index, values) => values.indexOf(dependencyId) === index)
+            .sort();
+        const publicExports = exportKeys(manifest.value.exports);
+        packages.push({
+            id,
+            name,
+            path: manifest.root,
+            manifestPath: manifest.path,
+            dependencyPackageIds: dependencies,
+            publicExports
+        });
+        const entryPath = sourceEntryPath(snapshot, manifest.root);
+        const symbols = entryPath === undefined
+            ? []
+            : exportedSymbols(yield* readGitTreeFileV1({ snapshot, path: entryPath }));
+        for (const exported of publicExports) {
+            publicSurfaces.push({
+                id: uniqueStableId("surface", `${name}-${exported}`, publicSurfaceIds),
+                packageId: id,
+                path: entryPath ?? manifest.path,
+                kind: "package-export",
+                symbols
+            });
+        }
+        const scripts = manifest.value.scripts !== null &&
+            typeof manifest.value.scripts === "object"
+            ? manifest.value.scripts
+            : {};
+        for (const scriptName of ["build", "test", "check"]) {
+            if (typeof scripts[scriptName] !== "string")
+                continue;
+            commands.push({
+                id: stableId("command", `${name}-${scriptName}`),
+                kind: scriptName,
+                cwd: manifest.root,
+                executable: "corepack",
+                args: ["pnpm", "run", scriptName],
+                timeoutMs: scriptName === "test" ? 120_000 : 180_000
+            });
+        }
+    }
+    const protocolPaths = snapshot.files.filter((path) => {
+        if (excludedPackageRoots.some((root) => pathWithinRoot(path, root))) {
+            return false;
+        }
+        const lower = path.toLowerCase();
+        return (/\.(?:[cm]?[jt]sx?|json)$/u.test(lower) &&
+            /(?:protocol|schema|contract)/u.test(lower.split("/").at(-1) ?? lower));
+    });
+    const protocols = [];
+    const protocolIds = new Set();
+    for (const path of protocolPaths) {
+        const content = yield* readGitTreeFileV1({ snapshot, path });
+        const names = exportedSymbols(content);
+        const base = path.split("/").at(-1) ?? path;
+        const kind = /schema/u.test(base.toLowerCase())
+            ? "schema"
+            : /persist|store/u.test(path.toLowerCase())
+                ? "persistence"
+                : /(?:http|wire|response|request|control)/u.test(path.toLowerCase())
+                    ? "wire"
+                    : "internal-boundary";
+        for (const name of names.length > 0 ? names : [base]) {
+            protocols.push({
+                id: uniqueStableId("protocol", `${path}-${name}`, protocolIds),
+                path,
+                name,
+                kind
+            });
+        }
+    }
+    return {
+        packages: packages.sort((left, right) => left.id.localeCompare(right.id)),
+        publicSurfaces: publicSurfaces.sort((left, right) => left.id.localeCompare(right.id)),
+        protocols: protocols.sort((left, right) => left.id.localeCompare(right.id)),
+        commands: commands.sort((left, right) => left.id.localeCompare(right.id)),
+        excludedPackageRoots
+    };
+});