@interf/compiler 0.5.0 → 0.5.1

package/dist/lib/summarize-plan.js

@@ -108,11 +108,7 @@ function readSourceReference(synthPath) {
     const parsed = parseJsonFrontmatter(content);
     const source = typeof parsed?.frontmatter.source === "string"
         ? parsed.frontmatter.source
-        : typeof parsed?.frontmatter.source_file === "string"
-            ? parsed.frontmatter.source_file
-            : typeof parsed?.frontmatter.raw === "string"
-                ? parsed.frontmatter.raw
-                : null;
+        : null;
     return source?.trim() ?? null;
 }
 function defaultSummaryPath(sourcePath) {

package/dist/lib/test-paths.js

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "./compiled-paths.js";
 const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
@@ -9,11 +9,17 @@ export function testSpecRootPath(sourcePath) {
 export function testSpecTypePath(sourcePath, type) {
     return join(testSpecRootPath(sourcePath), type);
 }
+function isDatasetTestsRootPath(artifactRootPath) {
+    return basename(dirname(artifactRootPath)) === "tests";
+}
 export function targetTestRunsPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestRunsRootForCompiled(compiledPath), type);
     }
-    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "runs");
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
 }
 export function targetTestRunGitignorePath(compiledPath, type) {
     return join(targetTestRunsPath(compiledPath, type), ".gitignore");
@@ -22,7 +28,10 @@ export function targetTestSandboxesPath(compiledPath, type) {
     if (existsSync(compiledInterfConfigPath(compiledPath))) {
         return join(targetTestSandboxesRootForCompiled(compiledPath), type);
     }
-    return join(compiledPath, "tests", type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled dataset or interf/tests/<dataset> root.`);
 }
 export function targetTestSandboxGitignorePath(compiledPath, type) {
     return join(targetTestSandboxesPath(compiledPath, type), ".gitignore");

package/dist/lib/test-sandbox.js

@@ -2,10 +2,10 @@ import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "./interf-bootstrap.js";
-import { readInterfConfig, resolveSourceControlPath, resolveCompiledRawPath } from "./interf.js";
+import { readInterfConfig, resolveCompiledRawPath } from "./interf.js";
 import { projectRawTestQueryShell } from "./agent-shells.js";
 import { compiledCompiledPathForDataset } from "./project-paths.js";
-import { findSourceDatasetConfig, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { saveCompiledInterfConfig } from "./source-config.js";
 import { refreshCompiledArtifacts } from "./state.js";
 import { projectRawSnapshot } from "./compiled-raw.js";
 import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "./compiled-paths.js";
@@ -46,27 +46,14 @@ export function createTestSandbox(target) {
                 throw new Error(`Sandbox compiled is missing interf.json: ${sandboxTargetPath()}`);
             }
             if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
-                const projectPath = resolveSourceControlPath(target.path);
-                const projectConfig = loadSourceFolderConfig(projectPath);
-                const datasetConfig = findSourceDatasetConfig(projectConfig, sandboxConfig.name);
-                if (!datasetConfig) {
-                    throw new Error(`Sandbox compiled is missing a trusted dataset binding for "${sandboxConfig.name}": ${target.path}`);
-                }
-                const controlSourcePath = resolveSourceDatasetPath(projectPath, datasetConfig);
-                projectRawSnapshot({
-                    sourcePath: controlSourcePath,
-                    destinationPath: sandboxRawPath(),
-                    compiledPath: target.path,
-                    mode: "link-or-copy",
-                    prune: false,
-                    preserveTimestamps: false,
-                });
+                throw new Error(`Sandbox compiled is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled dataset before testing it.`);
             }
             saveCompiledInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
                 checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
             });
             refreshCompiledBootstrapGuidance(sandboxTargetPath());

package/dist/lib/test-specs.js

@@ -21,7 +21,7 @@ function serializeTestSpec(spec) {
         type: spec.type,
         name: spec.name,
         ...(spec.description ? { description: spec.description } : {}),
-        checks: spec.cases.map((testCase) => ({
+        cases: spec.cases.map((testCase) => ({
             id: testCase.id,
             question: testCase.question,
             ...(testCase.file ? { file: testCase.file } : {}),

package/dist/lib/validate-compiled.js

@@ -7,7 +7,7 @@ import { compiledInterfConfigPath, workflowPackagePathForCompiled } from "./comp
 import { readCompiledConfig } from "./validate.js";
 import { loadState } from "./state.js";
 import { validateResolvedStageAcceptance, stageRecordFromState } from "./runtime-acceptance.js";
-import { getActiveCompiledWorkflow, resolveCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
+import { getActiveCompiledWorkflow, resolveRequiredCompiledWorkflowFromConfig, } from "./workflow-definitions.js";
 import { listFilesRecursive } from "./filesystem.js";
 function countZoneArtifacts(compiledPath, zonePath, kind) {
     const absolutePath = compiledZoneAbsolutePath(compiledPath, { path: zonePath });
@@ -19,7 +19,9 @@ function countZoneArtifacts(compiledPath, zonePath, kind) {
 }
 function readWorkflowContext(dirPath) {
     const config = readCompiledConfig(dirPath);
-    const workflowId = config.valid ? resolveCompiledWorkflowFromConfig(config.value) : null;
+    const workflowId = config.valid
+        ? resolveRequiredCompiledWorkflowFromConfig(config.value, `.interf/interf.json for ${dirPath}`)
+        : null;
     let workflow = null;
     if (workflowId) {
         try {

package/dist/lib/validate.d.ts

@@ -13,5 +13,7 @@ export declare function countBrokenWikilinks(compiledRoot: string, noteIndexRoot
 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";

package/dist/lib/validate.js

@@ -48,7 +48,7 @@ export function validateSynthFiles(files) {
             invalidFrontmatter += 1;
             continue;
         }
-        const abstractWords = countAbstractWords(parsed.frontmatter, parsed.body);
+        const abstractWords = countSynthAbstractWords(parsed.frontmatter, parsed.body);
         if (abstractWords < MIN_ABSTRACT_WORDS) {
             shortAbstracts += 1;
         }
@@ -139,21 +139,36 @@ function dedupeFiles(dirPaths) {
     return files;
 }
 function hasRequiredSynthFields(frontmatter) {
-    const hasSourceReference = "source" in frontmatter || "source_file" in frontmatter || "raw" in frontmatter;
+    const hasSourceReference = "source" in frontmatter;
     return hasSourceReference && REQUIRED_DIGEST_FIELDS.every((field) => field in frontmatter);
 }
-function countAbstractWords(frontmatter, body) {
-    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract : null;
-    if (frontmatterAbstract && frontmatterAbstract.trim().length > 0) {
-        return countWords(frontmatterAbstract);
+function extractBodyAbstract(body) {
+    const lines = body.split(/\r?\n/);
+    const abstractHeadingIndex = lines.findIndex((line) => /^#{1,2}\s+Abstract\s*$/.test(line.trim()));
+    if (abstractHeadingIndex < 0)
+        return null;
+    const abstractLines = [];
+    for (let index = abstractHeadingIndex + 1; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (/^#{1,2}\s+\S/.test(line.trim()))
+            break;
+        abstractLines.push(line);
     }
-    const match = body.match(/^## Abstract\s+([\s\S]*?)(?:\n## |\n# |$)/m);
-    if (!match)
-        return 0;
-    const abstractText = match[1];
-    if (!abstractText)
+    const abstractText = abstractLines.join("\n").trim();
+    return abstractText.length > 0 ? abstractText : null;
+}
+export function extractSynthAbstract(frontmatter, body) {
+    const frontmatterAbstract = typeof frontmatter.abstract === "string" ? frontmatter.abstract.trim() : "";
+    if (frontmatterAbstract.length > 0) {
+        return frontmatterAbstract;
+    }
+    return extractBodyAbstract(body);
+}
+export function countSynthAbstractWords(frontmatter, body) {
+    const abstract = extractSynthAbstract(frontmatter, body);
+    if (!abstract)
         return 0;
-    return countWords(abstractText);
+    return countWords(abstract);
 }
 function countWords(text) {
     return text

package/dist/lib/workflow-definitions.d.ts

@@ -48,8 +48,9 @@ export declare function getCompiledWorkflow(workflowId: CompiledWorkflowId, opti
     sourcePath?: string;
 }): WorkflowDefinition<string>;
 export declare function getActiveCompiledWorkflow(compiledPath: string, fallbackWorkflowId: CompiledWorkflowId): WorkflowDefinition<string>;
-export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId;
-export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId;
+export declare function resolveCompiledWorkflowId(value: unknown): CompiledWorkflowId | null;
+export declare function resolveCompiledWorkflowFromConfig(config: unknown): CompiledWorkflowId | null;
+export declare function resolveRequiredCompiledWorkflowFromConfig(config: unknown, label?: string): CompiledWorkflowId;
 export declare function formatCompiledWorkflowStageStep(workflowId: CompiledWorkflowId, stage: string, options?: {
     sourcePath?: string;
 }): string;

package/dist/lib/workflow-definitions.js

@@ -133,14 +133,21 @@ export function resolveCompiledWorkflowId(value) {
     if (typeof value === "string" && isWorkflowId(value)) {
         return value;
     }
-    return "interf";
+    return null;
 }
 export function resolveCompiledWorkflowFromConfig(config) {
     if (!config || typeof config !== "object")
-        return "interf";
+        return null;
     const raw = config;
     return resolveCompiledWorkflowId(raw.workflow);
 }
+export function resolveRequiredCompiledWorkflowFromConfig(config, label = "compiled config") {
+    const workflowId = resolveCompiledWorkflowFromConfig(config);
+    if (!workflowId) {
+        throw new Error(`Missing or invalid workflow in ${label}.`);
+    }
+    return workflowId;
+}
 export function formatCompiledWorkflowStageStep(workflowId, stage, options = {}) {
     return formatWorkflowStageStep(getCompiledWorkflow(workflowId, options), stage);
 }

package/dist/lib/workflow-primitives.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPILED_ZONE_KINDS: readonly ["directory", "file", "runtime"];
+export type CompiledZoneKind = typeof COMPILED_ZONE_KINDS[number];

package/dist/lib/workflow-primitives.js

@@ -0,0 +1,5 @@
+export const COMPILED_ZONE_KINDS = [
+    "directory",
+    "file",
+    "runtime",
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@interf/compiler",
-  "version": "0.5.0",
-  "description": "Interf Compiler is a local runtime for data-processing workflows that turn datasets into compiled datasets for local agents.",
+  "version": "0.5.1",
+  "description": "Interf Compiler is a local runtime for data-processing workflows that prepare datasets for accurate local agent use.",
   "type": "module",
   "bin": {
     "interf": "dist/bin.js"
@@ -37,11 +37,11 @@
     "test:internal:cbre:max:keep": "npm run test:matrix -- --matrix internal/test-matrices/cbre-chart-tier1-max.json --keep-project-clones",
     "test:full": "npm test && npm run test:e2e:quick:matrix",
     "test:release:matrix": "npm run test:internal:cbre:max",
-    "test:release": "npm test && npm run test:e2e:claude && npm run test:e2e:codex",
+    "test:release": "npm test && npm run test:acceptance-live -- --agent claude-code --with-test && npm run test:acceptance-live -- --agent codex --with-test",
     "test:acceptance-live": "npm run build && node scripts/acceptance-live.mjs",
-    "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude",
-    "test:acceptance-cache:refresh:claude": "npm run build && node scripts/acceptance-live.mjs --agent claude-code --output-root .interf-test-cache/claude-code",
-    "test:acceptance-cache:refresh:codex": "npm run build && node scripts/acceptance-live.mjs --agent codex --output-root .interf-test-cache/codex",
+    "test:acceptance-cache:refresh": "npm run test:acceptance-cache:refresh:claude && npm run test:acceptance-cache:refresh:codex",
+    "test:acceptance-cache:refresh:claude": "node scripts/acceptance-cache-refresh.mjs --agent claude-code",
+    "test:acceptance-cache:refresh:codex": "node scripts/acceptance-cache-refresh.mjs --agent codex",
     "test:acceptance-quick:create-compiled": "npm run build && node scripts/acceptance-targeted.mjs create-compiled",
     "test:acceptance-quick:compiled-query": "npm run build && node scripts/acceptance-targeted.mjs compiled-query",
     "test:acceptance-quick:self-improving": "npm run build && node scripts/acceptance-targeted.mjs self-improving-compile",

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

@@ -1,2 +0,0 @@
-export declare function normalizeLegacyCompiledLayout(compiledPath: string): boolean;
-export declare function compiledNeedsLegacyLayoutNormalization(compiledPath: string): boolean;

package/dist/lib/compiled-layout.js

@@ -1,60 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, renameSync, } from "node:fs";
-import { dirname, join } from "node:path";
-import { COMPILED_CONFIG_FILE, COMPILED_INTERF_DIR, COMPILED_RUNTIME_DIR, COMPILED_TEST_DIR, COMPILED_WORKFLOW_DIR, workflowPackagePathForCompiled, compiledInterfConfigPath, compiledInterfRoot, compiledRuntimeRoot, } from "./compiled-paths.js";
-const LEGACY_COMPILED_CONFIG_FILE = "interf.json";
-const LEGACY_WORKFLOW_DIR = "workflow";
-function movePathIfMissing(sourcePath, targetPath) {
-    if (!existsSync(sourcePath)) {
-        return false;
-    }
-    if (existsSync(targetPath)) {
-        return false;
-    }
-    mkdirSync(dirname(targetPath), { recursive: true });
-    renameSync(sourcePath, targetPath);
-    return true;
-}
-export function normalizeLegacyCompiledLayout(compiledPath) {
-    const interfRoot = compiledInterfRoot(compiledPath);
-    const runtimeRoot = compiledRuntimeRoot(compiledPath);
-    let changed = false;
-    changed = movePathIfMissing(join(compiledPath, LEGACY_COMPILED_CONFIG_FILE), compiledInterfConfigPath(compiledPath)) || changed;
-    changed = movePathIfMissing(join(compiledPath, LEGACY_WORKFLOW_DIR), workflowPackagePathForCompiled(compiledPath)) || changed;
-    if (!existsSync(interfRoot)) {
-        return changed;
-    }
-    for (const entry of readdirSync(interfRoot)) {
-        if (entry === COMPILED_RUNTIME_DIR ||
-            entry === COMPILED_TEST_DIR ||
-            entry === COMPILED_WORKFLOW_DIR ||
-            entry === COMPILED_CONFIG_FILE) {
-            continue;
-        }
-        changed = movePathIfMissing(join(interfRoot, entry), join(runtimeRoot, entry)) || changed;
-    }
-    return changed;
-}
-export function compiledNeedsLegacyLayoutNormalization(compiledPath) {
-    if (existsSync(join(compiledPath, LEGACY_COMPILED_CONFIG_FILE)) &&
-        !existsSync(compiledInterfConfigPath(compiledPath))) {
-        return true;
-    }
-    if (!existsSync(join(compiledPath, COMPILED_INTERF_DIR)))
-        return false;
-    if (existsSync(join(compiledPath, LEGACY_WORKFLOW_DIR)) &&
-        !existsSync(workflowPackagePathForCompiled(compiledPath))) {
-        return true;
-    }
-    for (const entry of readdirSync(join(compiledPath, COMPILED_INTERF_DIR))) {
-        if (entry === COMPILED_RUNTIME_DIR ||
-            entry === COMPILED_TEST_DIR ||
-            entry === COMPILED_WORKFLOW_DIR ||
-            entry === COMPILED_CONFIG_FILE) {
-            continue;
-        }
-        if (!existsSync(join(compiledRuntimeRoot(compiledPath), entry))) {
-            return true;
-        }
-    }
-    return false;
-}