@interf/compiler 0.7.3 → 0.9.1

package/dist/cli/commands/test.js

@@ -1,32 +1,35 @@
 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 { fingerprintReadinessChecks, loadCompiledDatasetConfig, sourceDatasetConfigFromInterfConfig, } 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 { resolveConfiguredPreparationSelection } from "./preparation-selection.js";
 import { printAgentTestFailures, printAgentTestMatrix, printSavedTestComparisonState, readSavedTestComparison, runSavedRawTest, runSavedCompiledTest, saveTestComparisonRun, } from "./test-flow.js";
+import { createCompiledTestTarget } from "../../packages/testing/test-targets.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.",
+        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);
@@ -40,27 +43,39 @@ function readRequestedMode(argv) {
     const value = argv.target;
     return value === "raw" || value === "compiled" || value === "both" ? value : null;
 }
+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,23 +141,23 @@ 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,
         },
     ];
 }
@@ -178,60 +193,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 requestedDatasetName = typeof requestedPreparation === "string" && requestedPreparation.trim().length > 0
+        ? requestedPreparation.trim()
         : null;
     const hintedDatasetConfig = (argv.datasetConfig ?? null);
     const selectedCompiled = detected
         ? (() => {
             const targetName = requestedDatasetName ?? hintedDatasetConfig?.name ?? detected.config.name;
-            return resolveConfiguredDatasetSelection({
+            return resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedDatasetName: targetName,
-                hintedDatasetConfig,
+                requestedPreparationName: targetName,
+                hintedPreparationConfig: hintedDatasetConfig,
             }) ?? (targetName === detected.config.name
                 ? (loadCompiledDatasetConfig(detected.path)
                     ?? sourceDatasetConfigFromInterfConfig(detected.config))
                 : null);
         })()
         : requestedDatasetName || hintedDatasetConfig
-            ? resolveConfiguredDatasetSelection({
+            ? resolveConfiguredPreparationSelection({
                 sourcePath,
-                requestedDatasetName,
-                hintedDatasetConfig,
+                requestedPreparationName: requestedDatasetName,
+                hintedPreparationConfig: hintedDatasetConfig,
             })
             : 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."));
-        }
-        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 reportTestCommandFailure(argv, `Preparation "${requestedDatasetName}" is not saved in this Source Folder.`, ["Run `interf list` to see the saved Preparations."]);
         }
-        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, selectedCompiled.method ?? selectedCompiled.workflow ?? "interf-default").eligible
+        : false;
     const requestedMode = readRequestedMode(argv);
     const selectedMode = requestedMode ?? (process.stdin.isTTY && process.stdout.isTTY
         ? await promptTestMode(hasBuiltCompiled)
@@ -239,18 +250,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 raw`."]);
     }
     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,
@@ -267,10 +307,7 @@ export async function runTestCommand(argv = {}) {
         executor: agent.executor,
     })));
     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);
@@ -290,7 +327,7 @@ export async function runTestCommand(argv = {}) {
             sourcePath,
             compiledPath: builtCompiledPath ?? null,
             compiledName: selectedCompiled.name,
-            checksFingerprint: fingerprintTruthChecks(selectedCompiled.checks),
+            checksFingerprint: fingerprintReadinessChecks(selectedCompiled.checks),
             mode,
             rawOutcome: row?.rawOutcome ?? null,
             compiledOutcome: row?.compiledOutcome ?? null,

package/dist/cli/commands/verify.js

@@ -9,8 +9,8 @@ function normalizeVerifyCheck(value) {
         return "stage";
     if (value === "compiled" || value === "compile")
         return "compiled";
-    if (value === "workflow")
-        return "workflow";
+    if (value === "method")
+        return "method";
     return null;
 }
 export const verifyCommand = {
@@ -19,7 +19,7 @@ export const verifyCommand = {
     builder: (yargs) => yargs
         .positional("check", {
         type: "string",
-        describe: "Check to run (`stage`, `compiled`, or `workflow`)",
+        describe: "Check to run (`stage`, `compiled`, 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,11 +42,11 @@ 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);
@@ -55,7 +55,7 @@ export const verifyCommand = {
             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") {

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>;