@interf/compiler 0.6.1 → 0.6.4

package/dist/lib/test-targets.js

@@ -1,38 +1,3 @@
-import { listCompiledDatasetsForSourceFolder } from "./interf.js";
-import { computeCompiledHealth } from "./state.js";
-function summarizeTargetSortKey(target) {
-    return `${target.name}\u0000${target.workflow}`;
-}
-export function listCompiledTestTargets(sourcePath) {
-    return listCompiledDatasetsForSourceFolder(sourcePath)
-        .map(({ path, config }) => createCompiledTestTarget(path, config.name, config.workflow ?? "interf"))
-        .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
-}
-export function createCompiledTestTarget(compiledPath, compiledName, workflowId = "interf") {
-    const health = computeCompiledHealth(compiledPath);
-    return {
-        type: "compiled",
-        name: compiledName,
-        path: compiledPath,
-        workflow: workflowId,
-        status: health.status,
-        stage: health.stage,
-        summary: health.summary,
-        eligible: health.status === "compiled",
-    };
-}
-export function createRawTestTarget(sourcePath) {
-    return {
-        type: "raw",
-        name: "raw",
-        path: sourcePath,
-        workflow: "raw",
-        status: "compiled",
-        stage: "raw",
-        summary: "Run the saved truth checks against an isolated sandbox of the raw files.",
-        eligible: true,
-    };
-}
-export function listTestTargets(sourcePath) {
-    return listCompiledTestTargets(sourcePath);
-}
+// Compatibility shim for historical `src/lib/test-targets.ts` imports.
+// Source of truth: `src/packages/testing/test-targets.ts`.
+export * from "../packages/testing/test-targets.js";

package/dist/lib/test-types.d.ts

@@ -1,17 +1 @@
-import type { TestSpec } from "./schema.js";
-export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, } from "./schema.js";
-export type TestTargetType = "compiled" | "raw";
-export interface LoadedTestSpec extends TestSpec {
-    id: string;
-    filePath: string;
-}
-export interface TestTargetCandidate {
-    type: TestTargetType;
-    name: string;
-    path: string;
-    workflow: string;
-    status: "idle" | "running" | "compiled" | "stale" | "failed";
-    stage: string;
-    summary: string;
-    eligible: boolean;
-}
+export * from "../packages/testing/test-types.js";

package/dist/lib/test-types.js

@@ -1 +1,3 @@
-export {};
+// Compatibility shim for historical `src/lib/test-types.ts` imports.
+// Source of truth: `src/packages/testing/test-types.ts`.
+export * from "../packages/testing/test-types.js";

package/dist/lib/test.d.ts

@@ -1,4 +1 @@
-export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
-export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
-export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";
+export * from "../packages/testing/test.js";

package/dist/lib/test.js

@@ -1,3 +1,3 @@
-export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createRawTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
-export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";
+// Compatibility shim for historical `src/lib/test.ts` imports.
+// Source of truth: `src/packages/testing/test.ts`.
+export * from "../packages/testing/test.js";

package/dist/lib/util.d.ts

@@ -1,4 +1 @@
-export declare function slugify(input: string): string;
-export declare function isMarkdownFile(filePath: string): boolean;
-export declare function isPathWithinRoot(rootPath: string, candidatePath: string): boolean;
-export declare function assertPathWithinRoot(rootPath: string, candidatePath: string, label: string): string;
+export * from "../packages/shared/util.js";

package/dist/lib/util.js

