@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/source-config.js

@@ -1,13 +1,15 @@
+import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { readInterfConfig, refreshWorkspaceBootstrapGuidance, resolveSourceControlPath, } from "./interf.js";
-import { seedWorkspaceWorkflowPackage } from "./interf-workflow-package.js";
+import { join, relative, resolve, sep } from "node:path";
+import { readInterfConfig, refreshCompiledBootstrapGuidance, } from "./interf.js";
+import { seedCompiledWorkflowPackage } from "./interf-workflow-package.js";
 import { readJsonFileWithSchema } from "./parse.js";
-import { getWorkspaceWorkflow } from "./workflow-definitions.js";
+import { getCompiledWorkflow } from "./workflow-definitions.js";
 import { SourceFolderConfigSchema, } from "./schema.js";
 import { slugify } from "./util.js";
-import { defaultControlPathForWorkspace, workspaceInterfConfigPath, workspaceInterfRoot, } from "./workspace-paths.js";
-export const SOURCE_FOLDER_CONFIG_FILE = "interf.config.json";
+import { assertPathWithinRoot } from "./util.js";
+import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "./compiled-paths.js";
+export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
 function sourceConfigPath(sourcePath) {
     return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
 }
@@ -31,17 +33,29 @@ function normalizeTruthChecks(cases) {
         };
     });
 }
+export function fingerprintTruthChecks(checks) {
+    const normalized = checks.map((check) => ({
+        question: check.question.trim(),
+        ...(check.answer ? { answer: check.answer.trim() } : {}),
+        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
+        ...(check.expect ? { expect: check.expect } : {}),
+    }));
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 16);
+}
 export function loadSourceFolderConfig(sourcePath) {
     const filePath = sourceConfigPath(sourcePath);
     if (!existsSync(filePath))
         return null;
-    return readJsonFileWithSchema(filePath, "source-folder config", SourceFolderConfigSchema);
+    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
 }
