@interf/compiler 0.9.4 → 0.13.0

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

@@ -1,18 +1,9 @@
 import type { CommandModule } from "yargs";
-import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
-import { type AgentTestMatrixRow } from "./test-flow.js";
-type TestMode = "raw" | "compiled" | "both";
-export interface TestCommandResult {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    builtCompiledPath: string | null;
-    mode: TestMode;
-    rows: AgentTestMatrixRow[];
+interface TestArgs {
+    prepId: string;
+    target?: "source-files" | "portable-context" | "both";
+    url?: string;
+    token?: string;
 }
-export interface TestCommandFailure {
-    message: string;
-    hints: string[];
-}
-export declare const testCommand: CommandModule;
-export declare function runTestCommand(argv?: Record<string, unknown>): Promise<boolean>;
+export declare const testCommand: CommandModule<unknown, TestArgs>;
 export {};

package/dist/cli/commands/test.js

@@ -1,351 +1,72 @@
+/**
+ * `interf test <prep-id>` — start a readiness-check (test) run for a preparation.
+ *
+ *   interf test bristol
+ *   interf test bristol --target source-files
+ *   interf test bristol --target portable-context
+ *   interf test bristol --target both
+ */
 import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.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 { 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: "Run readiness checks against source files and Portable Context",
-    builder: (yargs) => addExecutionProfileOptions(yargs)
-        .option("preparation", {
-        type: "string",
-        describe: "Preparation id to check when this Source Folder has more than one Preparation",
-    })
-        .option("target", {
-        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 readiness-check sandbox for review instead of pruning successful ones",
-    })
-        .option("agents", {
-        type: "string",
-        describe: "Comma-separated local agents to use for readiness checks, or `all`. Example: --agents claude-code,codex",
-    }),
-    handler: async (argv) => {
-        await runTestCommand(argv);
-    },
-};
-function readSandboxRetentionMode(argv) {
-    const enabled = argv["keep-sandboxes"] ?? argv.keepSandboxes ?? false;
-    return enabled ? "always" : "on-failure";
-}
-function readRequestedMode(argv) {
-    const value = argv.target;
-    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 check?",
-        options: [
-            {
-                value: "both",
-                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 Source Folder files",
-            },
-            {
-                value: "compiled",
-                label: "Portable Context only",
-                hint: "Run the saved readiness checks against the current Portable Context",
-            },
-        ],
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/local-service/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
     });
-    if (p.isCancel(selected))
-        return null;
-    return selected;
-}
-function parseRequestedAgents(argv) {
-    const raw = argv.agents;
-    if (typeof raw !== "string" || raw.trim().length === 0)
-        return null;
-    if (raw.trim() === "all") {
-        return listRunAgentOptions().map((agent) => agent.name);
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
     }
-    return raw
-        .split(",")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
 }
