@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{compiler → engine/compile}/state-health.js

@@ -1,13 +1,13 @@
 import { basename } from "node:path";
-import { readInterfConfig, resolveSourceFolderPath, } from "../project-model/interf-detect.js";
+import { readInterfConfig, resolveSourceFolderPath, } from "../../project/interf-detect.js";
 import { discoverSourceFiles } from "./discovery.js";
 import { loadRuntimeRun } from "./runtime.js";
 import { loadState } from "./state-io.js";
 import { validateCompiled, validateCompiledStage, validateCompiledMethod, } from "./validate.js";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
-import { countCompiledZoneArtifacts } from "./artifact-counts.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
+import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
 export function computeCompiledHealth(dirPath) {
     const now = new Date().toISOString();
     const config = readInterfConfig(dirPath);
@@ -37,9 +37,9 @@ export function computeCompiledHealth(dirPath) {
     const firstFailed = stageResults.find((entry) => !entry.validation.ok) ?? null;
     const methodValidation = validateCompiledMethod(dirPath);
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const zoneMetrics = Object.fromEntries((schema?.zones ?? []).map((zone) => [
-        `zone_${zone.id}`,
-        countCompiledZoneArtifacts(dirPath, zone.path, zone.kind),
+    const artifactMetrics = Object.fromEntries((schema ? listCompiledSchemaArtifacts(schema) : []).map((artifact) => [
+        `artifact_${artifact.id}`,
+        countCompiledArtifactsAtPath(dirPath, artifact.path, artifact.kind),
     ]));
     let status = "idle";
     let stage = "idle";
@@ -98,7 +98,7 @@ export function computeCompiledHealth(dirPath) {
             completed_stages: completedStages,
             warnings: state?.warning_count ?? 0,
             errors: (state?.error_count ?? 0) + errors,
-            ...zoneMetrics,
+            ...artifactMetrics,
         },
         checks,
     };

package/dist/packages/{compiler → engine/compile}/state-io.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { warnInterf } from "../shared/logger.js";
-import { readJsonFileUnchecked, readJsonFileWithSchema } from "../shared/parse.js";
+import { warnInterf } from "../../contracts/utils/logger.js";
+import { readJsonFileUnchecked, readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { CompiledHealthSchema, CompiledStateSchema, CompiledViewSpecSchema, SourceFilesSchema, SourceSnapshotSchema, } from "./lib/schema.js";
 import { emptyCompiledInventory, } from "./runtime-inventory.js";
 import { healthPath, sourceFilesPath, sourceSnapshotPath, statePath, viewSpecPath, } from "./state-paths.js";

package/dist/packages/{compiler → engine/compile}/state-view.js

@@ -1,9 +1,9 @@
 import { basename } from "node:path";
-import { readInterfConfig, resolveSourceFolderPath } from "../project-model/interf-detect.js";
+import { readInterfConfig, resolveSourceFolderPath } from "../../project/interf-detect.js";
 import { loadCompiledSourceSnapshot, loadCompiledViewSpec, saveCompiledViewSpec, } from "./state-io.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../method-package/method-definitions.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig } from "../../methods/package/method-definitions.js";
 import { writeCompiledSourceFiles, writeCompiledSourceSnapshot, } from "./source-files.js";
 export function ensureCompiledViewSpec(dirPath) {
     const existing = loadCompiledViewSpec(dirPath);
@@ -63,10 +63,11 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
     resolveRequiredCompiledMethodFromConfig(config, `.interf/interf.json for ${dirPath}`);
     const method = getActiveCompiledMethod(dirPath);
     const schema = readCompiledSchemaFile(methodPackagePathForCompiled(dirPath));
-    const outputDocumentPaths = (schema?.zones ?? [])
-        .filter((zone) => zone.role === "output" && zone.kind !== "runtime")
-        .map((zone) => zone.path);
-    const defaultNote = (schema?.zones ?? []).find((zone) => zone.role === "output" && zone.kind === "file")?.path ?? null;
+    const schemaArtifacts = schema ? listCompiledSchemaArtifacts(schema) : [];
+    const outputDocumentPaths = schemaArtifacts
+        .filter((artifact) => artifact.role === "output" && artifact.kind !== "runtime")
+        .map((artifact) => artifact.path);
+    const defaultNote = schemaArtifacts.find((artifact) => artifact.role === "output" && artifact.kind === "file")?.path ?? null;
     return {
         kind: "compiled-view-spec",
         version: 2,
@@ -85,7 +86,7 @@ function buildDefaultCompiledViewSpec(dirPath, compiledName, generatedAt) {
             { id: "status", type: "status", title: "Compile Status", path: ".interf/runtime/health.json" },
             { id: "cards", type: "cards", title: "Key Metrics", path: ".interf/runtime/health.json" },
             ...(outputDocumentPaths.length > 0
-                ? [{ id: "outputs", type: "documents", title: "Output Zones", paths: outputDocumentPaths }]
+                ? [{ id: "outputs", type: "documents", title: "Output Artifacts", paths: outputDocumentPaths }]
                 : []),
             { id: "method", type: "documents", title: "Method Docs", paths: ["method/README.md", ...method.stages.map((stage) => `method/compile/stages/${stage.skillDir}`)] },
         ],

package/dist/packages/{compiler → engine/compile}/validate-compiled.js

@@ -1,13 +1,13 @@
 import { existsSync } from "node:fs";
 import { discoverSourceFiles } from "./discovery.js";
-import { METHOD_SCHEMA_FILE, findCompiledSchemaZone, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
-import { resolveSourceFolderPath } from "../project-model/interf-detect.js";
+import { METHOD_SCHEMA_FILE, findCompiledSchemaArtifact, readCompiledSchemaFile, methodSchemaExists, } from "./compiled-schema.js";
+import { resolveSourceFolderPath } from "../../project/interf-detect.js";
 import { compiledInterfConfigPath, methodPackagePathForCompiled } from "./compiled-paths.js";
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
-import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
-import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../method-package/method-definitions.js";
-import { countCompiledZoneArtifacts } from "./artifact-counts.js";
+import { getActiveCompiledMethod, resolveRequiredCompiledMethodFromConfig, } from "../../methods/package/method-definitions.js";
+import { countCompiledArtifactsAtPath } from "./artifact-counts.js";
+import { evaluateChecks } from "./check-evaluator.js";
 function methodSchemaPresent(dirPath) {
     return methodSchemaExists(methodPackagePathForCompiled(dirPath));
 }
@@ -45,23 +45,57 @@ function readMethodContext(dirPath) {
 function stageRequired(sourceTotal, writeCounts, stageRecordPresent) {
     return sourceTotal > 0 || writeCounts > 0 || stageRecordPresent;
 }
-function zoneWriteCount(compiledPath, schema, stage) {
-    const zoneCounts = {};
+function artifactWriteCount(compiledPath, schema, stage) {
+    const artifactCounts = {};
     let total = 0;
-    for (const zoneId of stage.writes) {
-        const zone = findCompiledSchemaZone(schema, zoneId);
-        if (!zone)
+    for (const artifactId of stage.writes) {
+        const artifact = findCompiledSchemaArtifact(schema, artifactId);
+        if (!artifact)
             continue;
-        const count = countCompiledZoneArtifacts(compiledPath, zone.path, zone.kind);
-        zoneCounts[zoneId] = count;
+        const count = countCompiledArtifactsAtPath(compiledPath, artifact.path, artifact.kind);
+        artifactCounts[artifactId] = count;
         total += count;
     }
-    return { total, zoneCounts };
+    return { total, artifactCounts };
 }
-function mergeValidationCounts(sourceTotal, stageRecord, zoneCounts) {
+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;
+}
+function artifactsBuiltByStage(schema, stage) {
+    return (schema.artifacts ?? []).filter((artifact) => {
+        if (artifact.built_by_stages.includes(stage.id))
+            return true;
+        if (stage.writes.includes(artifact.id))
+            return true;
+        return artifact.shape.kind === "path" && (stage.writes.includes(artifact.id) || stage.writes.includes(artifact.shape.path));
+    });
+}
+function artifactCheckFailures(compiledPath, artifacts, counts) {
+    const failures = [];
+    for (const artifact of artifacts) {
+        const checks = artifact.checks ?? [];
+        if (checks.length === 0)
+            continue;
+        const targetPath = artifact.shape.kind === "path" ? artifact.shape.path : undefined;
+        const result = evaluateChecks(checks, {
+            rootPath: compiledPath,
+            targetPath,
+            counts,
+        });
+        failures.push(...result.failures);
+    }
+    return failures;
+}
+function mergeValidationCounts(sourceTotal, stageRecord, artifactCounts) {
     const merged = {
         source_total: sourceTotal,
-        ...zoneCounts,
+        ...artifactCounts,
     };
     const stageCounts = stageRecord?.counts;
     if (stageCounts && typeof stageCounts === "object" && !Array.isArray(stageCounts)) {
@@ -121,22 +155,19 @@ export function validateCompiledStage(dirPath, stageId) {
     checks.stage_finished = Boolean(stageRecord?.finished_at);
     checks.stage_succeeded = stageRecord?.status === "succeeded";
     const writeCounts = methodStage && context.schema
-        ? zoneWriteCount(dirPath, context.schema, methodStage)
-        : { total: 0, zoneCounts: {} };
-    const acceptanceCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.zoneCounts);
+        ? artifactWriteCount(dirPath, context.schema, methodStage)
+        : { total: 0, artifactCounts: {} };
+    const artifactCounts = mergeValidationCounts(context.sourceTotal, stageRecord, writeCounts.artifactCounts);
     const required = stageRequired(context.sourceTotal, writeCounts.total, checks.stage_record_present);
-    let acceptanceErrors = [];
+    let artifactErrors = [];
     if (methodStage && context.schema) {
-        const acceptanceValidation = validateResolvedStageAcceptance(dirPath, {
-            stageId,
-            acceptance: methodStage.acceptance,
-            counts: acceptanceCounts,
-        });
-        checks.acceptance_ok = acceptanceValidation.ok;
-        acceptanceErrors = acceptanceValidation.failures;
+        const artifacts = artifactsBuiltByStage(context.schema, methodStage);
+        const failures = artifactCheckFailures(dirPath, artifacts, artifactCounts);
+        checks.artifact_checks_ok = failures.length === 0;
+        artifactErrors = failures.map((proof) => `Artifact check "${proof.check_id}" failed for ${proof.kind}: ${proof.summary}`);
     }
     else {
-        checks.acceptance_ok = false;
+        checks.artifact_checks_ok = false;
     }
     if (required && checks.stage_record_present && !checks.stage_finished) {
         errors.push(`Stage "${stageId}" has no finished_at proof in runtime state.`);
@@ -145,23 +176,23 @@ export function validateCompiledStage(dirPath, stageId) {
         errors.push(`Stage "${stageId}" is not marked succeeded in runtime state.`);
     }
     if (required) {
-        errors.push(...acceptanceErrors);
+        errors.push(...artifactErrors);
     }
     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."}`;
+            : `Stage "${stageId}" failed — ${errors[0] ?? "artifact checks not satisfied."}`;
     return {
         ok,
         required,
         stage: stageId,
         summary,
         counts: {
-            ...acceptanceCounts,
+            ...artifactCounts,
             write_artifacts: writeCounts.total,
-            declared_write_zones: methodStage?.writes.length ?? 0,
+            declared_write_artifacts: methodStage?.writes.length ?? 0,
         },
         checks,
         errors,
@@ -213,7 +244,7 @@ export function validateCompiledMethod(dirPath) {
         stage: failedStage,
         summary: ok
             ? `Compiled Method verified — ${completedStages}/${context.method.stages.length} stages satisfied.`
-            : `Compiled Method failed — ${errors[0] ?? "stage acceptance not satisfied."}`,
+            : `Compiled Method failed — ${errors[0] ?? "stage artifact checks not satisfied."}`,
         counts: {
             source_total: context.sourceTotal,
             stage_total: context.method.stages.length,

package/dist/packages/{compiler → engine/compile}/validate.d.ts

@@ -1,4 +1,4 @@
-import { readInterfConfig } from "../project-model/interf-detect.js";
+import { readInterfConfig } from "../../project/interf-detect.js";
 export declare function readCompiledConfig(dirPath: string): {
     present: boolean;
     valid: boolean;

package/dist/packages/{compiler → engine/compile}/validate.js

@@ -1,11 +1,10 @@
 import { existsSync, readFileSync, statSync, } from "node:fs";
 import { basename, dirname, extname, join, resolve } from "node:path";
-import { readCompiledSchemaFile } from "./compiled-schema.js";
-import { compiledKnowledgeRootPath } from "./compiled-schema.js";
+import { listCompiledSchemaArtifacts, readCompiledSchemaFile } from "./compiled-schema.js";
 import { methodPackagePathForCompiled } from "./compiled-paths.js";
-import { listFilesRecursive } from "../shared/filesystem.js";
-import { readInterfConfig } from "../project-model/interf-detect.js";
-import { parseJsonFrontmatter } from "../shared/parse.js";
+import { listFilesRecursive } from "../../contracts/utils/filesystem.js";
+import { readInterfConfig } from "../../project/interf-detect.js";
+import { parseJsonFrontmatter } from "../../contracts/utils/parse.js";
 import { compiledInterfConfigPath } from "./compiled-paths.js";
 const MIN_ABSTRACT_WORDS = 5;
 const WIKILINK_PATTERN = /!?\[\[([^[\]]+)\]\]/g;
@@ -53,8 +52,8 @@ export function validateSynthFiles(files, options) {
     };
 }
 export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots) {
-    const zonePathById = compiledZoneDirectoryPaths(compiledRoot);
-    const knowledgeRelativePrefixes = compiledKnowledgeRelativePrefixes(zonePathById);
+    const artifactPathById = compiledArtifactDirectoryPaths(compiledRoot);
+    const directoryLeafParents = compiledDirectoryLeafParents(artifactPathById);
     const noteIndex = new Set();
     for (const filePath of dedupeFiles(noteIndexRoots)) {
         for (const target of collectWikilinkTargets(filePath)) {
@@ -75,15 +74,15 @@ export function countBrokenWikilinks(compiledRoot, noteIndexRoots, linkScanRoots
             if (!target)
                 continue;
             if (target.includes("/")) {
-                if (!wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath)) {
+                if (!wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, filePath)) {
                     brokenLinks += 1;
                 }
                 continue;
             }
             if (!noteIndex.has(target.toLowerCase()) &&
                 !noteIndex.has(noteName(target).toLowerCase()) &&
-                !wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, filePath) &&
-                !wikilinkPathExists(compiledRoot, noteName(target), zonePathById, knowledgeRelativePrefixes, filePath)) {
+                !wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, filePath) &&
+                !wikilinkPathExists(compiledRoot, noteName(target), artifactPathById, directoryLeafParents, filePath)) {
                 brokenLinks += 1;
             }
         }
@@ -172,22 +171,25 @@ function countWords(text) {
 function noteName(filePath) {
     return basename(filePath, extname(filePath));
 }
-function wikilinkPathExists(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
-    return linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath)
+function wikilinkPathExists(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
+    return linkPathCandidates(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath)
         .some((candidate) => existsSync(candidate));
 }
-function linkPathCandidates(compiledRoot, target, zonePathById, knowledgeRelativePrefixes, sourceFilePath) {
+function linkPathCandidates(compiledRoot, target, artifactPathById, directoryLeafParents, sourceFilePath) {
     const candidates = new Set();
     addPathCandidate(candidates, join(compiledRoot, target));
     if (sourceFilePath && (target.startsWith("./") || target.startsWith("../"))) {
         addPathCandidateIfInside(candidates, compiledRoot, resolve(dirname(sourceFilePath), target));
     }
     const [firstSegment] = target.split("/");
-    if (firstSegment && knowledgeRelativePrefixes.has(firstSegment)) {
-        addPathCandidate(candidates, join(compiledKnowledgeRootPath(compiledRoot), target));
+    if (firstSegment) {
+        const parentPath = directoryLeafParents.get(firstSegment);
+        if (parentPath) {
+            addPathCandidate(candidates, join(compiledRoot, parentPath, target));
+        }
     }
     if (firstSegment) {
-        const normalizedPrefix = zonePathById.get(firstSegment);
+        const normalizedPrefix = artifactPathById.get(firstSegment);
         if (normalizedPrefix) {
             const remainder = target.slice(firstSegment.length).replace(/^\/+/, "");
             addPathCandidate(candidates, join(compiledRoot, normalizedPrefix, remainder));
@@ -206,24 +208,24 @@ function addPathCandidateIfInside(candidates, compiledRoot, absolutePath) {
         return;
     addPathCandidate(candidates, candidate);
 }
-function compiledZoneDirectoryPaths(compiledRoot) {
+function compiledArtifactDirectoryPaths(compiledRoot) {
     const methodRoot = methodPackagePathForCompiled(compiledRoot);
     const schema = readCompiledSchemaFile(methodRoot);
     if (!schema)
         return new Map();
-    return new Map(schema.zones
-        .filter((zone) => zone.kind === "directory")
-        .map((zone) => [zone.id, zone.path]));
+    return new Map(listCompiledSchemaArtifacts(schema)
+        .filter((artifact) => artifact.kind === "directory")
+        .map((artifact) => [artifact.id, artifact.path]));
 }
-function compiledKnowledgeRelativePrefixes(zonePathById) {
-    const prefixes = new Set();
-    for (const zonePath of zonePathById.values()) {
-        const [root, leaf, ...rest] = zonePath.split("/");
-        if (root !== "knowledge" || !leaf || rest.length > 0)
+function compiledDirectoryLeafParents(artifactPathById) {
+    const parents = new Map();
+    for (const artifactPath of artifactPathById.values()) {
+        const [root, leaf, ...rest] = artifactPath.split("/");
+        if (!root || !leaf || rest.length > 0)
             continue;
-        prefixes.add(leaf);
+        parents.set(leaf, root);
     }
-    return prefixes;
+    return parents;
 }
 function collectWikilinkTargets(filePath) {
     const targets = new Set();