@@ -1,25 +1 @@
-import { extname, isAbsolute, relative, resolve, sep } from "node:path";
-export function slugify(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-export function isMarkdownFile(filePath) {
-    return extname(filePath).toLowerCase() === ".md";
-}
-export function isPathWithinRoot(rootPath, candidatePath) {
-    const root = resolve(rootPath);
-    const candidate = resolve(candidatePath);
-    const relativePath = relative(root, candidate);
-    return relativePath === "" || (!isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(`..${sep}`));
-}
-export function assertPathWithinRoot(rootPath, candidatePath, label) {
-    const resolvedPath = resolve(candidatePath);
-    if (!isPathWithinRoot(rootPath, resolvedPath)) {
-        throw new Error(`${label} must stay inside ${resolve(rootPath)}: ${resolvedPath}`);
-    }
-    return resolvedPath;
-}
+export * from "../packages/shared/util.js";

package/dist/lib/validate-compiled.d.ts

@@ -1,27 +1 @@
-export interface CompiledValidationSummary {
-    config_present: boolean;
-    config_valid: boolean;
-    config_type_match: boolean;
-    workflow_present: boolean;
-    workflow_valid: boolean;
-    schema_present: boolean;
-    schema_valid: boolean;
-}
-export interface CompiledStageValidation {
-    ok: boolean;
-    required: boolean;
-    stage: string;
-    summary: string;
-    counts: Record<string, number>;
-    checks: Record<string, boolean>;
-    errors: string[];
-}
-export interface CompiledWorkflowValidation extends CompiledStageValidation {
-    stage_results: Record<string, boolean>;
-}
-export declare function validateCompiled(dirPath: string): CompiledValidationSummary;
-export declare function validateCompiledStage(dirPath: string, stageId: string): CompiledStageValidation;
-export declare function validateCompiledWorkflow(dirPath: string): CompiledWorkflowValidation;
-export declare function validateCompiledSummarize(dirPath: string): CompiledStageValidation;
-export declare function validateCompiledStructure(dirPath: string): CompiledStageValidation;
-export declare function validateCompiledCompile(dirPath: string): CompiledWorkflowValidation;
+export * from "../packages/compiler/validate-compiled.js";

package/dist/lib/validate-compiled.js

@@ -1,241 +1 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { discoverSourceFiles } from "./discovery.js";
-import { WORKFLOW_SCHEMA_FILE, compiledZoneAbsolutePath, findCompiledSchemaZone, readCompiledSchemaFile, workflowSchemaExists, } from "./compiled-schema.js";
-import { resolveSourceFolderPath } from "./interf.js";
-import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./compiled-paths.js";
-import { readCompiledConfig } from "./validate.js";
-import { loadState } from "./state.js";
-import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
-import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
-import { listFilesRecursive } from "./filesystem.js";
-function workflowSchemaPresent(dirPath) {
-    return workflowSchemaExists(join(dirPath, ".interf", "workflow"));
-}
-function countZoneArtifacts(compiledPath, zonePath, kind) {
-    const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
-    if (!existsSync(absolutePath))
-        return 0;
-    if (kind === "file")
-        return 1;
-    return listFilesRecursive(absolutePath).length;
-}
-function readWorkflowContext(dirPath) {
-    const config = readCompiledConfig(dirPath);
-    const workflowId = config.valid
-        ? resolveRequiredCompiledWorkflowFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
-        : null;
-    let workflow = null;
-    if (workflowId) {
-        try {
-            workflow = getActiveCompiledWorkflow(dirPath, workflowId);
-        }
-        catch {
-            workflow = null;
-        }
-    }
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(dirPath));
-    const state = loadState(dirPath);
-    const sourceTotal = config.valid
-        ? discoverSourceFiles(resolveSourceFolderPath(dirPath, config.value), dirPath).totalCount
-        : 0;
-    return {
-        config,
-        workflow,
-        schema,
-        state,
-        sourceTotal,
-        workflowId,
-    };
-}
-function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
-    return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
-}
-function zoneWriteCount(compiledPath, schema, stage) {
-    const zoneCounts = {};
-    let total = 0;
-    for (const zoneId of stage.writes) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone)
-            continue;
-        const count = countZoneArtifacts(compiledPath, zone.path, zone.kind);
-        zoneCounts[zoneId] = count;
-        total += count;
-    }
-    return { total, zoneCounts };
-}
-function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
-    const merged = {
-        source_total: sourceTotal,
-        ...zoneCounts,
-    };
-    const stageCounts = stageRecord?.counts;
-    if (stageCounts && typeof stageCounts === "object" && !Array.isArray(stageCounts)) {
-        for (const [key, value] of Object.entries(stageCounts)) {
-            if (typeof value === "number" && Number.isFinite(value)) {
-                merged[key] = value;
-            }
-        }
-    }
-    return merged;
-}
-export function validateCompiled(dirPath) {
-    const context = readWorkflowContext(dirPath);
-    return {
-        config_present: context.config.present,
-        config_valid: context.config.valid,
-        config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
-        schema_valid: context.schema !== null,
-    };
-}
-export function validateCompiledStage(dirPath, stageId) {
-    const context = readWorkflowContext(dirPath);
-    const checks = {
-        config_present: context.config.present,
-        config_valid: context.config.valid,
-        config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
-        schema_valid: context.schema !== null,
-    };
-    const errors = [];
-    if (!checks.config_present)
-        errors.push(`Missing ${compiledInterfConfigPath(dirPath)}.`);
-    else if (!checks.config_valid)
-        errors.push(`Could not parse ${compiledInterfConfigPath(dirPath)}.`);
-    else if (!checks.config_type_match)
-        errors.push("Config is not a compiled dataset.");
-    if (!checks.workflow_present)
-        errors.push("Missing .interf/workflow/workflow.json.");
-    else if (!checks.workflow_valid)
-        errors.push("Could not load the active workflow package.");
-    if (!checks.schema_present)
-        errors.push(`Missing .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
-    else if (!checks.schema_valid)
-        errors.push(`Could not parse .interf/workflow/${WORKFLOW_SCHEMA_FILE}.`);
-    const workflowStage = context.workflow?.stages.find((stage) => stage.id === stageId) ?? null;
-    checks.stage_present = workflowStage !== null;
-    if (!checks.stage_present) {
-        errors.push(`Workflow does not declare stage "${stageId}".`);
-    }
-    const stageRecord = stageRecordFromState(context.state, stageId);
-    checks.stage_record_present = stageRecord !== null;
-    checks.stage_finished = Boolean(stageRecord?.finished_at);
-    checks.stage_succeeded = stageRecord?.status === "succeeded";
-    const writeCounts = workflowStage && context.schema
-        ? zoneWriteCount(dirPath, context.schema, workflowStage)
-        : { total: 0, zoneCounts: {} };
-    const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
-    const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
-    let acceptanceErrors = [];
-    if (workflowStage && context.schema) {
-        const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
-            stageId,
-            acceptance: workflowStage.acceptance,
-            counts: acceptanceCounts,
-        });
-        checks.acceptance_ok = acceptanceValidation.ok;
-        acceptanceErrors = acceptanceValidation.failures;
-    }
-    else {
-        checks.acceptance_ok = false;
-    }
-    if (required && checks.stage_record_present && !checks.stage_finished) {
-        errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
-    }
-    if (required && checks.stage_record_present && !checks.stage_succeeded) {
-        errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
-    }
-    if (required) {
-        errors.push(...acceptanceErrors);
-    }
-    const ok = required ? errors.length === 0 : errors.length === 0;
-    const summary = !required
-        ? `Stage "${stageId}" is not required yet.`
-        : ok
-            ? `Stage "${stageId}" verified.`
-            : `Stage "${stageId}" failed — ${errors[0] ?? "acceptance not satisfied."}`;
-    return {
-        ok,
-        required,
-        stage: stageId,
-        summary,
-        counts: {
-            ...acceptanceCounts,
-            write_artifacts: writeCounts.total,
-            declared_write_zones: workflowStage?.writes.length ?? 0,
-        },
-        checks,
-        errors,
-    };
-}
-export function validateCompiledWorkflow(dirPath) {
-    const context = readWorkflowContext(dirPath);
-    const checks = {
-        config_present: context.config.present,
-        config_valid: context.config.valid,
-        config_type_match: context.config.typeMatch(),
-        workflow_present: existsSync(join(dirPath, ".interf", "workflow", "workflow.json")),
-        workflow_valid: context.workflow !== null,
-        schema_present: workflowSchemaPresent(dirPath),
-        schema_valid: context.schema !== null,
-    };
-    if (!context.workflow) {
-        const errors = ["Could not load the active workflow package."];
-        return {
-            ok: false,
-            required: true,
-            stage: "workflow",
-            summary: `Compiled workflow failed — ${errors[0]}`,
-            counts: { source_total: context.sourceTotal, stage_total: 0, completed_stages: 0 },
-            checks,
-            errors,
-            stage_results: {},
-        };
-    }
-    const stageResults = {};
-    const errors = [];
-    let completedStages = 0;
-    let failedStage = "compiled";
-    for (const stage of context.workflow.stages) {
-        const validation = validateCompiledStage(dirPath, stage.id);
-        stageResults[stage.id] = validation.ok;
-        if (validation.ok) {
-            completedStages += 1;
-            continue;
-        }
-        failedStage = stage.id;
-        errors.push(...validation.errors);
-        break;
-    }
-    const ok = errors.length === 0;
-    return {
-        ok,
-        required: context.sourceTotal > 0,
-        stage: failedStage,
-        summary: ok
-            ? `Compiled workflow verified — ${completedStages}/${context.workflow.stages.length} stages satisfied.`
-            : `Compiled workflow failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
-        counts: {
-            source_total: context.sourceTotal,
-            stage_total: context.workflow.stages.length,
-            completed_stages: completedStages,
-        },
-        checks,
-        errors,
-        stage_results: stageResults,
-    };
-}
-export function validateCompiledSummarize(dirPath) {
-    return validateCompiledStage(dirPath, "summarize");
-}
-export function validateCompiledStructure(dirPath) {
-    return validateCompiledStage(dirPath, "structure");
-}
-export function validateCompiledCompile(dirPath) {
-    return validateCompiledWorkflow(dirPath);
-}
+export * from "../packages/compiler/validate-compiled.js";

