@interf/compiler 0.5.0 → 0.6.1

package/builtin-workflows/interf/{compiled.schema.json → workflow.schema.json}

@@ -1,11 +1,12 @@
 {
-  "kind": "compiled-schema",
+  "kind": "workflow-schema",
   "version": 1,
   "target_type": "compiled",
-  "label": "Interf Compiler (Recommended) compiled dataset schema",
+  "label": "Interf built-in workflow schema",
   "zones": [
     {
       "id": "raw",
+      "role": "input",
       "path": "raw",
       "kind": "directory",
       "required": true,
@@ -14,6 +15,7 @@
     },
     {
       "id": "summaries",
+      "role": "working",
       "path": "summaries",
       "kind": "directory",
       "required": true,
@@ -24,6 +26,7 @@
     },
     {
       "id": "knowledge-entities",
+      "role": "output",
       "path": "knowledge/entities",
       "kind": "directory",
       "required": true,
@@ -34,6 +37,7 @@
     },
     {
       "id": "knowledge-claims",
+      "role": "output",
       "path": "knowledge/claims",
       "kind": "directory",
       "required": true,
@@ -44,6 +48,7 @@
     },
     {
       "id": "knowledge-indexes",
+      "role": "output",
       "path": "knowledge/indexes",
       "kind": "directory",
       "required": true,
@@ -55,6 +60,7 @@
     },
     {
       "id": "home",
+      "role": "output",
       "path": "home.md",
       "kind": "file",
       "required": true,
@@ -65,6 +71,7 @@
     },
     {
       "id": "runtime",
+      "role": "runtime",
       "path": ".interf/runtime",
       "kind": "runtime",
       "required": true,

package/dist/commands/check-draft.js

@@ -12,18 +12,18 @@ export function buildTruthCheckDraftPrompt(options) {
     const taskLines = normalizedAbout
         ? [
             `Primary task: ${normalizedAbout}`,
-            "Draft checks that directly measure whether a local agent would be accurate on that task.",
+            "Draft checks that directly measure whether a local agent can answer the key questions from the data behind that task.",
             "Prefer checks that would make a human confident the dataset is useful for that exact job.",
         ]
         : [
             "No primary task was provided.",
-            "Prefer broad, representative checks that reflect the most useful questions this dataset should answer.",
+            "Prefer broad, representative checks that reflect the most useful questions a human would verify from this dataset.",
         ];
     return [
         "You are drafting Interf truth checks for a local dataset.",
         "Read the files in this folder and draft a small set of checks that a human can verify from the source material.",
         "Do not ask follow-up questions.",
-        "Keep the checks concrete, explicit, and useful for measuring agent accuracy on this dataset.",
+        "Keep the checks concrete, explicit, and useful for measuring whether an agent can reason correctly over the data in this dataset.",
         "",
         `Dataset id: ${options.datasetName}`,
         `Dataset folder: ${options.datasetPath}`,

package/dist/commands/compile-controller.js

@@ -3,30 +3,23 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../lib/interf.js";
-import { resetCompiledGeneratedState } from "../lib/compiled-reset.js";
-import { formatActiveCompiledWorkflowStageStep, resolveCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
+import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../lib/compiled-reset.js";
+import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../lib/workflow-definitions.js";
 import { resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { runWorkflowImprovementLoop } from "../lib/workflow-improvement.js";
 import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../lib/compiled-paths.js";
 import { readCompiledSchemaFile } from "../lib/compiled-schema.js";
+import { initializeCompiledRuntimeState } from "../lib/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
 import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
-    const workflowId = resolveCompiledWorkflowFromConfig(readInterfConfig(compiledPath));
+    const workflowId = resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
     const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, workflowId, failedStage ?? "compile");
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
-const BEST_VARIATION_RUNTIME_RESTORE_PATHS = [
-    ".interf/runtime/state.json",
-    ".interf/runtime/health.json",
-    ".interf/runtime/view-spec.json",
-    ".interf/runtime/inventory.json",
-    ".interf/runtime/run.json",
-    ".interf/runtime/raw-snapshot.json",
-];
 function bestVariationRestorePaths(compiledPath) {
     const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
@@ -39,10 +32,8 @@ function bestVariationRestorePaths(compiledPath) {
         ".codex",
         ".agents",
         ".cursor",
-        ".obsidian",
         ".interf/interf.json",
         ".interf/workflow",
-        ...BEST_VARIATION_RUNTIME_RESTORE_PATHS,
         ...zonePaths,
     ];
 }
@@ -71,6 +62,8 @@ function restoreCompiledBestState(snapshotPath, compiledPath) {
         rmSync(join(compiledPath, relativePath), { recursive: true, force: true });
         copyRelativePathIfPresent(snapshotPath, compiledPath, relativePath);
     }
+    clearCompiledRuntimeDerivedArtifacts(compiledPath);
+    initializeCompiledRuntimeState(compiledPath);
 }
 async function runWorkflowVariation(options) {
     let bestOutcome = null;
@@ -267,14 +260,14 @@ export async function runConfiguredCompiledCompile(options) {
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf Compiler will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same workflow variation, test the compiled dataset, and stop early if it passes."));
         }
         else {
             console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
         }
         if (maxLoops != null) {
             console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
-            console.log(chalk.dim("  Interf Compiler will review failed runs, edit the workflow package, and test new workflow variations."));
+            console.log(chalk.dim("  Interf will review failed runs, edit the workflow, and test new workflow variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
@@ -362,7 +355,7 @@ export async function runConfiguredCompiledCompile(options) {
                 const improvement = await runWorkflowImprovementLoop({
                     executor: options.executor,
                     compiledPath: options.compiledPath,
-                    workflowId: resolveCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath)),
+                    workflowId: resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
                     compiledConfig,
                     runId: improvementRunId,
                     loopIndex,

package/dist/commands/compile.d.ts

@@ -1,8 +1,26 @@
+import * as p from "@clack/prompts";
+import { detectInterf } from "../lib/interf.js";
 import type { SourceDatasetConfig } from "../lib/schema.js";
 import type { CommandModule } from "yargs";
+import { chooseCompiledConfigToBuild, ensureCompiledFromConfig } from "./compiled-flow.js";
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export declare const compileCommand: CommandModule;
-export declare function runCompileCommand(argv?: Record<string, unknown>): Promise<void>;
+interface CompileCommandDeps {
+    chooseCompiledConfigToBuild: typeof chooseCompiledConfigToBuild;
+    confirm: typeof p.confirm;
+    detectInterf: typeof detectInterf;
+    ensureCompiledFromConfig: typeof ensureCompiledFromConfig;
+    resolveInteractiveCompileLoopOverrides: typeof resolveInteractiveCompileLoopOverrides;
+    resolveOrConfigureLocalExecutor: typeof resolveOrConfigureLocalExecutor;
+    runConfiguredCompiledCompile: typeof runConfiguredCompiledCompile;
+}
+export interface CompileCommandResult {
+    compiledPath: string;
+    testedDuringCompile: boolean;
+}
+export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
 export declare function resolveInteractiveCompileLoopOverrides(options: {
     compiledPath: string;
     compiledConfig: SourceDatasetConfig | null;

package/dist/commands/compile.js

@@ -1,16 +1,17 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, readInterfConfig, resolveSourceControlPath, } from "../lib/interf.js";
-import { sourceDatasetConfigFromInterfConfig, } from "../lib/source-config.js";
+import { sourceDatasetConfigFromInterfConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../lib/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../lib/execution-profile.js";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig, } from "./compiled-flow.js";
+import { resolveConfiguredDatasetSelection } from "./dataset-selection.js";
 import { promptCompileLoopSelection, } from "./source-config-wizard.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
 import { runConfiguredCompiledCompile } from "./compile-controller.js";
 export { runConfiguredCompiledCompile } from "./compile-controller.js";
 export const compileCommand = {
     command: "compile",
-    describe: "Build the compiled dataset for the selected dataset",
+    describe: "Build a compiled dataset and optionally run retry or self-improving compile loops",
     builder: (yargs) => addExecutionProfileOptions(yargs).option("max-attempts", {
         type: "number",
         describe: "Retry compile + test for the same workflow until the dataset passes or reaches this total attempt limit",
@@ -26,48 +27,105 @@ export const compileCommand = {
         await runCompileCommand(argv);
     },
 };
-export async function runCompileCommand(argv = {}) {
+const defaultCompileCommandDeps = {
+    chooseCompiledConfigToBuild,
+    confirm: p.confirm,
+    detectInterf,
+    ensureCompiledFromConfig,
+    resolveInteractiveCompileLoopOverrides,
+    resolveOrConfigureLocalExecutor,
+    runConfiguredCompiledCompile,
+};
+function readHintedSourcePath(argv) {
+    return typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
+        ? argv.sourcePath.trim()
+        : null;
+}
+function readRequestedDatasetName(argv) {
+    return typeof argv.dataset === "string" && argv.dataset.trim().length > 0
+        ? argv.dataset.trim()
+        : null;
+}
+function shouldSkipCompileConfirm(argv) {
+    return argv.skipConfirm === true;
+}
+function shouldSkipDatasetBanner(argv) {
+    return argv.skipDatasetBanner === true;
+}
+function compileRunTests(options) {
+    const checks = options.compiledConfig?.checks ?? [];
+    if (checks.length === 0)
+        return false;
+    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
+    return maxAttempts != null;
+}
+export async function runCompileCommand(argv = {}, deps = {}) {
+    const helpers = {
+        ...defaultCompileCommandDeps,
+        ...deps,
+    };
     let compiledPath = null;
-    let sourcePath = process.cwd();
+    const hintedSourcePath = readHintedSourcePath(argv);
+    const detected = hintedSourcePath ? null : helpers.detectInterf(process.cwd());
+    let sourcePath = hintedSourcePath ?? process.cwd();
     let compiledConfig = null;
-    const detected = detectInterf(process.cwd());
+    const requestedDatasetName = readRequestedDatasetName(argv);
+    const hintedDatasetConfig = (argv.datasetConfig ?? null);
+    const skipConfirm = shouldSkipCompileConfirm(argv);
+    const skipDatasetBanner = shouldSkipDatasetBanner(argv);
     if (detected) {
         compiledPath = detected.path;
         sourcePath = resolveSourceControlPath(detected.path);
         compiledConfig = sourceDatasetConfigFromInterfConfig(detected.config);
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            const confirmed = await p.confirm({
+        if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
+            const confirmed = await helpers.confirm({
                 message: `Compile dataset "${detected.config.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
-                return;
+                return null;
         }
     }
     else {
-        const selectedCompiled = await chooseCompiledConfigToBuild({
-            sourcePath: process.cwd(),
-            selectMessage: "Which dataset do you want to compile?",
-        });
+        const selectedCompiled = requestedDatasetName || hintedDatasetConfig
+            ? resolveConfiguredDatasetSelection({
+                sourcePath,
+                requestedDatasetName,
+                hintedDatasetConfig,
+            })
+            : await helpers.chooseCompiledConfigToBuild({
+                sourcePath,
+                selectMessage: "Which dataset do you want to compile?",
+            });
         if (selectedCompiled === undefined)
-            return;
+            return null;
         if (!selectedCompiled) {
             process.exitCode = 1;
-            console.log(chalk.red("  No datasets are set up for this folder yet."));
-            console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
-            return;
+            if (requestedDatasetName) {
+                console.log(chalk.red(`  Dataset "${requestedDatasetName}" is not set up in this project.`));
+                console.log(chalk.dim("  Run `interf list` to see the saved datasets."));
+            }
+            else {
+                console.log(chalk.red("  No datasets are set up for this folder yet."));
+                console.log(chalk.dim("  Start with `interf` or `interf init` to set up this folder."));
+            }
+            return null;
         }
-        if (process.stdin.isTTY && process.stdout.isTTY) {
-            const confirmed = await p.confirm({
+        if (!skipConfirm && process.stdin.isTTY && process.stdout.isTTY) {
+            const confirmed = await helpers.confirm({
                 message: `Compile dataset "${selectedCompiled.name}" now?`,
                 initialValue: true,
             });
             if (p.isCancel(confirmed) || !confirmed)
-                return;
+                return null;
         }
         compiledConfig = selectedCompiled;
-        compiledPath = ensureCompiledFromConfig(process.cwd(), selectedCompiled);
-        console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
+        compiledPath = helpers.ensureCompiledFromConfig(sourcePath, selectedCompiled);
+        if (!skipDatasetBanner) {
+            console.log(chalk.dim(`  Dataset: ${selectedCompiled.name}`));
+        }
     }
     let maxAttemptsOverride = null;
     let maxLoopsOverride = null;
@@ -78,32 +136,37 @@ export async function runCompileCommand(argv = {}) {
     catch (error) {
         process.exitCode = 1;
         console.log(chalk.red(error instanceof Error ? error.message : String(error)));
-        return;
+        return null;
     }
-    const interactiveOverrides = await resolveInteractiveCompileLoopOverrides({
+    const interactiveOverrides = await helpers.resolveInteractiveCompileLoopOverrides({
         compiledPath,
         compiledConfig,
         maxAttemptsOverride,
         maxLoopsOverride,
     });
     if (!interactiveOverrides)
-        return;
+        return null;
     compiledConfig = interactiveOverrides.compiledConfig;
     maxAttemptsOverride = interactiveOverrides.maxAttemptsOverride;
     maxLoopsOverride = interactiveOverrides.maxLoopsOverride;
+    const testedDuringCompile = compileRunTests({
+        compiledConfig,
+        maxAttemptsOverride,
+        maxLoopsOverride,
+    });
     const executionProfile = executionProfileFromArgv(argv);
-    const { executor, error } = await resolveOrConfigureLocalExecutor({
+    const { executor, error } = await helpers.resolveOrConfigureLocalExecutor({
         executionProfile,
         purpose: "compile",
     });
     if (!executor && !error)
-        return;
+        return null;
     if (!executor) {
         process.exitCode = 1;
         console.log(chalk.red(error ?? "No coding agent detected."));
-        return;
+        return null;
     }
-    await runConfiguredCompiledCompile({
+    const compiled = await helpers.runConfiguredCompiledCompile({
         executor,
         compiledPath,
         sourcePath,
@@ -113,6 +176,13 @@ export async function runCompileCommand(argv = {}) {
         maxLoopsOverride,
         preserveStageShells: readStageShellRetentionMode(argv),
     });
+    if (!compiled) {
+        return null;
+    }
+    return {
+        compiledPath,
+        testedDuringCompile,
+    };
 }
 export async function resolveInteractiveCompileLoopOverrides(options) {
     if (!process.stdin.isTTY || !process.stdout.isTTY) {

package/dist/commands/create-workflow-wizard.d.ts

@@ -1,3 +1,7 @@
+import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
+import { runWorkflowAuthoringDraft } from "../lib/workflow-authoring.js";
+import type { SourceDatasetConfig } from "../lib/schema.js";
+import type { WorkflowExecutionProfile } from "../lib/executors.js";
 export interface WorkflowWizardPrompts {
     intro(message: string): void;
     select(options: {
@@ -17,8 +21,13 @@ export interface WorkflowWizardPrompts {
     isCancel(value: unknown): value is symbol;
     log: {
         info(message: string): void;
+        error?(message: string): void;
     };
 }
+export interface WorkflowWizardDatasetContext {
+    config: SourceDatasetConfig;
+    datasetPath: string;
+}
 export declare const clackWorkflowPrompts: WorkflowWizardPrompts;
 export declare function formatWorkflowLabel(workflow: {
     id: string;
@@ -42,5 +51,14 @@ export declare function chooseCompiledWorkflow(sourcePath: string, options?: {
 export declare function createWorkflowWizard(options?: {
     intro?: boolean;
     sourcePath?: string;
-}, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
-export declare function createCompiledWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts): Promise<string | symbol>;
+    executionProfile?: WorkflowExecutionProfile;
+    datasetContext?: WorkflowWizardDatasetContext;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runWorkflowAuthoringDraft;
+}, prompts?: WorkflowWizardPrompts): Promise<string | symbol | null>;
+export declare function createCompiledWorkflowWizard(sourcePath: string, prompts?: WorkflowWizardPrompts, options?: {
+    executionProfile?: WorkflowExecutionProfile;
+    datasetContext?: WorkflowWizardDatasetContext;
+    resolveExecutor?: typeof resolveOrConfigureLocalExecutor;
+    runDraft?: typeof runWorkflowAuthoringDraft;
+}): Promise<string | symbol | null>;