@dailephd/my-dev-kit-lab 0.7.1 → 0.7.2

package/dist/src/evaluation/localRepositorySubject/config.js

@@ -0,0 +1,296 @@
+import { validateAnswerKey, validateTaskLocality } from "../benchmarkMetadata.js";
+import { LOCAL_REPOSITORY_SUBJECT_CASE_FIELDS, LOCAL_REPOSITORY_SUBJECT_CONFIG_FIELDS, LOCAL_REPOSITORY_SUBJECT_CONFIG_SCHEMA_VERSION, LOCAL_REPOSITORY_SUBJECT_LIMITS, LocalRepositorySubjectConfigError, compareCodeUnits, } from "./types.js";
+const SUBJECT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const REQUIRED_CASE_FIELDS = ["id", "title", "sourceRoots", "query", "expectedFiles", "expectedSymbols", "rawIncludeGlobs"];
+const OPTIONAL_STRING_FIELDS = ["promptComplexityHint", "projectComplexityRelevance", "notes"];
+// eslint-disable-next-line no-control-regex
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u001f\u007f]/;
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function describeValue(value) {
+    if (typeof value === "string") {
+        return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}...` : value);
+    }
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value === null)
+        return "null";
+    if (Array.isArray(value))
+        return "array";
+    return typeof value;
+}
+/**
+ * Canonicalizes a platform-portable repository-relative logical path (or glob) to forward-slash form.
+ * Rejects absolute, drive-qualified, UNC, backslash, traversal, and empty-segment forms. Returns null on rejection.
+ */
+export function canonicalizeRepositoryRelativePath(value, label, errors, options) {
+    if (typeof value !== "string") {
+        errors.push(`${label}: must be a string (received ${describeValue(value)}).`);
+        return null;
+    }
+    if (value.length === 0 || value.trim().length === 0) {
+        errors.push(`${label}: must not be empty.`);
+        return null;
+    }
+    if (CONTROL_CHARACTER_PATTERN.test(value)) {
+        errors.push(`${label}: must not contain control characters.`);
+        return null;
+    }
+    if (value.includes("\\")) {
+        errors.push(`${label}: must use "/" separators, not backslashes (received ${describeValue(value)}).`);
+        return null;
+    }
+    if (value.startsWith("/")) {
+        errors.push(`${label}: must be repository-relative, not absolute or UNC (received ${describeValue(value)}).`);
+        return null;
+    }
+    if (/^[A-Za-z]:/.test(value)) {
+        errors.push(`${label}: must not be drive-qualified (received ${describeValue(value)}).`);
+        return null;
+    }
+    const segments = value.split("/");
+    const kept = [];
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment === "..") {
+            errors.push(`${label}: must not contain parent traversal (received ${describeValue(value)}).`);
+            return null;
+        }
+        if (segment === "") {
+            if (index === segments.length - 1 && index > 0)
+                continue; // single trailing slash
+            errors.push(`${label}: must not contain empty path segments (received ${describeValue(value)}).`);
+            return null;
+        }
+        if (segment === ".")
+            continue;
+        kept.push(segment);
+    }
+    if (kept.length === 0) {
+        if (options.allowDot)
+            return ".";
+        errors.push(`${label}: must name a path below the repository root (received ${describeValue(value)}).`);
+        return null;
+    }
+    return kept.join("/");
+}
+function validateSubjectId(value, errors) {
+    if (typeof value !== "string") {
+        errors.push(`config.subjectId: must be a string (received ${describeValue(value)}).`);
+        return false;
+    }
+    const max = LOCAL_REPOSITORY_SUBJECT_LIMITS.subjectIdMaxLength;
+    if (value.length < 1 || value.length > max) {
+        errors.push(`config.subjectId: length must be between 1 and ${max}.`);
+        return false;
+    }
+    if (!SUBJECT_ID_PATTERN.test(value)) {
+        errors.push(`config.subjectId: must begin with an ASCII letter or digit and contain only ASCII letters, digits, ".", "_" and "-" (received ${describeValue(value)}).`);
+        return false;
+    }
+    return true;
+}
+function validateStringArray(value, label, errors, options) {
+    if (!Array.isArray(value)) {
+        errors.push(`${label}: must be an array (received ${describeValue(value)}).`);
+        return null;
+    }
+    if (options.nonEmptyArray && value.length === 0) {
+        errors.push(`${label}: must not be empty.`);
+        return null;
+    }
+    let ok = true;
+    const strings = [];
+    value.forEach((entry, index) => {
+        if (typeof entry !== "string" || entry.trim().length === 0) {
+            errors.push(`${label}[${index}]: must be a non-empty string (received ${describeValue(entry)}).`);
+            ok = false;
+        }
+        else {
+            strings.push(entry);
+        }
+    });
+    return ok ? strings : null;
+}
+function validatePathArray(value, label, errors, options) {
+    if (!Array.isArray(value)) {
+        errors.push(`${label}: must be an array (received ${describeValue(value)}).`);
+        return null;
+    }
+    if (value.length === 0) {
+        errors.push(`${label}: must not be empty.`);
+        return null;
+    }
+    let ok = true;
+    const canonical = [];
+    value.forEach((entry, index) => {
+        const path = canonicalizeRepositoryRelativePath(entry, `${label}[${index}]`, errors, options);
+        if (path === null) {
+            ok = false;
+        }
+        else if (!canonical.includes(path)) {
+            canonical.push(path);
+        }
+    });
+    return ok ? canonical : null;
+}
+function validateCase(value, index, seenIds, errors) {
+    const label = `config.cases[${index}]`;
+    if (!isPlainObject(value)) {
+        errors.push(`${label}: must be an object (received ${describeValue(value)}).`);
+        return null;
+    }
+    const before = errors.length;
+    const allowed = new Set(LOCAL_REPOSITORY_SUBJECT_CASE_FIELDS);
+    for (const key of Object.keys(value).sort(compareCodeUnits)) {
+        if (!allowed.has(key))
+            errors.push(`${label}: unknown field ${JSON.stringify(key)}.`);
+    }
+    for (const field of REQUIRED_CASE_FIELDS) {
+        if (!hasOwn(value, field))
+            errors.push(`${label}: missing required field ${field}.`);
+    }
+    let id = null;
+    if (hasOwn(value, "id")) {
+        const rawId = value.id;
+        if (typeof rawId !== "string" || rawId.length < 1 || rawId.length > LOCAL_REPOSITORY_SUBJECT_LIMITS.subjectIdMaxLength) {
+            errors.push(`${label}.id: must be a string of length 1 to ${LOCAL_REPOSITORY_SUBJECT_LIMITS.subjectIdMaxLength} (received ${describeValue(rawId)}).`);
+        }
+        else if (!SUBJECT_ID_PATTERN.test(rawId)) {
+            errors.push(`${label}.id: must begin with an ASCII letter or digit and contain only ASCII letters, digits, ".", "_" and "-" (received ${describeValue(rawId)}).`);
+        }
+        else if (seenIds.has(rawId)) {
+            errors.push(`${label}.id: duplicate case id ${JSON.stringify(rawId)}.`);
+        }
+        else {
+            seenIds.add(rawId);
+            id = rawId;
+        }
+    }
+    for (const field of ["title", "query"]) {
+        if (hasOwn(value, field) && (typeof value[field] !== "string" || value[field].trim().length === 0)) {
+            errors.push(`${label}.${field}: must be a non-empty string (received ${describeValue(value[field])}).`);
+        }
+    }
+    const sourceRoots = hasOwn(value, "sourceRoots")
+        ? validatePathArray(value.sourceRoots, `${label}.sourceRoots`, errors, { allowDot: true })
+        : null;
+    const expectedFiles = hasOwn(value, "expectedFiles")
+        ? validatePathArray(value.expectedFiles, `${label}.expectedFiles`, errors, { allowDot: false })
+        : null;
+    const expectedSymbols = hasOwn(value, "expectedSymbols")
+        ? validateStringArray(value.expectedSymbols, `${label}.expectedSymbols`, errors, { nonEmptyArray: false })
+        : null;
+    const rawIncludeGlobs = hasOwn(value, "rawIncludeGlobs")
+        ? validatePathArray(value.rawIncludeGlobs, `${label}.rawIncludeGlobs`, errors, { allowDot: false })
+        : null;
+    if (hasOwn(value, "taskLocality"))
+        errors.push(...validateTaskLocality(value.taskLocality, `${label}`));
+    if (hasOwn(value, "answerKey"))
+        errors.push(...validateAnswerKey(value.answerKey, `${label}`));
+    if (hasOwn(value, "expectedFacts")) {
+        const facts = value.expectedFacts;
+        if (!Array.isArray(facts)) {
+            errors.push(`${label}.expectedFacts: must be an array (received ${describeValue(facts)}).`);
+        }
+        else {
+            facts.forEach((fact, factIndex) => {
+                if (!isPlainObject(fact))
+                    errors.push(`${label}.expectedFacts[${factIndex}]: must be an object.`);
+            });
+        }
+    }
+    for (const field of OPTIONAL_STRING_FIELDS) {
+        if (hasOwn(value, field) && typeof value[field] !== "string") {
+            errors.push(`${label}.${field}: must be a string (received ${describeValue(value[field])}).`);
+        }
+    }
+    if (errors.length > before || id === null || sourceRoots === null || expectedFiles === null || expectedSymbols === null || rawIncludeGlobs === null) {
+        return null;
+    }
+    const result = {
+        id,
+        title: value.title,
+        sourceRoots,
+        query: value.query,
+        expectedFiles,
+        expectedSymbols: [...expectedSymbols],
+        rawIncludeGlobs,
+    };
+    if (hasOwn(value, "answerKey"))
+        result.answerKey = structuredClone(value.answerKey);
+    if (hasOwn(value, "expectedFacts"))
+        result.expectedFacts = structuredClone(value.expectedFacts);
+    if (hasOwn(value, "taskLocality"))
+        result.taskLocality = value.taskLocality;
+    for (const field of OPTIONAL_STRING_FIELDS) {
+        if (hasOwn(value, field))
+            result[field] = value[field];
+    }
+    return result;
+}
+/** Pure, strict validation of a LocalRepositorySubjectConfigV1 input. No filesystem or Git access. */
+export function validateLocalRepositorySubjectConfig(input) {
+    const errors = [];
+    if (!isPlainObject(input)) {
+        return { ok: false, errors: [`config: must be an object (received ${describeValue(input)}).`] };
+    }
+    const allowed = new Set(LOCAL_REPOSITORY_SUBJECT_CONFIG_FIELDS);
+    for (const key of Object.keys(input).sort(compareCodeUnits)) {
+        if (!allowed.has(key))
+            errors.push(`config: unknown field ${JSON.stringify(key)}.`);
+    }
+    if (!hasOwn(input, "schemaVersion")) {
+        errors.push("config: missing required field schemaVersion.");
+    }
+    else if (input.schemaVersion !== LOCAL_REPOSITORY_SUBJECT_CONFIG_SCHEMA_VERSION) {
+        errors.push(`config.schemaVersion: must be ${JSON.stringify(LOCAL_REPOSITORY_SUBJECT_CONFIG_SCHEMA_VERSION)} (received ${describeValue(input.schemaVersion)}).`);
+    }
+    let subjectId = null;
+    if (!hasOwn(input, "subjectId")) {
+        errors.push("config: missing required field subjectId.");
+    }
+    else if (validateSubjectId(input.subjectId, errors)) {
+        subjectId = input.subjectId;
+    }
+    const cases = [];
+    if (!hasOwn(input, "cases")) {
+        errors.push("config: missing required field cases.");
+    }
+    else if (!Array.isArray(input.cases)) {
+        errors.push(`config.cases: must be an array (received ${describeValue(input.cases)}).`);
+    }
+    else if (input.cases.length === 0) {
+        errors.push("config.cases: must not be empty.");
+    }
+    else {
+        const seenIds = new Set();
+        input.cases.forEach((entry, index) => {
+            const parsed = validateCase(entry, index, seenIds, errors);
+            if (parsed)
+                cases.push(parsed);
+        });
+    }
+    if (errors.length > 0 || subjectId === null) {
+        return { ok: false, errors };
+    }
+    return {
+        ok: true,
+        errors: [],
+        config: { schemaVersion: LOCAL_REPOSITORY_SUBJECT_CONFIG_SCHEMA_VERSION, subjectId, cases },
+    };
+}
+/** Throwing variant used by the loader. */
+export function parseLocalRepositorySubjectConfig(input) {
+    const result = validateLocalRepositorySubjectConfig(input);
+    if (!result.ok)
+        throw new LocalRepositorySubjectConfigError(result.errors);
+    return result.config;
+}

package/dist/src/evaluation/localRepositorySubject/evaluationCase.js

@@ -0,0 +1,36 @@
+import { logicalTargetRootForSubject } from "./types.js";
+/**
+ * Adapts a validated local-subject config to existing EvaluationCase objects in memory. The logical targetRoot is
+ * the durable identity; absoluteTargetRoot is the only place the physical repository path appears.
+ */
+export function buildLocalRepositorySubjectEvaluationCases(config, repositoryRoot) {
+    const targetRoot = logicalTargetRootForSubject(config.subjectId);
+    return config.cases.map((subjectCase) => {
+        const evaluationCase = {
+            id: subjectCase.id,
+            title: subjectCase.title,
+            benchmarkProject: config.subjectId,
+            targetRoot,
+            sourceRoots: [...subjectCase.sourceRoots],
+            query: subjectCase.query,
+            expectedFiles: [...subjectCase.expectedFiles],
+            expectedSymbols: [...subjectCase.expectedSymbols],
+            rawIncludeGlobs: [...subjectCase.rawIncludeGlobs],
+            absoluteTargetRoot: repositoryRoot,
+        };
+        if (subjectCase.answerKey !== undefined)
+            evaluationCase.answerKey = structuredClone(subjectCase.answerKey);
+        if (subjectCase.expectedFacts !== undefined)
+            evaluationCase.expectedFacts = structuredClone(subjectCase.expectedFacts);
+        if (subjectCase.taskLocality !== undefined)
+            evaluationCase.taskLocality = subjectCase.taskLocality;
+        if (subjectCase.promptComplexityHint !== undefined)
+            evaluationCase.promptComplexityHint = subjectCase.promptComplexityHint;
+        if (subjectCase.projectComplexityRelevance !== undefined) {
+            evaluationCase.projectComplexityRelevance = subjectCase.projectComplexityRelevance;
+        }
+        if (subjectCase.notes !== undefined)
+            evaluationCase.notes = subjectCase.notes;
+        return evaluationCase;
+    });
+}

package/dist/src/evaluation/localRepositorySubject/expectedFiles.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+function isWithinCanonicalRoot(filePath, root) {
+    return root === "." || filePath === root || filePath.startsWith(`${root}/`);
+}
+async function describeUnavailableFile(repositoryRoot, filePath, io) {
+    let current = repositoryRoot;
+    const segments = filePath.split("/");
+    for (let index = 0; index < segments.length; index += 1) {
+        current = path.join(current, segments[index]);
+        let stats;
+        try {
+            stats = await io.lstat(current);
+        }
+        catch {
+            return "does not exist";
+        }
+        if (stats.isSymbolicLink())
+            return "is or passes through a symlink";
+        if (index === segments.length - 1 && !stats.isFile())
+            return "is not a regular file";
+    }
+    return "is not eligible subject material";
+}
+/**
+ * Validates every required expected file of every case against the safe inventory. A required file is never
+ * silently dropped: ignored, oversized, symlinked, missing, non-regular, or out-of-root files each produce an error.
+ */
+export async function validateExpectedFiles(repositoryRoot, cases, inventory, io) {
+    const eligible = new Set(inventory.eligibleFiles.map((file) => file.path));
+    const errors = [];
+    for (let caseIndex = 0; caseIndex < cases.length; caseIndex += 1) {
+        const subjectCase = cases[caseIndex];
+        for (let fileIndex = 0; fileIndex < subjectCase.expectedFiles.length; fileIndex += 1) {
+            const filePath = subjectCase.expectedFiles[fileIndex];
+            const label = `config.cases[${caseIndex}].expectedFiles[${fileIndex}]`;
+            if (!subjectCase.sourceRoots.some((root) => isWithinCanonicalRoot(filePath, root))) {
+                errors.push(`${label}: expected file is outside the case source roots (${JSON.stringify(filePath)}).`);
+            }
+            else if (inventory.ignoredFiles.has(filePath)) {
+                errors.push(`${label}: expected file is ignored by Git (${JSON.stringify(filePath)}).`);
+            }
+            else if (inventory.oversizedFiles.has(filePath)) {
+                errors.push(`${label}: expected file exceeds the maximum file size policy (${JSON.stringify(filePath)}).`);
+            }
+            else if (!eligible.has(filePath)) {
+                errors.push(`${label}: expected file ${await describeUnavailableFile(repositoryRoot, filePath, io)} (${JSON.stringify(filePath)}).`);
+            }
+        }
+    }
+    return errors;
+}

package/dist/src/evaluation/localRepositorySubject/gitRepository.js

@@ -0,0 +1,128 @@
+import { execFile } from "node:child_process";
+import { realpath as nativeRealpath } from "node:fs";
+import { stat } from "node:fs/promises";
+import { promisify } from "node:util";
+import { LocalRepositorySubjectRepositoryError } from "./types.js";
+// Native realpath expands Windows short (8.3) names so the selected path and Git's reported root compare equal.
+const realpath = promisify(nativeRealpath.native);
+const GIT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+const CHECK_IGNORE_CHUNK_SIZE = 5000;
+const FULL_SHA_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+function gitEnvironment() {
+    const env = { ...process.env };
+    // A subject repository must be inspected on its own terms, never through an inherited git context.
+    for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR", "GIT_PREFIX"])
+        delete env[key];
+    env.GIT_OPTIONAL_LOCKS = "0";
+    return env;
+}
+/**
+ * Runs git with a structured argument array (no shell). Resolves with the exit code for ordinary non-zero exits so
+ * callers can classify them; rejects only when git cannot be started. Raw stderr is never surfaced.
+ */
+function runGit(cwd, args, input) {
+    return new Promise((resolve, reject) => {
+        const child = execFile("git", [...args], { cwd, env: gitEnvironment(), encoding: "utf8", maxBuffer: GIT_MAX_BUFFER_BYTES, windowsHide: true }, (error, stdout) => {
+            if (error) {
+                const code = error.code;
+                if (typeof code === "number") {
+                    resolve({ exitCode: code, stdout: String(stdout ?? "") });
+                    return;
+                }
+                if (code === "ENOENT") {
+                    reject(new LocalRepositorySubjectRepositoryError("GIT_UNAVAILABLE", "the git executable is not available."));
+                    return;
+                }
+                if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+                    resolve({ exitCode: 0, stdout: String(stdout ?? "") });
+                    return;
+                }
+                reject(new LocalRepositorySubjectRepositoryError("GIT_UNAVAILABLE", "the git executable could not be run."));
+                return;
+            }
+            resolve({ exitCode: 0, stdout: String(stdout ?? "") });
+        });
+        // When the process cannot be started (for example a working directory beyond the Windows path limit), Node can
+        // still emit an error on the never-connected stdio sockets; without listeners that becomes an uncaught exception
+        // instead of the classified rejection above.
+        for (const stream of [child.stdin, child.stdout, child.stderr])
+            stream?.on("error", () => undefined);
+        if (input !== undefined) {
+            child.stdin?.end(input);
+        }
+    });
+}
+function normalizeForComparison(value) {
+    const slashed = value.replace(/\\/g, "/").replace(/\/+$/, "");
+    return process.platform === "win32" ? slashed.toLowerCase() : slashed;
+}
+/** Resolves the selected path to its physical directory, rejecting missing or non-directory paths. */
+export async function resolveSelectedRepositoryPath(selectedPath) {
+    if (typeof selectedPath !== "string" || selectedPath.trim().length === 0) {
+        throw new LocalRepositorySubjectRepositoryError("REPOSITORY_PATH_INVALID", "the repository path must be a non-empty string.");
+    }
+    let physical;
+    try {
+        physical = await realpath(selectedPath);
+        if (!(await stat(physical)).isDirectory())
+            throw new Error("not a directory");
+    }
+    catch {
+        throw new LocalRepositorySubjectRepositoryError("REPOSITORY_PATH_INVALID", "the repository path does not exist or is not a directory.");
+    }
+    return physical;
+}
+/**
+ * Reads Git-backed identity for the selected path. The selected path must be the exact worktree root. Only
+ * read-only Git commands are issued. Dirty state is reduced to a boolean; status output is discarded.
+ */
+export async function readRepositoryIdentity(selectedPath) {
+    const repositoryRoot = await resolveSelectedRepositoryPath(selectedPath);
+    const topLevel = await runGit(repositoryRoot, ["rev-parse", "--show-toplevel"]);
+    if (topLevel.exitCode !== 0 || topLevel.stdout.trim().length === 0) {
+        throw new LocalRepositorySubjectRepositoryError("NOT_A_GIT_REPOSITORY", "the selected path is not inside a usable Git worktree.");
+    }
+    let gitRoot;
+    try {
+        gitRoot = await realpath(topLevel.stdout.trim());
+    }
+    catch {
+        throw new LocalRepositorySubjectRepositoryError("NOT_A_GIT_REPOSITORY", "the Git worktree root could not be resolved.");
+    }
+    if (normalizeForComparison(gitRoot) !== normalizeForComparison(repositoryRoot)) {
+        throw new LocalRepositorySubjectRepositoryError("NOT_WORKTREE_ROOT", "the selected path is inside a Git worktree but is not the worktree root.");
+    }
+    const head = await runGit(repositoryRoot, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
+    const commit = head.stdout.trim();
+    if (head.exitCode !== 0 || !FULL_SHA_PATTERN.test(commit)) {
+        throw new LocalRepositorySubjectRepositoryError("NO_HEAD_COMMIT", "the repository has no resolvable HEAD commit.");
+    }
+    const symbolic = await runGit(repositoryRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    const branch = symbolic.exitCode === 0 && symbolic.stdout.trim().length > 0 ? symbolic.stdout.trim() : null;
+    const status = await runGit(repositoryRoot, ["status", "--porcelain=v1", "-z"]);
+    if (status.exitCode !== 0) {
+        throw new LocalRepositorySubjectRepositoryError("NOT_A_GIT_REPOSITORY", "the working tree state could not be read.");
+    }
+    return { repositoryRoot, identity: { commit, branch, workingTreeDirty: status.stdout.length > 0 } };
+}
+/**
+ * Returns the subset of repository-relative paths that Git itself reports as ignored. No independent ignore
+ * parsing exists here. Tracked files are never reported ignored by Git; `--no-index` is intentionally not used.
+ */
+export async function classifyGitIgnoredPaths(repositoryRoot, relativePaths) {
+    const ignored = new Set();
+    for (let start = 0; start < relativePaths.length; start += CHECK_IGNORE_CHUNK_SIZE) {
+        const chunk = relativePaths.slice(start, start + CHECK_IGNORE_CHUNK_SIZE);
+        const result = await runGit(repositoryRoot, ["check-ignore", "--stdin", "-z"], chunk.map((entry) => `${entry}\0`).join(""));
+        if (result.exitCode === 1)
+            continue;
+        if (result.exitCode !== 0) {
+            throw new LocalRepositorySubjectRepositoryError("GIT_CHECK_IGNORE_FAILED", "git could not classify ignored files.");
+        }
+        for (const entry of result.stdout.split("\0")) {
+            if (entry.length > 0)
+                ignored.add(entry);
+        }
+    }
+    return ignored;
+}

package/dist/src/evaluation/localRepositorySubject/index.js

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export { canonicalizeRepositoryRelativePath, parseLocalRepositorySubjectConfig, validateLocalRepositorySubjectConfig } from "./config.js";
+export { classifyGitIgnoredPaths, readRepositoryIdentity, resolveSelectedRepositoryPath } from "./gitRepository.js";
+export { buildLocalRepositorySubjectInventory, defaultLocalRepositorySubjectFsIo, validateSourceRootOnDisk, } from "./inventory.js";
+export { validateExpectedFiles } from "./expectedFiles.js";
+export { buildLocalRepositorySubjectManifest, extensionOf, serializeLocalRepositorySubjectManifest } from "./manifest.js";
+export { buildLocalRepositorySubjectEvaluationCases } from "./evaluationCase.js";
+export { loadLocalRepositorySubject } from "./loadLocalRepositorySubject.js";

package/dist/src/evaluation/localRepositorySubject/inventory.js

@@ -0,0 +1,127 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithinRoot } from "../../core/pathSafety.js";
+import { classifyGitIgnoredPaths } from "./gitRepository.js";
+import { compareCodeUnits } from "./types.js";
+export const defaultLocalRepositorySubjectFsIo = {
+    lstat: (absolutePath) => lstat(absolutePath),
+    readdir: (absolutePath) => readdir(absolutePath),
+};
+function isNotFound(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+ * Validates, for one declared source root, that it is contained, exists, is a directory, and neither is nor passes
+ * through a symlink. Returns labelled error strings (empty when valid).
+ */
+export async function validateSourceRootOnDisk(repositoryRoot, canonicalRoot, label, io) {
+    if (canonicalRoot === ".")
+        return [];
+    try {
+        resolveWithinRoot(repositoryRoot, canonicalRoot);
+    }
+    catch {
+        return [`${label}: resolves outside the selected repository (${JSON.stringify(canonicalRoot)}).`];
+    }
+    let current = repositoryRoot;
+    const segments = canonicalRoot.split("/");
+    for (let index = 0; index < segments.length; index += 1) {
+        current = path.join(current, segments[index]);
+        let stats;
+        try {
+            stats = await io.lstat(current);
+        }
+        catch (error) {
+            if (isNotFound(error))
+                return [`${label}: source root does not exist (${JSON.stringify(canonicalRoot)}).`];
+            return [`${label}: source root could not be inspected (${JSON.stringify(canonicalRoot)}).`];
+        }
+        if (stats.isSymbolicLink()) {
+            return [`${label}: source root is or passes through a symlink (${JSON.stringify(canonicalRoot)}).`];
+        }
+        if (index === segments.length - 1 && !stats.isDirectory()) {
+            return [`${label}: source root is not a directory (${JSON.stringify(canonicalRoot)}).`];
+        }
+    }
+    return [];
+}
+/**
+ * Walks the union of source roots without following links and without reading contents. Symlinks and non-regular
+ * entries are counted and excluded; `.git` is never traversed. Result is deterministic (code-unit order).
+ */
+async function walkSourceRoots(repositoryRoot, canonicalRoots, io) {
+    const regularFiles = new Map();
+    const visitedDirectories = new Set();
+    let symlinkCount = 0;
+    let otherExcludedCount = 0;
+    const walkDirectory = async (relativeDirectory) => {
+        if (visitedDirectories.has(relativeDirectory))
+            return;
+        visitedDirectories.add(relativeDirectory);
+        const absoluteDirectory = relativeDirectory === "." ? repositoryRoot : path.join(repositoryRoot, relativeDirectory);
+        const names = (await io.readdir(absoluteDirectory)).slice().sort(compareCodeUnits);
+        for (const name of names) {
+            if (name === ".git")
+                continue;
+            const relativePath = relativeDirectory === "." ? name : `${relativeDirectory}/${name}`;
+            const stats = await io.lstat(path.join(absoluteDirectory, name));
+            if (stats.isSymbolicLink()) {
+                symlinkCount += 1;
+            }
+            else if (stats.isDirectory()) {
+                await walkDirectory(relativePath);
+            }
+            else if (stats.isFile()) {
+                if (!regularFiles.has(relativePath))
+                    regularFiles.set(relativePath, stats.size);
+            }
+            else {
+                otherExcludedCount += 1;
+            }
+        }
+    };
+    for (const root of [...canonicalRoots].sort(compareCodeUnits)) {
+        await walkDirectory(root);
+    }
+    return { regularFiles, symlinkCount, otherExcludedCount };
+}
+/**
+ * Builds the safety inventory: walk, ask Git which files are ignored, then classify remaining regular files by
+ * size from filesystem metadata only. Categories are exclusive (ignored, then oversized, else eligible).
+ */
+export async function buildLocalRepositorySubjectInventory(repositoryRoot, canonicalRoots, maxFileBytes, io = defaultLocalRepositorySubjectFsIo) {
+    const walked = await walkSourceRoots(repositoryRoot, canonicalRoots, io);
+    const candidatePaths = [...walked.regularFiles.keys()].sort(compareCodeUnits);
+    const ignoredByGit = await classifyGitIgnoredPaths(repositoryRoot, candidatePaths);
+    const eligibleFiles = [];
+    const ignoredFiles = new Set();
+    const oversizedFiles = new Set();
+    let eligibleByteCount = 0;
+    for (const filePath of candidatePaths) {
+        const size = walked.regularFiles.get(filePath);
+        if (ignoredByGit.has(filePath)) {
+            ignoredFiles.add(filePath);
+        }
+        else if (size > maxFileBytes) {
+            oversizedFiles.add(filePath);
+        }
+        else {
+            eligibleFiles.push({ path: filePath, size });
+            eligibleByteCount += size;
+        }
+    }
+    return {
+        eligibleFiles,
+        ignoredFiles,
+        oversizedFiles,
+        counts: {
+            eligibleFileCount: eligibleFiles.length,
+            eligibleByteCount,
+            gitIgnoredCount: ignoredFiles.size,
+            oversizedCount: oversizedFiles.size,
+            symlinkCount: walked.symlinkCount,
+            otherExcludedCount: walked.otherExcludedCount,
+        },
+    };
+}