-async function resolveSelectedTestAgents(options) {
-    const requestedAgents = parseRequestedAgents(options.argv);
-    if (requestedAgents && requestedAgents.length > 0) {
-        const selected = [];
-        for (const agentName of requestedAgents) {
-            const resolved = resolveNamedLocalExecutor(agentName, {
-                executionProfile: options.executionProfile,
-            });
-            if (!resolved.executor) {
-                process.exitCode = 1;
-                console.log(chalk.red(`  ${resolved.error ?? `Could not resolve local agent \"${agentName}\".`}`));
-                return null;
-            }
-            const option = listRunAgentOptions().find((agent) => agent.name === agentName);
-            selected.push({
-                name: agentName,
-                label: option?.displayName ?? agentName,
-                executor: resolved.executor,
-            });
+async function callJson(url, token, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    const response = await fetch(url, { ...init, headers });
+    const raw = await response.text();
+    let body = null;
+    if (raw.length > 0) {
+        try {
+            body = JSON.parse(raw);
         }
-        return selected;
-    }
-    if (process.stdin.isTTY && process.stdout.isTTY) {
-        const prompted = await promptForTestAgents();
-        if (prompted.cancelled)
-            return null;
-        if (prompted.agents.length > 0) {
-            const selected = [];
-            for (const agent of prompted.agents) {
-                const resolved = resolveNamedLocalExecutor(agent.name, {
-                    executionProfile: options.executionProfile,
-                });
-                if (!resolved.executor) {
-                    process.exitCode = 1;
-                    console.log(chalk.red(`  ${resolved.error ?? `Could not resolve local agent \"${agent.name}\".`}`));
-                    return null;
-                }
-                selected.push({
-                    name: agent.name,
-                    label: agent.displayName,
-                    executor: resolved.executor,
-                });
-            }
-            return selected;
+        catch {
+            body = null;
         }
     }
-    const resolved = await resolveOrConfigureLocalExecutor({
-        preflight: true,
-        executionProfile: options.executionProfile,
-        purpose: "test",
-    });
-    if (!resolved.executor) {
-        if (resolved.cancelled)
-            return null;
-        process.exitCode = 1;
-        console.log(chalk.red(resolved.error ?? "No local agent detected."));
-        return null;
-    }
-    return [
-        {
-            name: resolved.executor.name,
-            label: resolved.executor.displayName,
-            executor: resolved.executor,
-        },
-    ];
+    return { status: response.status, body, raw };
 }
-async function runModeForAgent(options) {
-    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: result.rawOutcome,
-        compiledOutcome: result.compiledOutcome,
-        comparisonRunPath: result.comparisonRunPath,
-        comparison: result.comparison,
-    };
-}
-export async function runTestCommand(argv = {}) {
-    const cwd = process.cwd();
-    const detected = detectInterf(cwd);
-    const sourcePath = typeof argv.sourcePath === "string" && argv.sourcePath.trim().length > 0
-        ? argv.sourcePath.trim()
-        : (detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath(cwd));
-    const requestedPreparation = argv.preparation;
-    const requestedPreparationName = typeof requestedPreparation === "string" && requestedPreparation.trim().length > 0
-        ? requestedPreparation.trim()
-        : null;
-    const hintedPreparationConfig = (argv.preparationConfig ?? null);
-    const selectedCompiled = detected
-        ? (() => {
-            const targetName = requestedPreparationName ?? hintedPreparationConfig?.name ?? detected.config.name;
-            return resolveConfiguredPreparationSelection({
-                sourcePath,
-                requestedPreparationName: targetName,
-                hintedPreparationConfig,
-            }) ?? (targetName === detected.config.name
-                ? (loadCompiledPreparationConfig(detected.path)
-                    ?? sourcePreparationConfigFromInterfConfig(detected.config))
-                : null);
-        })()
-        : requestedPreparationName || hintedPreparationConfig
-            ? resolveConfiguredPreparationSelection({
-                sourcePath,
-                requestedPreparationName,
-                hintedPreparationConfig,
-            })
-            : await chooseCompiledConfigToBuild({
-                sourcePath,
-                selectMessage: "Which saved Preparation do you want to test?",
-            });
-    if (selectedCompiled === undefined)
-        return false;
-    if (!selectedCompiled) {
-        if (requestedPreparationName) {
-            return reportTestCommandFailure(argv, `Preparation "${requestedPreparationName}" is not saved in this Source Folder.`, ["Run `interf list` to see the saved Preparations."]);
-        }
-        return reportTestCommandFailure(argv, "No saved Preparations are configured for this Source Folder yet.", ["Start with `interf` or `interf init`."]);
-    }
-    if (selectedCompiled.checks.length === 0) {
-        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 = 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)
-        : (hasBuiltCompiled ? "both" : "raw"));
-    if (!selectedMode)
-        return false;
-    if (selectedMode === "compiled" && !hasBuiltCompiled) {
-        return reportTestCommandFailure(argv, `Preparation "${selectedCompiled.name}" does not have Portable Context agents can use yet.`, ["Run `interf compile` first."]);
-    }
-    if (selectedMode === "both" && !hasBuiltCompiled) {
-        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,
-    });
-    if (!selectedAgents || selectedAgents.length === 0) {
-        return false;
-    }
-    const rows = await Promise.all(selectedAgents.map((agent) => runModeForAgent({
-        sourcePath,
-        preparationConfig: selectedCompiled,
-        builtCompiledPath: builtCompiledPath ?? null,
-        mode,
-        preserveSandboxes,
-        executor: agent.executor,
-        saveLatest: selectedAgents.length === 1,
-    })));
-    if ((mode === "compiled" || mode === "both") && rows.some((row) => !row.compiledOutcome)) {
-        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,
-        preparationConfig: selectedCompiled,
-        builtCompiledPath: builtCompiledPath ?? null,
-        mode,
-        rows,
-    };
-    const onComplete = typeof argv.onComplete === "function"
-        ? argv.onComplete
-        : null;
-    if (rows.length === 1) {
-        const row = rows[0];
-        const comparisonRunPath = row?.comparisonRunPath ?? null;
-        const latestComparison = row?.comparison ?? null;
-        if (latestComparison) {
-            if (mode === "both") {
-                console.log();
-                console.log(chalk.dim(`  Saved summary: ${comparisonRunPath}`));
-            }
-            else {
-                printSavedTestComparisonState(latestComparison, comparisonRunPath);
-            }
+export const testCommand = {
+    command: "test <prep-id>",
+    describe: "Run readiness checks for a preparation",
+    builder: (yargs) => yargs
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .option("target", {
+        type: "string",
+        choices: ["source-files", "portable-context", "both"],
+        default: "both",
+        describe: "Which surface to test against",
+    })
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: async (args) => {
+        const { url, token } = resolveConnection(args);
+        const mode = args.target === "portable-context" ? "compiled" : args.target === "source-files" ? "source-files" : "both";
+        const { status, body, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/test-runs`, token, { method: "POST", body: JSON.stringify({ mode }) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to start test run for ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
         }
-        await onComplete?.(resultSummary);
-        return true;
-    }
-    console.log();
-    console.log(chalk.dim("  Multi-agent compare does not overwrite the saved latest single-agent result."));
-    await onComplete?.(resultSummary);
-    return true;
-}
+        console.log();
+        console.log(`  Run ${chalk.bold(body?.run_id ?? "(?)")} ${chalk.dim(`(${body?.status ?? "started"})`)}`);
+        if (body?.readiness?.status)
+            console.log(`  Readiness: ${body.readiness.status}`);
+        if (body?.error)
+            console.log(chalk.red(`  Error: ${body.error}`));
+        console.log();
+    },
+};

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

@@ -1,11 +1,2 @@
 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>;