@interf/compiler 0.7.3 → 0.9.3

package/dist/cli/commands/test.js

@@ -1,32 +1,37 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
 import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { fingerprintTruthChecks, loadCompiledDatasetConfig, sourceDatasetConfigFromInterfConfig, } from "../../packages/project-model/source-config.js";
+import { loadCompiledPreparationConfig, sourcePreparationConfigFromInterfConfig, } from "../../packages/project-model/source-config.js";
 import { addExecutionProfileOptions, executionProfileFromArgv, } from "../../packages/agents/lib/execution-profile.js";
 import { chooseCompiledConfigToBuild, findBuiltCompiledPath, } from "./compiled-flow.js";
-import { resolveConfiguredDatasetSelection } from "./dataset-selection.js";
-import { printAgentTestFailures, printAgentTestMatrix, printSavedTestComparisonState, readSavedTestComparison, runSavedRawTest, runSavedCompiledTest, saveTestComparisonRun, } from "./test-flow.js";
+import { resolveConfiguredPreparationSelection } from "./preparation-selection.js";
+import { printAgentTestFailures, printAgentTestMatrix, printSavedTestComparisonState, } from "./test-flow.js";
+import { createCompiledTestTarget } from "../../packages/testing/test-targets.js";
+import { runReadinessChecksForExecutor, } from "../../packages/testing/readiness-check-run.js";
+import { resolveMethodId } from "../../packages/methods/method-resolution.js";
 import { listRunAgentOptions, promptForTestAgents, resolveNamedLocalExecutor, resolveOrConfigureLocalExecutor, } from "./executor-flow.js";
