@interf/compiler 0.9.4 → 0.9.5

package/dist/cli/commands/status.js

@@ -1,50 +1,7 @@
 import chalk from "chalk";
-import * as p from "@clack/prompts";
-import { detectInterf, listPortableContextsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { computeCompiledHealth } from "../../packages/compiler/state.js";
-import { sourcePreparationConfigFromInterfConfig, loadCompiledPreparationConfig, } from "../../packages/project-model/source-config.js";
-import { printSavedTestComparisonState, readCurrentSavedTestComparison } from "./test-flow.js";
+import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 import { findLocalService, readLocalServiceRunSnapshot, } from "../../packages/local-service/index.js";
 import { resolveCommandControlPath } from "./control-path.js";
-function statusColor(status) {
-    switch (status) {
-        case "compiled":
-            return chalk.green;
-        case "running":
-            return chalk.yellow;
-        case "failed":
-            return chalk.red;
-        default:
-            return chalk.dim;
-    }
-}
-function publicReadinessStatus(status) {
-    return status === "compiled" ? "ready" : "not ready";
-}
-function publicPrepareState(status) {
-    if (status === "compiled")
-        return "prepared";
-    if (status === "idle")
-        return "not prepared";
-    return status;
-}
-function publicHealthSummary(health) {
-    const completedStages = health.metrics.completed_stages;
-    const stageTotal = health.metrics.stage_total;
-    if (typeof completedStages === "number" && typeof stageTotal === "number") {
-        if (health.status === "compiled") {
-            return `Portable Context ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
-        }
-        if (health.status === "stale") {
-            return `Portable Context not ready — ${completedStages}/${stageTotal} Method stages satisfied.`;
-        }
-    }
-    return health.summary
-        .replace(/\bCompiled\b/g, "Prepared")
-        .replace(/\bcompiled\b/g, "prepared")
-        .replace(/\bmethod stages\b/g, "Method stages")
-        .replace(/\bmethod stage\b/g, "Method stage");
-}
 export const statusCommand = {
     command: "status",
     describe: "Show deterministic health for the Portable Context agents use",
@@ -54,7 +11,6 @@ export const statusCommand = {
         describe: "Poll the local Interf service for live run status",
     }),
     handler: async (argv) => {
-        let compiledPath = null;
         const detected = detectInterf(process.cwd());
         const serviceProjectPath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
         const service = await findLocalService({
@@ -68,82 +24,10 @@ export const statusCommand = {
             }
             return;
         }
-        if (detected) {
-            compiledPath = detected.path;
-        }
-        else {
-            const sourcePath = resolveCommandControlPath();
-            const local = listPortableContextsForSourceFolder(sourcePath).map(({ path, config }) => ({
-                path,
-                name: config.name,
-            }));
-            if (local.length === 0) {
-                process.exitCode = 1;
-                console.log(chalk.red("  No Portable Context found."));
-                console.log(chalk.dim("  Run `interf`, save readiness checks, and compile Portable Context agents can use first."));
-                return;
-            }
-            if (local.length === 1) {
-                compiledPath = local[0].path;
-            }
-            else {
-                const selected = await p.select({
-                    message: "Which Portable Context?",
-                    options: local.map((entry) => ({ value: entry.path, label: entry.name })),
-                });
-                if (p.isCancel(selected))
-                    return;
-                compiledPath = selected;
-            }
-        }
-        const health = computeCompiledHealth(compiledPath);
-        const color = statusColor(health.status);
-        console.log();
-        console.log(color(`  ${health.target_name}`));
-        console.log(chalk.dim(`  readiness: ${publicReadinessStatus(health.status)}`));
-        console.log(chalk.dim(`  prepare state: ${publicPrepareState(health.status)}`));
-        console.log(chalk.dim(`  ${publicHealthSummary(health)}`));
-        const compiledConfig = readInterfConfig(compiledPath);
-        const sourcePath = resolveSourceControlPath(compiledPath);
-        const latestComparisonState = compiledConfig
-            ? readCurrentSavedTestComparison({
-                projectPath: sourcePath,
-                preparationName: compiledConfig.name,
-                checks: (loadCompiledPreparationConfig(compiledPath)
-                    ?? sourcePreparationConfigFromInterfConfig(compiledConfig)).checks,
-            })
-            : { comparison: null, stale: false };
-        const latestComparison = latestComparisonState.comparison;
-        if (latestComparison) {
-            printSavedTestComparisonState(latestComparison);
-        }
-        else {
-            console.log();
-            console.log(chalk.dim(latestComparisonState.stale
-                ? "  Saved readiness results are stale for the current checks. Run `interf test` again."
-                : "  No saved readiness check run yet. Run `interf test` to check source files and Portable Context."));
-        }
-        console.log();
-        const metricOrder = [
-            "source_total",
-            "stage_total",
-            "completed_stages",
-            "warnings",
-            "errors",
-        ];
-        const printed = new Set();
-        for (const key of metricOrder) {
-            const value = health.metrics[key];
-            if (typeof value !== "number")
-                continue;
-            printed.add(key);
-            console.log(chalk.dim(`  ${key}: ${value}`));
-        }
-        for (const [key, value] of Object.entries(health.metrics)) {
-            if (printed.has(key))
-                continue;
-            console.log(chalk.dim(`  ${key}: ${value}`));
-        }
+        process.exitCode = 1;
+        console.log(chalk.red("  Interf local service is not running."));
+        console.log(chalk.dim("  Start `interf web`, then rerun `interf status` so status comes from the service source of truth."));
+        return;
     },
 };
 function formatEventTime(value) {
@@ -157,8 +41,8 @@ function formatEventTime(value) {
     });
 }
 function testScore(run) {
-    const compiled = run.comparison?.compiled;
-    const raw = run.comparison?.raw;
+    const compiled = run.readiness_run?.compiled;
+    const raw = run.readiness_run?.raw;
     if (compiled)
         return `${compiled.passed_cases}/${compiled.total_cases}`;
     if (raw)

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

@@ -1,13 +1,12 @@
 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[];
+    rows: [];
 }
 export interface TestCommandFailure {
     message: string;

package/dist/cli/commands/test.js

@@ -2,20 +2,17 @@ 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 { choosePreparationConfig, } from "./preparation-picker.js";
+import { findBuiltPortableContextPath, } from "../../packages/project-model/preparation-entries.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)
+    builder: (yargs) => yargs
         .option("preparation", {
         type: "string",
         describe: "Preparation id to check when this Source Folder has more than one Preparation",
@@ -23,24 +20,11 @@ export const testCommand = {
         .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"
@@ -97,103 +81,6 @@ async function promptTestMode(hasBuiltCompiled) {
         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);
-    }
-    return raw
-        .split(",")
-        .map((value) => value.trim())
-        .filter((value) => value.length > 0);
-}
-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,
-            });
-        }
-        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;
-        }
-    }
-    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,
-        },
-    ];
-}
-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);
@@ -223,7 +110,7 @@ export async function runTestCommand(argv = {}) {
                 requestedPreparationName,
                 hintedPreparationConfig,
             })
-            : await chooseCompiledConfigToBuild({
+            : await choosePreparationConfig({
                 sourcePath,
                 selectMessage: "Which saved Preparation do you want to test?",
             });
@@ -241,11 +128,9 @@ export async function runTestCommand(argv = {}) {
             "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);
+        : findBuiltPortableContextPath(sourcePath, selectedCompiled.name);
     const hasBuiltCompiled = builtCompiledPath
         ? createCompiledTestTarget(builtCompiledPath, selectedCompiled.name, resolveMethodId(selectedCompiled)).eligible
         : false;
@@ -255,97 +140,49 @@ export async function runTestCommand(argv = {}) {
         : (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 submitted = await submitTestRunToLocalService({
+        projectPath: sourcePath,
+        request: {
+            preparation: selectedCompiled.name,
+            mode,
+        },
+    });
+    if (!submitted) {
+        return reportTestCommandFailure(argv, "Interf local service is not running for this Workspace.", ["Start it with `interf web`, then rerun `interf test` so the readiness-check run is visible in Interf."]);
     }
-    const selectedAgents = await resolveSelectedTestAgents({
-        argv,
-        executionProfile,
+    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 (!selectedAgents || selectedAgents.length === 0) {
-        return false;
+    if (completed.status !== "succeeded") {
+        return reportTestCommandFailure(argv, `Readiness check run ${completed.status}.`, completed.error ? [completed.error] : []);
     }
-    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."]);
+    const compiledScore = completed.readiness_run?.compiled;
+    const rawScore = completed.readiness_run?.raw;
+    if (compiledScore) {
+        console.log(chalk.green(`  Portable Context readiness checks: ${compiledScore.passed_cases}/${compiledScore.total_cases}`));
     }
-    printAgentTestMatrix(rows);
-    printAgentTestFailures(rows);
-    const resultSummary = {
+    if (rawScore) {
+        console.log(chalk.dim(`  Source files readiness checks: ${rawScore.passed_cases}/${rawScore.total_cases}`));
+    }
+    const onComplete = typeof argv.onComplete === "function"
+        ? argv.onComplete
+        : null;
+    await onComplete?.({
         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);
-            }
-        }
-        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);
+        rows: [],
+    });
     return true;
 }