@interf/compiler 0.7.3 → 0.9.3

package/dist/cli/commands/compile-controller.js

@@ -3,25 +3,31 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import chalk from "chalk";
 import { readInterfConfig } from "../../packages/project-model/interf.js";
-import { clearCompiledRuntimeDerivedArtifacts, resetCompiledGeneratedState, } from "../../packages/compiler/reset.js";
-import { formatActiveCompiledWorkflowStageStep, resolveRequiredCompiledWorkflowFromConfig, } from "../../packages/workflow-package/workflow-definitions.js";
-import { loadCompiledDatasetConfig, resolveDatasetCompileMaxAttempts, resolveDatasetCompileMaxLoops, } from "../../packages/project-model/source-config.js";
-import { runWorkflowImprovementLoop } from "../../packages/workflow-authoring/workflow-improvement.js";
-import { stageExecutionShellsRoot, workflowPackagePathForCompiled, } from "../../packages/compiler/compiled-paths.js";
+import { clearCompiledRuntimeDerivedArtifacts, } from "../../packages/compiler/reset.js";
+import { formatActiveCompiledMethodStageStep, resolveRequiredCompiledMethodFromConfig, } from "../../packages/method-package/method-definitions.js";
+import { loadCompiledPreparationConfig, resolvePreparationCompileMaxAttempts, resolvePreparationCompileMaxLoops, } from "../../packages/project-model/source-config.js";
+import { runMethodImprovementLoop } from "../../packages/method-authoring/method-improvement.js";
+import { stageExecutionShellsRoot, methodPackagePathForCompiled, } from "../../packages/compiler/compiled-paths.js";
 import { readCompiledSchemaFile } from "../../packages/compiler/compiled-schema.js";
 import { initializeCompiledRuntimeState } from "../../packages/compiler/state.js";
 import { compileCompiledWithReporter } from "./compiled-flow.js";
-import { printSavedTestOutcome, questionPassRate, runSavedCompiledTest, } from "./test-flow.js";
+import { printSavedTestOutcome, readinessPassRate, runSavedCompiledTest, } from "./test-flow.js";
 function printCompileFailure(compiledPath, failedStage) {
-    const workflowId = resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
-    const failedStageLabel = formatActiveCompiledWorkflowStageStep(compiledPath, workflowId, failedStage ?? "compile");
+    resolveRequiredCompiledMethodFromConfig(readInterfConfig(compiledPath), `.interf/interf.json for ${compiledPath}`);
+    let failedStageLabel = failedStage ? `Stage "${failedStage}"` : "Compile";
+    try {
+        failedStageLabel = formatActiveCompiledMethodStageStep(compiledPath, failedStage ?? "compile");
+    }
+    catch {
+        // Keep the original failure visible even when the failure is outside a declared Method stage.
+    }
     console.log(chalk.red(`  ${failedStageLabel} failed.`));
 }
 function testScore(outcome) {
     return (outcome.result.passedCases * 1000) + outcome.result.passedChecks;
 }
 function bestVariationRestorePaths(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zonePaths = (schema?.zones ?? [])
         .filter((zone) => zone.id !== "raw" && zone.kind !== "runtime")
         .map((zone) => zone.path);
@@ -33,7 +39,7 @@ function bestVariationRestorePaths(compiledPath) {
         ".agents",
         ".cursor",
         ".interf/interf.json",
-        ".interf/workflow",
+        ".interf/method",
         ...zonePaths,
     ];
 }
@@ -65,7 +71,7 @@ function restoreCompiledBestState(snapshotPath, compiledPath) {
     clearCompiledRuntimeDerivedArtifacts(compiledPath);
     initializeCompiledRuntimeState(compiledPath);
 }
