@interf/compiler 0.16.0 → 0.18.0

package/dist/packages/engine/compile/runtime-acceptance.js

@@ -1,265 +0,0 @@
-import { existsSync, } from "node:fs";
-import { join } from "node:path";
-import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { METHOD_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, } from "./compiled-schema.js";
-import { RuntimeStageContractSchema, } from "./lib/schema.js";
-import { ACCEPTANCE_RULE_KEYS } from "../../contracts/lib/schema.js";
-import { stageContractPath } from "./runtime-paths.js";
-import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { loadState } from "./state-io.js";
-import { countBrokenWikilinks, isOutputMarkdownFile, safeReadText, validateSynthFiles } from "./validate.js";
-import { countCompiledZoneArtifacts } from "./artifact-counts.js";
-function toFiniteNumber(value) {
-    if (typeof value !== "number" || !Number.isFinite(value))
-        return null;
-    return value;
-}
-function hasAcceptanceRules(acceptance) {
-    if (!acceptance)
-        return false;
-    // Drive off the canonical rule-key list so a new key added to
-    // contracts/ is automatically considered here.
-    for (const key of ACCEPTANCE_RULE_KEYS) {
-        const value = acceptance[key];
-        if (Array.isArray(value)) {
-            if (value.length > 0)
-                return true;
-        }
-        else if (value && typeof value === "object") {
-            if (Object.keys(value).length > 0)
-                return true;
-        }
-    }
-    return false;
-}
-function readPathValue(record, keyPath) {
-    if (!record)
-        return undefined;
-    return keyPath
-        .split(".")
-        .filter((segment) => segment.length > 0)
-        .reduce((current, segment) => {
-        if (!current || typeof current !== "object" || Array.isArray(current))
-            return undefined;
-        return current[segment];
-    }, record);
-}
-function markdownFilesForZone(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return [];
-    if (kind === "file") {
-        return isOutputMarkdownFile(absolutePath) ? [absolutePath] : [];
-    }
-    return listFilesRecursive(absolutePath, isOutputMarkdownFile);
-}
-function zoneRoots(compiledPath, acceptanceZones) {
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
-    if (!schema)
-        return [];
-    return acceptanceZones
-        .map((zoneId) => findCompiledSchemaZone(schema, zoneId))
-        .filter((zone) => zone !== null)
-        .map((zone) => compiledZoneAbsolutePath(compiledPath, zone));
-}
-function readArtifactText(compiledPath, relativePath) {
-    const artifactPath = join(compiledPath, relativePath);
-    if (!existsSync(artifactPath))
-        return null;
-    return safeReadText(artifactPath);
-}
-function resolveStageCounts(contract, stageRecord) {
-    const merged = { ...contract.counts };
-    const fromStage = stageRecord?.counts;
-    if (fromStage && typeof fromStage === "object" && !Array.isArray(fromStage)) {
-        for (const [key, value] of Object.entries(fromStage)) {
-            const numeric = toFiniteNumber(value);
-            if (numeric !== null)
-                merged[key] = numeric;
-        }
-    }
-    return merged;
-}
-export function stageRecordFromState(state, stageId) {
-    const stages = state?.stages;
-    if (!stages || typeof stages !== "object")
-        return null;
-    const stage = stages[stageId];
-    if (!stage || typeof stage !== "object" || Array.isArray(stage))
-        return null;
-    return stage;
-}
-export function validateResolvedStageAcceptance(dirPath, options) {
-    const acceptance = options.acceptance;
-    if (!hasAcceptanceRules(acceptance)) {
-        return {
-            ok: true,
-            summary: "No additional stage acceptance criteria were declared.",
-            failures: [],
-        };
-    }
-    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    if (!schema) {
-        return {
-            ok: false,
-            summary: `Stage acceptance failed for ${options.stageId}: missing Method schema.`,
-            failures: [`Missing method/${METHOD_SCHEMA_FILE}.`],
-        };
-    }
-    const failures = [];
-    const state = loadState(dirPath);
-    const stageRecord = stageRecordFromState(state, options.stageId);
-    const counts = options.counts ?? {};
-    for (const relativePath of acceptance?.artifacts_exist ?? []) {
-        if (!existsSync(join(dirPath, relativePath))) {
-            failures.push(`Missing required artifact: ${relativePath}.`);
-        }
-    }
-    for (const keyPath of acceptance?.stage_truthy ?? []) {
-        if (!readPathValue(stageRecord, keyPath)) {
-            failures.push(`Expected truthy stage value at "${keyPath}".`);
-        }
-    }
-    for (const [keyPath, countKey] of Object.entries(acceptance?.stage_equals_counts ?? {})) {
-        const actual = readPathValue(stageRecord, keyPath);
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for "${keyPath}".`);
-            continue;
-        }
-        if (actual !== expected) {
-            failures.push(`Expected stage "${keyPath}" to equal count "${countKey}" (${expected}), got ${JSON.stringify(actual)}.`);
-        }
-    }
-    for (const [keyPath, minimum] of Object.entries(acceptance?.stage_at_least ?? {})) {
-        const actual = toFiniteNumber(readPathValue(stageRecord, keyPath));
-        if (actual === null || actual < minimum) {
-            failures.push(`Expected stage "${keyPath}" to be at least ${minimum}, got ${actual === null ? "non-numeric" : actual}.`);
-        }
-    }
-    for (const [keyPath, countKey] of Object.entries(acceptance?.stage_at_least_counts ?? {})) {
-        const actual = toFiniteNumber(readPathValue(stageRecord, keyPath));
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for "${keyPath}".`);
-            continue;
-        }
-        if (actual === null || actual < expected) {
-            failures.push(`Expected stage "${keyPath}" to be at least count "${countKey}" (${expected}), got ${actual === null ? "non-numeric" : actual}.`);
-        }
-    }
-    for (const [zoneId, minimum] of Object.entries(acceptance?.zone_counts_at_least ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const actual = countCompiledZoneArtifacts(dirPath, zone.path, zone.kind);
-        if (actual < minimum) {
-            failures.push(`Expected zone "${zoneId}" to contain at least ${minimum} artifact(s), got ${actual}.`);
-        }
-    }
-    for (const [zoneId, countKey] of Object.entries(acceptance?.zone_counts_at_least_counts ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const expected = counts[countKey];
-        if (typeof expected !== "number") {
-            failures.push(`Acceptance references missing count "${countKey}" for zone "${zoneId}".`);
-            continue;
-        }
-        const actual = countCompiledZoneArtifacts(dirPath, zone.path, zone.kind);
-        if (actual < expected) {
-            failures.push(`Expected zone "${zoneId}" to contain at least count "${countKey}" (${expected}) artifact(s), got ${actual}.`);
-        }
-    }
-    for (const zoneId of acceptance?.markdown_frontmatter_valid_zones ?? []) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind));
-        if (validation.invalid_frontmatter > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.invalid_frontmatter} markdown file(s) with invalid or incomplete frontmatter.`);
-        }
-    }
-    for (const [zoneId, requiredKeys] of Object.entries(acceptance?.frontmatter_required_keys_in_zones ?? {})) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind), { requiredFrontmatterKeys: requiredKeys });
-        if (validation.invalid_frontmatter > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.invalid_frontmatter} markdown file(s) missing required frontmatter keys (${requiredKeys.join(", ")}).`);
-        }
-    }
-    for (const zoneId of acceptance?.markdown_abstract_valid_zones ?? []) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone) {
-            failures.push(`Acceptance references unknown zone "${zoneId}".`);
-            continue;
-        }
-        const validation = validateSynthFiles(markdownFilesForZone(dirPath, zone.path, zone.kind));
-        if (validation.short_abstracts > 0) {
-            failures.push(`Zone "${zoneId}" has ${validation.short_abstracts} markdown file(s) with missing or weak abstracts.`);
-        }
-    }
-    if ((acceptance?.wikilinks_valid_in_zones?.length ?? 0) > 0) {
-        const roots = zoneRoots(dirPath, acceptance?.wikilinks_valid_in_zones ?? []);
-        const brokenLinks = countBrokenWikilinks(dirPath, roots, roots);
-        if (brokenLinks > 0) {
-            failures.push(`Detected ${brokenLinks} broken wikilink(s) across the declared acceptance zones.`);
-        }
-    }
-    for (const [relativePath, disallowedTexts] of Object.entries(acceptance?.artifacts_must_not_contain ?? {})) {
-        const content = readArtifactText(dirPath, relativePath);
-        if (content === null) {
-            failures.push(`Missing artifact required for content check: ${relativePath}.`);
-            continue;
-        }
-        for (const disallowed of disallowedTexts) {
-            if (content.includes(disallowed)) {
-                failures.push(`Artifact "${relativePath}" still contains forbidden text: ${JSON.stringify(disallowed)}.`);
-            }
-        }
-    }
-    if (failures.length === 0) {
-        return {
-            ok: true,
-            summary: `Stage acceptance satisfied for ${options.stageId}.`,
-            failures: [],
-        };
-    }
-    return {
-        ok: false,
-        summary: `Stage acceptance failed for ${options.stageId}: ${failures.join(" ")}`,
-        failures,
-    };
-}
-export function validateStageContractAcceptance(dirPath, contract = null) {
-    const resolvedContract = contract ?? (() => {
-        const path = stageContractPath(dirPath);
-        if (!existsSync(path))
-            return null;
-        return readJsonFileWithSchema(path, "stage contract", RuntimeStageContractSchema);
-    })();
-    if (!resolvedContract) {
-        return {
-            ok: true,
-            summary: "No active stage contract found for acceptance validation.",
-            failures: [],
-        };
-    }
-    const state = loadState(dirPath);
-    const stageRecord = stageRecordFromState(state, resolvedContract.stage);
-    return validateResolvedStageAcceptance(dirPath, {
-        stageId: resolvedContract.stage,
-        acceptance: resolvedContract.acceptance,
-        counts: resolveStageCounts(resolvedContract, stageRecord),
-    });
-}