package/dist/lib/validate-helpers.d.ts

@@ -1,12 +1 @@
-export declare function asStringArray(value: unknown): string[];
-export declare function asRejectedEntries(value: unknown): Array<{
-    path: string;
-    reason: string;
-}>;
-export declare function asFileEntries(value: unknown): Array<{
-    file: string;
-}>;
-export declare function isSubset(left: Set<string>, right: Set<string>): boolean;
-export declare function setsEqual(left: Set<string>, right: Set<string>): boolean;
-export declare function setIntersectionSize(left: Set<string>, right: Set<string>): number;
-export declare function dedupeStrings(values: string[]): string[];
+export * from "../packages/compiler/validate-helpers.js";

package/dist/lib/validate-helpers.js

@@ -1,41 +1 @@
-export function asStringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => typeof item === "string");
-}
-export function asRejectedEntries(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => !!item &&
-        typeof item === "object" &&
-        typeof item.path === "string" &&
-        typeof item.reason === "string");
-}
-export function asFileEntries(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.filter((item) => !!item &&
-        typeof item === "object" &&
-        typeof item.file === "string");
-}
-export function isSubset(left, right) {
-    for (const item of left) {
-        if (!right.has(item))
-            return false;
-    }
-    return true;
-}
-export function setsEqual(left, right) {
-    return left.size === right.size && isSubset(left, right);
-}
-export function setIntersectionSize(left, right) {
-    let count = 0;
-    for (const item of left) {
-        if (right.has(item))
-            count += 1;
-    }
-    return count;
-}
-export function dedupeStrings(values) {
-    return Array.from(new Set(values));
-}
+export * from "../packages/compiler/validate-helpers.js";