-export function listSourceWorkspaceConfigs(config) {
-    return config?.workspaces ?? [];
+export function listSourceDatasetConfigs(config) {
+    return config?.datasets ?? [];
 }
-export function resolveWorkspaceCompileMaxAttempts(workspaceConfig, override = null) {
-    const configured = override ?? workspaceConfig.max_attempts ?? null;
+export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_attempts ?? null;
     if (configured == null)
         return null;
     const normalized = Math.trunc(configured);
@@ -49,8 +63,8 @@ export function resolveWorkspaceCompileMaxAttempts(workspaceConfig, override = n
         return 1;
     return Math.min(5, normalized);
 }
-export function resolveWorkspaceCompileMaxLoops(workspaceConfig, override = null) {
-    const configured = override ?? workspaceConfig.max_loops ?? null;
+export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_loops ?? null;
     if (configured == null)
         return null;
     const normalized = Math.trunc(configured);
@@ -58,83 +72,86 @@ export function resolveWorkspaceCompileMaxLoops(workspaceConfig, override = null
         return 1;
     return Math.min(3, normalized);
 }
-export function getDefaultSourceWorkspaceConfig(config) {
-    const workspaces = listSourceWorkspaceConfigs(config);
-    return workspaces[0] ?? null;
+export function getDefaultSourceDatasetConfig(config) {
+    const datasets = listSourceDatasetConfigs(config);
+    return datasets[0] ?? null;
 }
-export function findSourceWorkspaceConfig(config, workspaceName) {
-    return listSourceWorkspaceConfigs(config).find((workspace) => workspace.name === workspaceName) ?? null;
+export function findSourceDatasetConfig(config, datasetName) {
+    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
 }
-function toWritableSourceFolderConfig(config) {
-    const workspaces = config?.workspaces ?? [];
-    if (workspaces.length > 0) {
+function toWritableSourceProjectConfig(config) {
+    const datasets = config?.datasets ?? [];
+    if (datasets.length > 0) {
         return {
-            workspaces: workspaces.map((workspace) => ({
-                name: workspace.name,
-                ...(workspace.about ? { about: workspace.about } : {}),
-                ...(workspace.workflow && workspace.workflow !== "interf" ? { workflow: workspace.workflow } : {}),
-                ...(typeof workspace.max_attempts === "number" ? { max_attempts: workspace.max_attempts } : {}),
-                ...(typeof workspace.max_loops === "number" ? { max_loops: workspace.max_loops } : {}),
-                checks: workspace.checks,
+            datasets: datasets.map((dataset) => ({
+                name: dataset.name,
+                ...(dataset.path && dataset.path !== "." ? { path: dataset.path } : {}),
+                ...(dataset.about ? { about: dataset.about } : {}),
+                ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
+                ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
+                ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
+                checks: dataset.checks,
             })),
         };
     }
     return {};
 }
 export function saveSourceFolderConfig(sourcePath, config) {
-    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceFolderConfig(config), null, 2) + "\n");
+    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
 }
-export function appendSourceWorkspaceChecks(sourcePath, workspaceName, checks) {
+export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const currentWorkspace = findSourceWorkspaceConfig(existing, workspaceName);
-    const otherWorkspaces = listSourceWorkspaceConfigs(existing).filter((workspace) => workspace.name !== workspaceName);
-    const currentChecks = currentWorkspace?.checks ?? [];
+    const currentDataset = findSourceDatasetConfig(existing, datasetName);
+    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
+    const currentChecks = currentDataset?.checks ?? [];
     saveSourceFolderConfig(sourcePath, {
-        workspaces: [
+        datasets: [
             {
-                name: workspaceName,
-                ...(currentWorkspace?.about ? { about: currentWorkspace.about } : {}),
-                ...(currentWorkspace?.workflow ? { workflow: currentWorkspace.workflow } : {}),
-                ...(typeof currentWorkspace?.max_attempts === "number"
-                    ? { max_attempts: currentWorkspace.max_attempts }
+                name: datasetName,
+                path: currentDataset?.path ?? ".",
+                ...(currentDataset?.about ? { about: currentDataset.about } : {}),
+                ...(currentDataset?.workflow ? { workflow: currentDataset.workflow } : {}),
+                ...(typeof currentDataset?.max_attempts === "number"
+                    ? { max_attempts: currentDataset.max_attempts }
                     : {}),
-                ...(typeof currentWorkspace?.max_loops === "number"
-                    ? { max_loops: currentWorkspace.max_loops }
+                ...(typeof currentDataset?.max_loops === "number"
+                    ? { max_loops: currentDataset.max_loops }
                     : {}),
                 checks: [...currentChecks, ...checks],
             },
-            ...otherWorkspaces,
+            ...otherDatasets,
         ],
     });
 }
-export function upsertSourceWorkspaceConfig(sourcePath, workspaceConfig, options = {}) {
+export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const workspaces = listSourceWorkspaceConfigs(existing);
-    const candidateNames = Array.from(new Set([workspaceConfig.name, options.matchName].filter((value) => Boolean(value))));
-    const existingIndex = workspaces.findIndex((entry) => candidateNames.includes(entry.name));
+    const datasets = listSourceDatasetConfigs(existing);
+    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
     if (existingIndex >= 0) {
-        workspaces[existingIndex] = workspaceConfig;
+        datasets[existingIndex] = datasetConfig;
     }
     else {
-        workspaces.push(workspaceConfig);
+        datasets.push(datasetConfig);
     }
     saveSourceFolderConfig(sourcePath, {
-        workspaces,
+        datasets,
     });
 }
-export function workspaceMaxAttempts(maxAttempts) {
+export function compiledMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
-    return resolveWorkspaceCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+    return resolveDatasetCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
 }
-export function workspaceMaxLoops(maxLoops) {
+export function compiledMaxLoops(maxLoops) {
     if (maxLoops == null)
         return undefined;
-    return resolveWorkspaceCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+    return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
 }
-export function sourceWorkspaceConfigFromInterfConfig(config) {
+export function sourceDatasetConfigFromInterfConfig(config, datasetPath = ".") {
     return {
         name: config.name,
+        path: datasetPath,
         ...(config.about ? { about: config.about } : {}),
         ...(config.workflow ? { workflow: config.workflow } : {}),
         ...(typeof config.max_attempts === "number"
@@ -146,18 +163,27 @@ export function sourceWorkspaceConfigFromInterfConfig(config) {
         checks: config.checks ?? [],
     };
 }
-export function loadWorkspaceControlConfig(workspacePath) {
-    const config = readInterfConfig(workspacePath);
-    return config ? sourceWorkspaceConfigFromInterfConfig(config) : null;
+export function loadCompiledDatasetConfig(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (!config)
+        return null;
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
+        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled dataset source path")).split(sep).join("/") || "."
+        : ".";
+    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
 }
-export function saveWorkspaceInterfConfig(workspacePath, config) {
-    mkdirSync(workspaceInterfRoot(workspacePath), { recursive: true });
-    writeFileSync(workspaceInterfConfigPath(workspacePath), JSON.stringify(config, null, 2) + "\n");
+export function saveCompiledInterfConfig(compiledPath, config) {
+    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
+    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
     return config;
 }
-export function syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath, workspaceConfig) {
-    const current = readInterfConfig(workspacePath);
-    const workflowId = workspaceConfig.workflow ?? current?.workflow ?? "interf";
+export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig) {
+    const current = readInterfConfig(compiledPath);
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const datasetAbsolutePath = resolve(projectPath, datasetConfig.path ?? ".");
+    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
+    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
     const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
     const workflowOrigin = workflowChanged || !current?.workflow_origin
         ? {
@@ -169,88 +195,100 @@ export function syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath
     const nextConfig = {
         ...passthrough,
         ...(!current ? {
-            type: "workspace",
+            type: "compiled",
             source: {
                 path: "./raw",
             },
         } : {}),
-        type: "workspace",
-        name: workspaceConfig.name,
-        ...(workspaceConfig.about ? { about: workspaceConfig.about } : {}),
+        type: "compiled",
+        name: datasetConfig.name,
+        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
         workflow: workflowId,
-        ...(typeof workspaceConfig.max_attempts === "number"
-            ? { max_attempts: workspaceConfig.max_attempts }
+        ...(typeof datasetConfig.max_attempts === "number"
+            ? { max_attempts: datasetConfig.max_attempts }
             : {}),
-        ...(typeof workspaceConfig.max_loops === "number"
-            ? { max_loops: workspaceConfig.max_loops }
+        ...(typeof datasetConfig.max_loops === "number"
+            ? { max_loops: datasetConfig.max_loops }
             : {}),
-        checks: workspaceConfig.checks,
+        checks: datasetConfig.checks,
         workflow_origin: workflowOrigin,
         source: {
             path: current?.source?.path ?? "./raw",
-            ...(current?.source?.control_path
-                ? { control_path: current.source.control_path }
-                : { control_path: defaultControlPathForWorkspace(workspacePath) }),
+            control_path: defaultControlPathForCompiled(compiledPath),
+            dataset_path: datasetRelativePath,
         },
     };
-    const saved = saveWorkspaceInterfConfig(workspacePath, nextConfig);
+    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
     if (workflowChanged) {
-        const sourcePath = resolveSourceControlPath(workspacePath);
-        const selectedWorkflow = getWorkspaceWorkflow(workflowId, { sourcePath });
-        seedWorkspaceWorkflowPackage({
-            workspacePath,
+        const sourcePath = projectPath;
+        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+        seedCompiledWorkflowPackage({
+            compiledPath,
             sourcePath,
             workflowId: selectedWorkflow.id,
         });
     }
-    refreshWorkspaceBootstrapGuidance(workspacePath);
+    refreshCompiledBootstrapGuidance(compiledPath);
     return saved;
 }
+function buildLoadedTestSpec(options) {
+    if (options.checks.length === 0)
+        return null;
+    const testId = options.id ?? slugify(options.name);
+    return {
+        id: options.targetType === "raw" ? `${testId}-raw` : testId,
+        filePath: options.filePath,
+        type: options.targetType,
+        name: options.name,
+        description: options.about ?? options.fallbackDescription,
+        cases: normalizeTruthChecks(options.checks),
+    };
+}
 export function buildTestSpecFromSourceFolderConfig(options) {
-    const { sourcePath, targetName, targetType = "workspace" } = options;
+    const { sourcePath, targetName, targetType = "compiled" } = options;
     const config = loadSourceFolderConfig(sourcePath);
     if (!config)
         return null;
-    const workspaces = listSourceWorkspaceConfigs(config);
-    if (workspaces.length === 0)
+    const datasets = listSourceDatasetConfigs(config);
+    if (datasets.length === 0)
         return null;
     const match = targetName
-        ? workspaces.find((entry) => entry.name === targetName)
-        : workspaces.length === 1
-            ? workspaces[0]
-            : getDefaultSourceWorkspaceConfig(config);
-    const workspaceChecks = match?.checks ?? [];
-    if (!match || workspaceChecks.length === 0)
+        ? datasets.find((entry) => entry.name === targetName)
+        : datasets.length === 1
+            ? datasets[0]
+            : getDefaultSourceDatasetConfig(config);
+    if (!match)
         return null;
     const configPath = sourceConfigPath(sourcePath);
-    const testId = match.id ?? slugify(match.name);
-    return {
-        id: targetType === "raw" ? `${testId}-raw` : testId,
-        filePath: targetType === "raw"
-            ? `${configPath}#workspaces/${match.name}:raw`
-            : `${configPath}#workspaces/${match.name}`,
-        type: targetType,
+    return buildLoadedTestSpec({
+        id: match.id,
         name: match.name,
-        description: match.about ?? `Derived from dataset truth checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
-        cases: normalizeTruthChecks(workspaceChecks),
-    };
+        about: match.about,
+        checks: match.checks,
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#datasets/${match.name}:file-as-is`
+            : `${configPath}#datasets/${match.name}:compiled`,
+        fallbackDescription: `Derived from dataset truth checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
+    });
 }
-export function buildTestSpecFromWorkspaceConfig(options) {
-    const { workspacePath, targetType = "workspace" } = options;
-    const config = readInterfConfig(workspacePath);
-    const workspaceChecks = config?.checks ?? [];
-    if (!config || workspaceChecks.length === 0)
+export function buildTestSpecFromCompiledDatasetConfig(options) {
+    const { compiledPath, targetType = "compiled" } = options;
+    const config = readInterfConfig(compiledPath);
+    const configPath = compiledInterfConfigPath(compiledPath);
+    if (!config)
         return null;
-    const testId = slugify(config.name);
-    const configPath = workspaceInterfConfigPath(workspacePath);
-    return {
-        id: targetType === "raw" ? `${testId}-raw` : testId,
-        filePath: targetType === "raw"
-            ? `${configPath}#checks:raw`
-            : `${configPath}#checks:workspace`,
-        type: targetType,
+    return buildLoadedTestSpec({
         name: config.name,
-        description: config.about ?? "Derived from workspace truth checks.",
-        cases: normalizeTruthChecks(workspaceChecks),
-    };
+        about: config.about,
+        checks: config.checks ?? [],
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#checks:file-as-is`
+            : `${configPath}#checks:compiled`,
+        fallbackDescription: "Derived from compiled-dataset truth checks.",
+    });
+}
+export function resolveSourceDatasetPath(projectPath, datasetConfig) {
+    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path ?? "."), "Dataset path");
 }

package/dist/lib/state-artifacts.d.ts

@@ -1,8 +1,8 @@
-import { type WorkspaceHealth, type WorkspaceRawSnapshot, type WorkspaceViewSpec } from "./schema.js";
-export declare function refreshWorkspaceArtifacts(dirPath: string, options?: {
+import { type CompiledHealth, type CompiledRawSnapshot, type CompiledViewSpec } from "./schema.js";
+export declare function refreshCompiledArtifacts(dirPath: string, options?: {
     ensureViewSpec?: boolean;
 }): {
-    health: WorkspaceHealth;
-    viewSpec?: WorkspaceViewSpec;
-    rawSnapshot: WorkspaceRawSnapshot;
+    health: CompiledHealth;
+    viewSpec?: CompiledViewSpec;
+    rawSnapshot: CompiledRawSnapshot;
 };

package/dist/lib/state-artifacts.js

@@ -1,13 +1,13 @@
-import { saveWorkspaceHealth, } from "./state-io.js";
-import { computeWorkspaceHealth, } from "./state-health.js";
-import { ensureWorkspaceRawSnapshot, ensureWorkspaceViewSpec, } from "./state-view.js";
-export function refreshWorkspaceArtifacts(dirPath, options) {
-    const health = computeWorkspaceHealth(dirPath);
-    saveWorkspaceHealth(dirPath, health);
-    const rawSnapshot = ensureWorkspaceRawSnapshot(dirPath);
+import { saveCompiledHealth, } from "./state-io.js";
+import { computeCompiledHealth, } from "./state-health.js";
+import { ensureCompiledRawSnapshot, ensureCompiledViewSpec, } from "./state-view.js";
+export function refreshCompiledArtifacts(dirPath, options) {
+    const health = computeCompiledHealth(dirPath);
+    saveCompiledHealth(dirPath, health);
+    const rawSnapshot = ensureCompiledRawSnapshot(dirPath);
     let viewSpec;
     if (options?.ensureViewSpec) {
-        viewSpec = ensureWorkspaceViewSpec(dirPath);
+        viewSpec = ensureCompiledViewSpec(dirPath);
     }
     return { health, viewSpec, rawSnapshot };
 }

package/dist/lib/state-health.d.ts

@@ -1,4 +1,4 @@
-import { type WorkspaceHealth, type WorkspaceState, type WorkspaceStage, type RuntimeStatus } from "./schema.js";
-export declare function computeWorkspaceHealth(dirPath: string): WorkspaceHealth;
-export declare function resolveWorkspaceStatus(sourceTotal: number, summarized: number, toSummarize: number, toStructure: number, toShape: number, errors: number, state: WorkspaceState): RuntimeStatus;
-export declare function resolveWorkspaceStage(state: WorkspaceState, sourceTotal: number, summarized: number, toSummarize: number, toStructure: number, toShape: number, errors: number): WorkspaceStage;
+import { type CompiledHealth, type CompiledStage, type RuntimeStatus } from "./schema.js";
+export declare function computeCompiledHealth(dirPath: string): CompiledHealth;
+export declare function resolveCompiledStatus(..._args: unknown[]): RuntimeStatus;
+export declare function resolveCompiledStage(...args: unknown[]): CompiledStage;