-async function runWorkflowVariation(options) {
+async function runMethodVariation(options) {
     let bestOutcome = null;
     let bestSnapshotPath = null;
     let bestAttempt = 0;
@@ -73,22 +79,16 @@ async function runWorkflowVariation(options) {
     try {
         for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
             attemptsRun = attempt;
-            if (attempt > 1 || (attempt === 1 && options.resetBeforeFirstAttempt)) {
-                console.log();
-                const resetTarget = attempt > 1
-                    ? `attempt ${attempt}/${options.maxAttempts}`
-                    : options.variationLabel;
-                console.log(chalk.dim(`  Resetting generated portable-context state before ${resetTarget}...`));
-                resetCompiledGeneratedState(options.compiledPath, "compile");
-            }
             const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
                 heading: options.maxAttempts > 1
-                    ? `Building portable context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
-                    : `Building portable context (${options.variationLabel})...`,
+                    ? `Building Portable Context (${options.variationLabel}, attempt ${attempt}/${options.maxAttempts})...`
+                    : `Building Portable Context (${options.variationLabel})...`,
                 successMessage: options.maxAttempts > 1
-                    ? `Portable context ready for ${options.variationLabel}, attempt ${attempt}.`
-                    : `Portable context ready for ${options.variationLabel}.`,
+                    ? `Portable Context ready for ${options.variationLabel}, attempt ${attempt}.`
+                    : `Portable Context ready for ${options.variationLabel}.`,
                 preserveStageShells: options.preserveStageShells,
+                runId: options.runId,
+                events: options.events,
             });
             if (!result.ok) {
                 printCompileFailure(options.compiledPath, result.failedStage);
@@ -109,7 +109,7 @@ async function runWorkflowVariation(options) {
             }
             const outcome = await runSavedCompiledTest({
                 sourcePath: options.sourcePath,
-                datasetConfig: options.compiledConfig,
+                preparationConfig: options.compiledConfig,
                 executor: options.testExecutor,
                 executionProfile: options.executionProfile,
                 compiledPath: options.compiledPath,
@@ -123,7 +123,7 @@ async function runWorkflowVariation(options) {
                     bestOutcome,
                     bestSnapshotPath,
                     bestAttempt,
-                    fatalError: "Could not run the saved portable-context comparison after compile.",
+                    fatalError: "Could not run the saved Portable Context comparison after compile.",
                 };
             }
             console.log();
@@ -138,7 +138,7 @@ async function runWorkflowVariation(options) {
             }
             if (outcome.result.ok) {
                 console.log();
-                console.log(chalk.green(`  Compiled context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
+                console.log(chalk.green(`  Portable Context passed on ${options.variationLabel}, attempt ${attempt}/${options.maxAttempts}.`));
                 printStageShellReviewHint(options.compiledPath, options.preserveStageShells, "success");
                 return {
                     passed: true,
@@ -152,7 +152,7 @@ async function runWorkflowVariation(options) {
             }
             if (attempt < options.maxAttempts) {
                 console.log();
-                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same workflow.`));
+                console.log(chalk.yellow(`  ${options.variationLabel} attempt ${attempt}/${options.maxAttempts} did not pass. Retrying with the same Method.`));
             }
         }
         return {
@@ -177,23 +177,23 @@ async function runWorkflowVariation(options) {
         };
     }
 }
-function summarizeWorkflowVariation(options) {
-    const passedQuestions = options.result.bestOutcome?.result.passedCases ?? 0;
-    const totalQuestions = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalQuestions;
+function summarizeMethodVariation(options) {
+    const passedChecks = options.result.bestOutcome?.result.passedCases ?? 0;
+    const totalChecks = options.result.bestOutcome?.result.totalCases ?? options.defaultTotalChecks;
     const summary = options.result.passed
-        ? `Passed ${passedQuestions}/${totalQuestions} questions.`
+        ? `Passed ${passedChecks}/${totalChecks} readiness checks.`
         : options.result.bestOutcome
-            ? `Best result: ${passedQuestions}/${totalQuestions} questions passed.`
+            ? `Best result: ${passedChecks}/${totalChecks} readiness checks passed.`
             : options.result.failedStage
                 ? `Compile failed at stage ${options.result.failedStage} before any saved comparison result.`
-                : "Workflow variation did not produce a passing result.";
+                : "Method variation did not produce a passing result.";
     return {
         variation: options.variation,
         kind: options.kind,
         attempts_run: Math.max(1, options.result.attemptsRun),
         passed: options.result.passed,
-        passed_questions: passedQuestions,
-        total_questions: totalQuestions,
+        passed_questions: passedChecks,
+        total_questions: totalChecks,
         ...(options.result.failedStage ? { failed_stage: options.result.failedStage } : {}),
         ...(options.result.bestOutcome ? { test_run_path: options.result.bestOutcome.runPath } : {}),
         ...(options.result.bestOutcome?.result.sandbox_path
@@ -213,66 +213,68 @@ function printStageShellReviewHint(compiledPath, preserveStageShells, result) {
     }
 }
 function printPostCompileNextStep(options) {
-    console.log(chalk.dim(`  Portable context: ${options.compiledPath}`));
+    console.log(chalk.dim(`  Portable Context: ${options.compiledPath}`));
     if (options.checks === 0) {
-        console.log(chalk.dim("  Next: run `interf` to add questions, then `interf test`."));
+        console.log(chalk.dim("  Next: run `interf` to add readiness checks, then `interf test`."));
         return;
     }
     if (options.testedDuringCompile) {
-        console.log(chalk.dim("  Next: inspect the portable context agents will use, or run `interf test` if you also want a source-files-versus-portable-context comparison."));
+        console.log(chalk.dim("  Next: inspect the Portable Context agents will use, or run `interf test` if you also want a source files versus Portable Context comparison."));
         return;
     }
-    console.log(chalk.dim("  Next: run `interf test` to compare source files and portable context."));
+    console.log(chalk.dim("  Next: run `interf test` to compare source files and Portable Context."));
 }
-function formatVariationQuestionSummary(summary) {
+function formatVariationReadinessSummary(summary) {
     return `${summary.passed_questions}/${summary.total_questions}`;
 }
-function printWorkflowVariationSummary(summaries) {
+function printMethodVariationSummary(summaries) {
     if (summaries.length === 0)
         return;
     console.log();
-    console.log(chalk.bold("  Workflow variation summary"));
+    console.log(chalk.bold("  Method variation summary"));
     console.log();
-    console.log("  | Variation | Kind | Questions | Result |");
+    console.log("  | Variation | Kind | Readiness checks | Result |");
     console.log("  | --- | --- | --- | --- |");
     for (const summary of summaries) {
-        console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationQuestionSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
+        console.log(`  | ${summary.variation} | ${summary.kind} | \`${formatVariationReadinessSummary(summary)}\` | ${summary.passed ? "pass" : "fail"} |`);
     }
 }
-function printCompiledLocalWorkflowOwnership(compiledPath, bestVariation) {
+function printCompiledLocalMethodOwnership(compiledPath, bestVariation) {
     if (bestVariation <= 1)
         return;
     console.log();
-    console.log(chalk.dim(`  Best workflow variation now lives in: ${workflowPackagePathForCompiled(compiledPath)}`));
-    console.log(chalk.dim("  The project-level workflow selection was not changed automatically."));
-    console.log(chalk.dim("  Recompiling this existing portable context reuses that local workflow draft."));
+    console.log(chalk.dim(`  Best Method variation now lives in: ${methodPackagePathForCompiled(compiledPath)}`));
+    console.log(chalk.dim("  The project-level Method selection was not changed automatically."));
+    console.log(chalk.dim("  Recompiling this existing Portable Context reuses that local Method draft."));
 }
 export async function runConfiguredCompiledCompile(options) {
     const preserveStageShells = options.preserveStageShells ?? "on-failure";
-    const configuredMaxAttempts = resolveDatasetCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
-    const maxLoops = resolveDatasetCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
+    const configuredMaxAttempts = resolvePreparationCompileMaxAttempts(options.compiledConfig ?? { max_attempts: undefined }, options.maxAttemptsOverride);
+    const maxLoops = resolvePreparationCompileMaxLoops(options.compiledConfig ?? { max_loops: undefined }, options.maxLoopsOverride);
     const maxAttempts = configuredMaxAttempts ?? (maxLoops != null ? 1 : null);
     const loopEnabled = maxAttempts != null;
     const checks = options.compiledConfig?.checks ?? [];
     if (loopEnabled && checks.length === 0) {
-        console.log(chalk.yellow("  Retry and self-improving modes need saved questions. Building once without those loops."));
+        console.log(chalk.yellow("  Retry and self-improving modes need saved readiness checks. Building once without those loops."));
     }
     else if (loopEnabled) {
         if (maxAttempts > 1) {
             console.log(chalk.dim(`  Retry mode: up to ${maxAttempts} compile attempts.`));
-            console.log(chalk.dim("  Interf will rerun the same workflow variation, check the portable context agents can use, and stop early if it passes."));
+            console.log(chalk.dim("  Interf will rerun the same Method variation, check the Portable Context agents can use, and stop early if it passes."));
         }
         else {
-            console.log(chalk.dim("  Compile mode: 1 attempt per workflow variation."));
+            console.log(chalk.dim("  Compilation mode: 1 attempt per Method variation."));
         }
         if (maxLoops != null) {
-            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} workflow edits after retries fail.`));
-            console.log(chalk.dim("  Interf will review failed runs, edit the workflow, and test new workflow variations."));
+            console.log(chalk.dim(`  Self-improving loops: up to ${maxLoops} Method edits after retries fail.`));
+            console.log(chalk.dim("  Interf will review failed runs, edit the Method, and test new Method variations."));
         }
     }
     if (!loopEnabled || checks.length === 0) {
         const result = await compileCompiledWithReporter(options.executor, options.compiledPath, {
             preserveStageShells,
+            runId: options.runId,
+            events: options.events,
         });
         if (!result.ok) {
             process.exitCode = 1;
@@ -296,10 +298,10 @@ export async function runConfiguredCompiledCompile(options) {
     const improvementRunId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
     try {
         const compiledConfig = options.compiledConfig
-            ?? loadCompiledDatasetConfig(options.compiledPath)
+            ?? loadCompiledPreparationConfig(options.compiledPath)
             ?? {
                 name: readInterfConfig(options.compiledPath)?.name ?? "compiled",
-                path: "./dataset",
+                path: "./source-folder",
                 checks: [],
             };
         const adoptVariationBest = (variation, result) => {
@@ -318,7 +320,7 @@ export async function runConfiguredCompiledCompile(options) {
                 result.bestSnapshotPath = null;
             }
         };
-        const baseline = await runWorkflowVariation({
+        const baseline = await runMethodVariation({
             executor: options.executor,
             testExecutor: options.testExecutor,
             compiledPath: options.compiledPath,
@@ -327,7 +329,9 @@ export async function runConfiguredCompiledCompile(options) {
             executionProfile: options.executionProfile,
             preserveStageShells,
             maxAttempts,
-            variationLabel: "baseline workflow",
+            variationLabel: "baseline Method",
+            runId: options.runId,
+            events: options.events,
         });
         if (baseline.fatalError) {
             process.exitCode = 1;
@@ -335,14 +339,14 @@ export async function runConfiguredCompiledCompile(options) {
             return false;
         }
         adoptVariationBest(1, baseline);
-        previousVariations.push(summarizeWorkflowVariation({
+        previousVariations.push(summarizeMethodVariation({
             variation: 1,
             kind: "baseline",
             result: baseline,
-            defaultTotalQuestions: checks.length,
+            defaultTotalChecks: checks.length,
         }));
         if (baseline.passed) {
-            printWorkflowVariationSummary(previousVariations);
+            printMethodVariationSummary(previousVariations);
             printPostCompileNextStep({
                 compiledPath: options.compiledPath,
                 checks: checks.length,
@@ -353,11 +357,11 @@ export async function runConfiguredCompiledCompile(options) {
         if (maxLoops != null) {
             for (let loopIndex = 1; loopIndex <= maxLoops; loopIndex += 1) {
                 console.log();
-                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the workflow.`));
-                const improvement = await runWorkflowImprovementLoop({
+                console.log(chalk.dim(`  Self-improving loop ${loopIndex}/${maxLoops}: reviewing failed runs and editing the Method.`));
+                const improvement = await runMethodImprovementLoop({
                     executor: options.executor,
                     compiledPath: options.compiledPath,
-                    workflowId: resolveRequiredCompiledWorkflowFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
+                    methodId: resolveRequiredCompiledMethodFromConfig(readInterfConfig(options.compiledPath), `.interf/interf.json for ${options.compiledPath}`),
                     compiledConfig,
                     runId: improvementRunId,
                     loopIndex,
@@ -365,7 +369,7 @@ export async function runConfiguredCompiledCompile(options) {
                     maxAttempts,
                     previousVariations,
                 });
-                console.log(chalk.dim(`  Workflow improvement shell: ${improvement.shellPath}`));
+                console.log(chalk.dim(`  Method improvement shell: ${improvement.shellPath}`));
                 if (improvement.status === "executor-failed") {
                     process.exitCode = 1;
                     console.log(chalk.red(`  ${improvement.summary}`));
@@ -375,7 +379,7 @@ export async function runConfiguredCompiledCompile(options) {
                     console.log(chalk.yellow(`  ${improvement.summary}`));
                     continue;
                 }
-                const variation = await runWorkflowVariation({
+                const variation = await runMethodVariation({
                     executor: options.executor,
                     testExecutor: options.testExecutor,
                     compiledPath: options.compiledPath,
@@ -384,8 +388,9 @@ export async function runConfiguredCompiledCompile(options) {
                     executionProfile: options.executionProfile,
                     preserveStageShells,
                     maxAttempts,
-                    variationLabel: `workflow variation ${loopIndex + 1}`,
-                    resetBeforeFirstAttempt: true,
+                    variationLabel: `Method variation ${loopIndex + 1}`,
+                    runId: options.runId,
+                    events: options.events,
                 });
                 if (variation.fatalError) {
                     process.exitCode = 1;
@@ -393,15 +398,15 @@ export async function runConfiguredCompiledCompile(options) {
                     return false;
                 }
                 adoptVariationBest(loopIndex + 1, variation);
-                previousVariations.push(summarizeWorkflowVariation({
+                previousVariations.push(summarizeMethodVariation({
                     variation: loopIndex + 1,
                     kind: "edited",
                     result: variation,
-                    defaultTotalQuestions: checks.length,
+                    defaultTotalChecks: checks.length,
                 }));
                 if (variation.passed) {
-                    printWorkflowVariationSummary(previousVariations);
-                    printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
+                    printMethodVariationSummary(previousVariations);
+                    printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
                     printPostCompileNextStep({
                         compiledPath: options.compiledPath,
                         checks: checks.length,
@@ -414,20 +419,20 @@ export async function runConfiguredCompiledCompile(options) {
         if (bestSnapshotPath && bestVariation > 0) {
             restoreCompiledBestState(bestSnapshotPath, options.compiledPath);
             console.log();
-            console.log(chalk.dim(`  Restored the best-performing portable context from variation ${bestVariation}, attempt ${bestAttempt}.`));
+            console.log(chalk.dim(`  Restored the best-performing Portable Context from variation ${bestVariation}, attempt ${bestAttempt}.`));
         }
         process.exitCode = 1;
         console.log();
-        printWorkflowVariationSummary(previousVariations);
-        printCompiledLocalWorkflowOwnership(options.compiledPath, bestVariation);
+        printMethodVariationSummary(previousVariations);
+        printCompiledLocalMethodOwnership(options.compiledPath, bestVariation);
         if (maxLoops != null) {
-            console.log(chalk.red(`  Portable context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} workflow-improvement loop${maxLoops === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Portable Context did not pass after ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"} per variation and ${maxLoops} Method-improvement loop${maxLoops === 1 ? "" : "s"}.`));
         }
         else {
-            console.log(chalk.red(`  Portable context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
+            console.log(chalk.red(`  Portable Context did not pass within ${maxAttempts} attempt${maxAttempts === 1 ? "" : "s"}.`));
         }
         if (bestOutcome) {
-            console.log(chalk.dim(`  Best attempt test pass rate: ${questionPassRate(bestOutcome)}%.`));
+            console.log(chalk.dim(`  Best attempt readiness-check pass rate: ${readinessPassRate(bestOutcome)}%.`));
         }
         printStageShellReviewHint(options.compiledPath, preserveStageShells, "failure");
         return false;

package/dist/cli/commands/compile.d.ts

@@ -1,6 +1,6 @@
 import * as p from "@clack/prompts";
 import { detectInterf } from "../../packages/project-model/interf.js";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
 import type { CommandModule } from "yargs";
 import { chooseCompiledConfigToBuild, ensureCompiledFromConfig } from "./compiled-flow.js";
 import { resolveOrConfigureLocalExecutor } from "./executor-flow.js";
@@ -23,11 +23,11 @@ export interface CompileCommandResult {
 export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
 export declare function resolveInteractiveCompileLoopOverrides(options: {
     compiledPath: string;
-    compiledConfig: SourceDatasetConfig | null;
+    compiledConfig: SourcePreparationConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 }): Promise<{
-    compiledConfig: SourceDatasetConfig | null;
+    compiledConfig: SourcePreparationConfig | null;
     maxAttemptsOverride: number | null;
     maxLoopsOverride: number | null;
 } | null>;