+import { submitTestRunToLocalService, waitForLocalTestRun, } from "../../packages/local-service/index.js";
+import { resolveCommandControlPath } from "./control-path.js";
 export const testCommand = {
     command: "test",
-    describe: "Compare source files and portable context on saved questions",
+    describe: "Run readiness checks against source files and Portable Context",
     builder: (yargs) => addExecutionProfileOptions(yargs)
-        .option("dataset", {
+        .option("preparation", {
         type: "string",
-        describe: "Dataset id to test when this project has more than one dataset",
+        describe: "Preparation id to check when this Source Folder has more than one Preparation",
     })
         .option("target", {
-        choices: ["both", "raw", "compiled"],
-        describe: "Test source files, portable context, or both. Default: both when portable context exists, otherwise source files.",
+        choices: ["both", "source-files", "portable-context"],
+        describe: "Check source files, Portable Context, or both. Default: both when Portable Context exists, otherwise source files.",
     })
         .option("keep-sandboxes", {
         type: "boolean",
         default: false,
-        describe: "Keep every test sandbox for review instead of pruning successful ones",
+        describe: "Keep every readiness-check sandbox for review instead of pruning successful ones",
     })
         .option("agents", {
         type: "string",
-        describe: "Comma-separated local agents to use for this test, or `all`. Example: --agents claude-code,codex",
+        describe: "Comma-separated local agents to use for readiness checks, or `all`. Example: --agents claude-code,codex",
     }),
     handler: async (argv) => {
         await runTestCommand(argv);
@@ -38,29 +43,53 @@ function readSandboxRetentionMode(argv) {
 }
 function readRequestedMode(argv) {
     const value = argv.target;
-    return value === "raw" || value === "compiled" || value === "both" ? value : null;
+    const target = value === "source-files" || value === "portable-context" || value === "both"
+        ? value
+        : null;
+    if (!target)
+        return null;
+    return modeFromTargetChoice(target);
+}
+function modeFromTargetChoice(target) {
+    if (target === "source-files")
+        return "raw";
+    if (target === "portable-context")
+        return "compiled";
+    return "both";
+}
+function reportTestCommandFailure(argv, message, hints = []) {
+    process.exitCode = 1;
+    console.log(chalk.red(`  ${message}`));
+    for (const hint of hints) {
+        console.log(chalk.dim(`  ${hint}`));
+    }
+    const onFailure = typeof argv.onFailure === "function"
+        ? argv.onFailure
+        : null;
+    void onFailure?.({ message, hints });
+    return false;
 }
 async function promptTestMode(hasBuiltCompiled) {
     if (!hasBuiltCompiled) {
         return "raw";
     }
     const selected = await p.select({
-        message: "What do you want to test?",
+        message: "What do you want to check?",
         options: [
             {
                 value: "both",
-                label: "Compare source files and portable context (Recommended)",
-                hint: "Measure whether the portable context helps your agents on the saved questions",
+                label: "Source files and Portable Context (Recommended)",
+                hint: "Check whether the data is ready with and without Portable Context",
             },
             {
                 value: "raw",
                 label: "Source files only",
-                hint: "Measure the current baseline on the dataset files",
+                hint: "Measure the current baseline on the Source Folder files",
             },
             {
                 value: "compiled",
-                label: "Portable context only",
-                hint: "Measure the current portable context on the saved questions",
+                label: "Portable Context only",
+                hint: "Run the saved readiness checks against the current Portable Context",
             },
         ],
     });
@@ -126,51 +155,43 @@ async function resolveSelectedTestAgents(options) {
             return selected;
         }
     }
-    const fallback = await resolveOrConfigureLocalExecutor({
+    const resolved = await resolveOrConfigureLocalExecutor({
         preflight: true,
         executionProfile: options.executionProfile,
         purpose: "test",
     });
-    if (!fallback.executor) {
-        if (fallback.cancelled)
+    if (!resolved.executor) {
+        if (resolved.cancelled)
             return null;
         process.exitCode = 1;
-        console.log(chalk.red(fallback.error ?? "No local agent detected."));
+        console.log(chalk.red(resolved.error ?? "No local agent detected."));
         return null;
     }
     return [
         {
-            name: fallback.executor.name,
-            label: fallback.executor.displayName,
-            executor: fallback.executor,
+            name: resolved.executor.name,
+            label: resolved.executor.displayName,
+            executor: resolved.executor,
         },
     ];
 }
 async function runModeForAgent(options) {
-    const rawPromise = options.mode === "raw" || options.mode === "both"
-        ? runSavedRawTest({
-            sourcePath: options.sourcePath,
-            datasetConfig: options.datasetConfig,
-            executor: options.executor,
-            preserveSandboxes: options.preserveSandboxes,
-            runSuffix: options.executor.name,
-        })
-        : Promise.resolve(null);
-    const compiledPromise = options.mode === "compiled" || options.mode === "both"
-        ? runSavedCompiledTest({
-            sourcePath: options.sourcePath,
-            datasetConfig: options.datasetConfig,
-            compiledPath: options.builtCompiledPath,
-            executor: options.executor,
-            preserveSandboxes: options.preserveSandboxes,
-            runSuffix: options.executor.name,
-        })
-        : Promise.resolve(null);
-    const [rawOutcome, compiledOutcome] = await Promise.all([rawPromise, compiledPromise]);
+    const result = await runReadinessChecksForExecutor({
+        sourcePath: options.sourcePath,
+        preparationConfig: options.preparationConfig,
+        portableContextPath: options.builtCompiledPath,
+        mode: options.mode,
+        preserveSandboxes: options.preserveSandboxes,
+        executor: options.executor,
+        runSuffix: options.executor.name,
+        saveLatest: options.saveLatest,
+    });
     return {
         agentLabel: options.executor.displayName,
-        rawOutcome,
-        compiledOutcome,
+        rawOutcome: result.rawOutcome,
+        compiledOutcome: result.compiledOutcome,
+        comparisonRunPath: result.comparisonRunPath,
+        comparison: result.comparison,
     };
 }
 export async function runTestCommand(argv = {}) {
@@ -178,60 +199,56 @@ export async function runTestCommand(argv = {}) {
     const detected = detectInterf(cwd);
     const sourcePath = typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
         ? argv.sourcePath.trim()
-        : (detected ? resolveSourceControlPath(detected.path) : cwd);
-    const requestedDatasetName = typeof argv.dataset === "string" && argv.dataset.trim().length > 0
-        ? argv.dataset.trim()
+        : (detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath(cwd));
+    const requestedPreparation = argv.preparation;
+    const requestedPreparationName = typeof requestedPreparation === "string" && requestedPreparation.trim().length > 0
+        ? requestedPreparation.trim()
         : null;
-    const hintedDatasetConfig = (argv.datasetConfig ?? null);
+    const hintedPreparationConfig = (argv.preparationConfig ?? null);
     const selectedCompiled = detected
         ? (() => {
-            const targetName = requestedDatasetName ?? hintedDatasetConfig?.name ?? detected.config.name;
-            return resolveConfiguredDatasetSelection({
+            const targetName = requestedPreparationName ?? hintedPreparationConfig?.name ?? detected.config.name;
+            return resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedDatasetName: targetName,
-                hintedDatasetConfig,
+                requestedPreparationName: targetName,
+                hintedPreparationConfig,
             }) ?? (targetName === detected.config.name
-                ? (loadCompiledDatasetConfig(detected.path)
-                    ?? sourceDatasetConfigFromInterfConfig(detected.config))
+                ? (loadCompiledPreparationConfig(detected.path)
+                    ?? sourcePreparationConfigFromInterfConfig(detected.config))
                 : null);
         })()
-        : requestedDatasetName || hintedDatasetConfig
-            ? resolveConfiguredDatasetSelection({
+        : requestedPreparationName || hintedPreparationConfig
+            ? resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedDatasetName,
-                hintedDatasetConfig,
+                requestedPreparationName,
+                hintedPreparationConfig,
             })
             : await chooseCompiledConfigToBuild({
                 sourcePath,
-                selectMessage: "Which source folder setup do you want to test?",
+                selectMessage: "Which saved Preparation do you want to test?",
             });
     if (selectedCompiled === undefined)
         return false;
     if (!selectedCompiled) {
-        process.exitCode = 1;
-        if (requestedDatasetName) {
-            console.log(chalk.red(`  Setup "${requestedDatasetName}" is not set up in this project.`));
-            console.log(chalk.dim("  Run `interf list` to see the saved setups."));
+        if (requestedPreparationName) {
+            return reportTestCommandFailure(argv, `Preparation "${requestedPreparationName}" is not saved in this Source Folder.`, ["Run `interf list` to see the saved Preparations."]);
         }
-        else {
-            console.log(chalk.red("  No saved setups are configured for this folder yet."));
-            console.log(chalk.dim("  Start with `interf` or `interf init`."));
-        }
-        return false;
+        return reportTestCommandFailure(argv, "No saved Preparations are configured for this Source Folder yet.", ["Start with `interf` or `interf init`."]);
     }
     if (selectedCompiled.checks.length === 0) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Setup "${selectedCompiled.name}" does not have any questions yet.`));
-        console.log(chalk.dim("  Run `interf`, edit this setup, and add a few questions first."));
-        console.log(chalk.dim("  Then rerun `interf test`."));
-        return false;
+        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have any readiness checks yet.`, [
+            "Run `interf`, edit this Preparation, and add a few readiness checks first.",
+            "Then rerun `interf test`.",
+        ]);
     }
     const executionProfile = executionProfileFromArgv(argv);
     const preserveSandboxes = readSandboxRetentionMode(argv);
     const builtCompiledPath = detected?.config.name === selectedCompiled.name
         ? detected.path
         : findBuiltCompiledPath(sourcePath, selectedCompiled.name);
-    const hasBuiltCompiled = Boolean(builtCompiledPath);
+    const hasBuiltCompiled = builtCompiledPath
+        ? createCompiledTestTarget(builtCompiledPath, selectedCompiled.name, resolveMethodId(selectedCompiled)).eligible
+        : false;
     const requestedMode = readRequestedMode(argv);
     const selectedMode = requestedMode ?? (process.stdin.isTTY && process.stdout.isTTY
         ? await promptTestMode(hasBuiltCompiled)
@@ -239,18 +256,47 @@ export async function runTestCommand(argv = {}) {
     if (!selectedMode)
         return false;
     if (selectedMode === "compiled" && !hasBuiltCompiled) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Setup "${selectedCompiled.name}" does not have portable context agents can use yet.`));
-        console.log(chalk.dim("  Run `interf compile` first."));
-        return false;
+        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have Portable Context agents can use yet.`, ["Run `interf compile` first."]);
     }
     if (selectedMode === "both" && !hasBuiltCompiled) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Setup "${selectedCompiled.name}" does not have portable context agents can use yet, so Interf cannot compare source files and portable context.`));
-        console.log(chalk.dim("  Run `interf compile` first, or rerun with `--target raw`."));
-        return false;
+        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have Portable Context agents can use yet, so Interf cannot compare source files and Portable Context.`, ["Run `interf compile` first, or rerun with `--target source-files`."]);
     }
     const mode = selectedMode;
+    if (argv.skipService !== true) {
+        const submitted = await submitTestRunToLocalService({
+            projectPath: sourcePath,
+            request: {
+                preparation: selectedCompiled.name,
+                mode,
+            },
+        });
+        if (submitted) {
+            console.log(chalk.dim(`  Visible in Interf: ${submitted.serviceUrl}/`));
+            let lastStatus = "";
+            const completed = await waitForLocalTestRun({
+                serviceUrl: submitted.serviceUrl,
+                runId: submitted.resource.run_id,
+                onUpdate(resource) {
+                    if (resource.status === lastStatus)
+                        return;
+                    lastStatus = resource.status;
+                    console.log(chalk.dim(`  Readiness check run: ${resource.status}`));
+                },
+            });
+            if (completed.status !== "succeeded") {
+                return reportTestCommandFailure(argv, `Readiness check run ${completed.status}.`, completed.error ? [completed.error] : []);
+            }
+            const compiledScore = completed.comparison?.compiled;
+            const rawScore = completed.comparison?.raw;
+            if (compiledScore) {
+                console.log(chalk.green(`  Portable Context readiness checks: ${compiledScore.passed_cases}/${compiledScore.total_cases}`));
+            }
+            if (rawScore) {
+                console.log(chalk.dim(`  Source files readiness checks: ${rawScore.passed_cases}/${rawScore.total_cases}`));
+            }
+            return true;
+        }
+    }
     const selectedAgents = await resolveSelectedTestAgents({
         argv,
         executionProfile,
@@ -260,23 +306,21 @@ export async function runTestCommand(argv = {}) {
     }
     const rows = await Promise.all(selectedAgents.map((agent) => runModeForAgent({
         sourcePath,
-        datasetConfig: selectedCompiled,
+        preparationConfig: selectedCompiled,
         builtCompiledPath: builtCompiledPath ?? null,
         mode,
         preserveSandboxes,
         executor: agent.executor,
+        saveLatest: selectedAgents.length === 1,
     })));
     if ((mode === "compiled" || mode === "both") && rows.some((row) => !row.compiledOutcome)) {
-        process.exitCode = 1;
-        console.log(chalk.red(`  Setup "${selectedCompiled.name}" does not have portable context agents can use yet.`));
-        console.log(chalk.dim("  Run `interf compile` first."));
-        return false;
+        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have Portable Context agents can use yet.`, ["Run `interf compile` first."]);
     }
     printAgentTestMatrix(rows);
     printAgentTestFailures(rows);
     const resultSummary = {
         sourcePath,
-        datasetConfig: selectedCompiled,
+        preparationConfig: selectedCompiled,
         builtCompiledPath: builtCompiledPath ?? null,
         mode,
         rows,
@@ -286,16 +330,8 @@ export async function runTestCommand(argv = {}) {
         : null;
     if (rows.length === 1) {
         const row = rows[0];
-        const comparisonRunPath = saveTestComparisonRun({
-            sourcePath,
-            compiledPath: builtCompiledPath ?? null,
-            compiledName: selectedCompiled.name,
-            checksFingerprint: fingerprintTruthChecks(selectedCompiled.checks),
-            mode,
-            rawOutcome: row?.rawOutcome ?? null,
-            compiledOutcome: row?.compiledOutcome ?? null,
-        });
-        const latestComparison = readSavedTestComparison(sourcePath, selectedCompiled.name);
+        const comparisonRunPath = row?.comparisonRunPath ?? null;
+        const latestComparison = row?.comparison ?? null;
         if (latestComparison) {
             if (mode === "both") {
                 console.log();

package/dist/cli/commands/verify.js

@@ -1,25 +1,25 @@
 import chalk from "chalk";
 import { detectInterf } from "../../packages/project-model/interf.js";
 import { validateCompiledCompile, validateCompiledStage, } from "../../packages/compiler/validate.js";
-import { validateWorkflowPackage } from "../../packages/workflow-package/local-workflows.js";
+import { validateMethodPackage } from "../../packages/method-package/local-methods.js";
 function normalizeVerifyCheck(value) {
     if (!value)
         return null;
     if (value === "stage")
         return "stage";
-    if (value === "compiled" || value === "compile")
-        return "compiled";
-    if (value === "workflow")
-        return "workflow";
+    if (value === "portable-context")
+        return "portable-context";
+    if (value === "method")
+        return "method";
     return null;
 }
 export const verifyCommand = {
-    command: "verify <check>",
+    command: "verify <check> [stageId]",
     describe: "Run deterministic verification checks",
     builder: (yargs) => yargs
         .positional("check", {
         type: "string",
-        describe: "Check to run (`stage`, `compiled`, or `workflow`)",
+        describe: "Check to run (`stage`, `portable-context`, or `method`)",
     })
         .positional("stageId", {
         type: "string",
@@ -27,7 +27,7 @@ export const verifyCommand = {
     })
         .option("path", {
         type: "string",
-        describe: "Path to a workflow package when using `verify workflow`",
+        describe: "Path to a Method package when using `verify method`",
     })
         .option("json", {
         type: "boolean",
@@ -42,23 +42,23 @@ export const verifyCommand = {
             return;
         }
         let result;
-        if (check === "workflow") {
+        if (check === "method") {
             const path = argv.path;
             if (!path) {
                 process.exitCode = 1;
-                console.log(chalk.red("`interf verify workflow` needs --path <workflow-dir>."));
+                console.log(chalk.red("`interf verify method` needs --path <method-dir>."));
                 return;
             }
-            result = validateWorkflowPackage(path);
+            result = validateMethodPackage(path);
         }
         else {
             const detected = detectInterf(process.cwd());
             if (!detected) {
                 process.exitCode = 1;
-                console.log(chalk.red("Run this from inside a compiled context."));
+                console.log(chalk.red("Run this from inside Portable Context."));
                 return;
             }
-            if (check === "compiled") {
+            if (check === "portable-context") {
                 result = validateCompiledCompile(detected.path);
             }
             else {

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

@@ -0,0 +1,11 @@
+import type { CommandModule } from "yargs";
+export declare const webCommand: CommandModule;
+export interface WebProjectPaths {
+    controlPath: string;
+    sourceFolderPath: string | null;
+}
+export declare function resolveWebProjectPaths(argv?: Record<string, unknown>, cwd?: string): WebProjectPaths;
+export declare function ensureWebProjectInitialized(controlPath: string, options?: {
+    sourceFolderPath?: string | null;
+}): void;
+export declare function runWebCommand(argv?: Record<string, unknown>): Promise<void>;