package/dist/lib/validate.d.ts

@@ -1,21 +1 @@
-import { readInterfConfig } from "./interf.js";
-export declare function readCompiledConfig(dirPath: string): {
-    present: boolean;
-    valid: boolean;
-    value: ReturnType<typeof readInterfConfig>;
-    typeMatch(): boolean;
-};
-export declare function validateSynthFiles(files: string[], options?: {
-    requiredFrontmatterKeys?: string[];
-}): {
-    invalid_frontmatter: number;
-    short_abstracts: number;
-};
-export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoots: string[], linkScanRoots: string[]): number;
-export declare function asNumber(value: unknown): number;
-export declare function isOutputMarkdownFile(filePath: string): boolean;
-export declare function safeReadText(filePath: string): string | null;
-export declare function extractSynthAbstract(frontmatter: Record<string, unknown>, body: string): string | null;
-export declare function countSynthAbstractWords(frontmatter: Record<string, unknown>, body: string): number;
-export { validateCompiled, validateCompiledStage, validateCompiledWorkflow, validateCompiledSummarize, validateCompiledStructure, validateCompiledCompile, } from "./validate-compiled.js";
-export type { CompiledValidationSummary, CompiledStageValidation, CompiledWorkflowValidation, } from "./validate-compiled.js";
+export * from "../packages/compiler/validate.js";