@interf/compiler 0.7.3 → 0.9.3

package/dist/cli/commands/status.js

@@ -1,9 +1,11 @@
 import chalk from "chalk";
 import * as p from "@clack/prompts";
-import { detectInterf, listCompiledDatasetsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+import { detectInterf, listPortableContextsForSourceFolder, readInterfConfig, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
 import { computeCompiledHealth } from "../../packages/compiler/state.js";
-import { sourceDatasetConfigFromInterfConfig, loadCompiledDatasetConfig, } from "../../packages/project-model/source-config.js";
+import { sourcePreparationConfigFromInterfConfig, loadCompiledPreparationConfig, } from "../../packages/project-model/source-config.js";
 import { printSavedTestComparisonState, readCurrentSavedTestComparison } from "./test-flow.js";
+import { findLocalService, readLocalServiceRunSnapshot, } from "../../packages/local-service/index.js";
+import { resolveCommandControlPath } from "./control-path.js";
 function statusColor(status) {
     switch (status) {
         case "compiled":
@@ -16,25 +18,69 @@ function statusColor(status) {
             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",
-    handler: async () => {
+    describe: "Show deterministic health for the Portable Context agents use",
+    builder: (yargs) => yargs.option("watch", {
+        type: "boolean",
+        default: false,
+        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({
+            projectPath: serviceProjectPath,
+            timeoutMs: 200,
+        });
+        if (service) {
+            await printLocalServiceStatus(service.serviceUrl);
+            if (argv.watch === true) {
+                await watchLocalServiceStatus(service.serviceUrl);
+            }
+            return;
+        }
         if (detected) {
             compiledPath = detected.path;
         }
         else {
-            const sourcePath = process.cwd();
-            const local = listCompiledDatasetsForSourceFolder(sourcePath).map(({ path, config }) => ({
+            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 contexts found."));
-                console.log(chalk.dim("  Run `interf`, save questions, and compile portable context agents can use first."));
+                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) {
@@ -42,7 +88,7 @@ export const statusCommand = {
             }
             else {
                 const selected = await p.select({
-                    message: "Which setup?",
+                    message: "Which Portable Context?",
                     options: local.map((entry) => ({ value: entry.path, label: entry.name })),
                 });
                 if (p.isCancel(selected))
@@ -54,17 +100,17 @@ export const statusCommand = {
         const color = statusColor(health.status);
         console.log();
         console.log(color(`  ${health.target_name}`));
-        console.log(chalk.dim(`  status: ${health.status}`));
-        console.log(chalk.dim(`  stage: ${health.stage}`));
-        console.log(chalk.dim(`  ${health.summary}`));
+        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,
-                datasetName: compiledConfig.name,
-                checks: (loadCompiledDatasetConfig(compiledPath)
-                    ?? sourceDatasetConfigFromInterfConfig(compiledConfig)).checks,
+                preparationName: compiledConfig.name,
+                checks: (loadCompiledPreparationConfig(compiledPath)
+                    ?? sourcePreparationConfigFromInterfConfig(compiledConfig)).checks,
             })
             : { comparison: null, stale: false };
         const latestComparison = latestComparisonState.comparison;
@@ -74,8 +120,8 @@ export const statusCommand = {
         else {
             console.log();
             console.log(chalk.dim(latestComparisonState.stale
-                ? "  Saved test results are stale for the current questions. Run `interf test` again."
-                : "  No saved comparison yet. Run `interf test` to measure source files and portable context."));
+                ? "  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 = [
@@ -100,3 +146,92 @@ export const statusCommand = {
         }
     },
 };
+function formatEventTime(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.valueOf()))
+        return value;
+    return date.toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit",
+    });
+}
+function testScore(run) {
+    const compiled = run.comparison?.compiled;
+    const raw = run.comparison?.raw;
+    if (compiled)
+        return `${compiled.passed_cases}/${compiled.total_cases}`;
+    if (raw)
+        return `${raw.passed_cases}/${raw.total_cases}`;
+    return "pending";
+}
+function compileRunEventDetail(event) {
+    if ("message" in event && typeof event.message === "string")
+        return event.message;
+    if ("summary" in event && typeof event.summary === "string")
+        return event.summary;
+    if ("error" in event && typeof event.error === "string")
+        return event.error;
+    if ("stage_id" in event && typeof event.stage_id === "string")
+        return event.stage_id;
+    return "recorded";
+}
+async function printLocalServiceStatus(serviceUrl) {
+    const { jobs, compileRuns, testRuns } = await readLocalServiceRunSnapshot({ serviceUrl });
+    const latestJob = jobs[0] ?? null;
+    const latestCompile = compileRuns[0]?.run ?? null;
+    const latestTest = testRuns[0] ?? null;
+    console.log();
+    console.log(chalk.green("  Interf local service is running"));
+    console.log(chalk.dim(`  Interf: ${serviceUrl}/`));
+    if (latestJob) {
+        console.log();
+        console.log(chalk.bold(`  Latest local job: ${latestJob.title}`));
+        console.log(chalk.dim(`  run: ${latestJob.run_id}`));
+        console.log(chalk.dim(`  type: ${latestJob.job_type}`));
+        console.log(chalk.dim(`  status: ${latestJob.status}`));
+        const stepSummary = latestJob.steps
+            .map((step) => `${step.id}:${step.status}`)
+            .join(", ");
+        if (stepSummary)
+            console.log(chalk.dim(`  steps: ${stepSummary}`));
+        for (const event of latestJob.events.slice(-4)) {
+            const detail = event.message ?? event.step_id ?? "recorded";
+            console.log(chalk.dim(`  ${formatEventTime(event.timestamp)} ${event.type} ${detail}`));
+        }
+    }
+    if (latestCompile) {
+        console.log();
+        console.log(chalk.bold(`  Latest prepare run: ${latestCompile.preparation}`));
+        console.log(chalk.dim(`  run: ${latestCompile.run_id}`));
+        console.log(chalk.dim(`  status: ${latestCompile.status}`));
+        console.log(chalk.dim(`  Method: ${latestCompile.method}`));
+        const stageSummary = latestCompile.stages
+            .map((stage) => `${stage.stage_id}:${stage.status}`)
+            .join(", ");
+        if (stageSummary)
+            console.log(chalk.dim(`  stages: ${stageSummary}`));
+        const events = latestCompile.events.slice(-6);
+        for (const event of events) {
+            const detail = compileRunEventDetail(event);
+            console.log(chalk.dim(`  ${formatEventTime(event.timestamp)} ${event.type} ${detail}`));
+        }
+    }
+    else {
+        console.log(chalk.dim("  No prepare runs recorded by the local service yet."));
+    }
+    if (latestTest) {
+        console.log();
+        console.log(chalk.bold(`  Latest readiness check run: ${latestTest.preparation}`));
+        console.log(chalk.dim(`  status: ${latestTest.status}`));
+        console.log(chalk.dim(`  mode: ${latestTest.mode}`));
+        console.log(chalk.dim(`  readiness checks: ${testScore(latestTest)}`));
+    }
+}
+async function watchLocalServiceStatus(serviceUrl) {
+    while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        console.clear();
+        await printLocalServiceStatus(serviceUrl);
+    }
+}

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

@@ -1,8 +1,8 @@
-import { type TestTargetCandidate, type TestTargetResult } from "../../packages/testing/test.js";
-import type { WorkflowExecutionProfile, WorkflowExecutor } from "../../packages/agents/lib/executors.js";
+import type { TestTargetCandidate, TestTargetResult } from "../../packages/testing/test.js";
+import type { MethodExecutionProfile, MethodExecutor } from "../../packages/agents/lib/executors.js";
 import type { TestSandboxRetentionMode } from "../../packages/testing/test-sandbox.js";
-import type { SourceDatasetConfig } from "../../packages/project-model/lib/schema.js";
-import type { TestRunComparison, TestRunMode } from "../../packages/testing/lib/schema.js";
+import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
+import type { ReadinessCheckRun, TestRunMode } from "../../packages/testing/lib/schema.js";
 export interface SavedTestOutcome {
     runPath: string;
     displayRunPath?: string;
@@ -14,17 +14,17 @@ export interface AgentTestMatrixRow {
     rawOutcome?: SavedTestOutcome | null;
     compiledOutcome?: SavedTestOutcome | null;
 }
-export declare function questionPassRate(outcome: SavedTestOutcome): number;
-export declare function readSavedTestComparison(projectPath: string, datasetName: string): TestRunComparison | null;
+export declare function readinessPassRate(outcome: SavedTestOutcome): number;
+export declare function readSavedTestComparison(projectPath: string, preparationName: string): ReadinessCheckRun | null;
 export declare function readCurrentSavedTestComparison(options: {
     projectPath: string;
-    datasetName: string;
-    checks: SourceDatasetConfig["checks"];
+    preparationName: string;
+    checks: SourcePreparationConfig["checks"];
 }): {
-    comparison: TestRunComparison | null;
+    comparison: ReadinessCheckRun | null;
     stale: boolean;
 };
-export declare function printSavedTestComparisonState(payload: TestRunComparison, comparisonRunPath?: string | null): void;
+export declare function printSavedTestComparisonState(payload: ReadinessCheckRun, comparisonRunPath?: string | null): void;
 export declare function printAgentTestMatrix(rows: AgentTestMatrixRow[]): void;
 export declare function printAgentTestFailures(rows: AgentTestMatrixRow[]): void;
 export declare function printSavedTestOutcome(prefix: string, outcome: SavedTestOutcome): void;
@@ -41,17 +41,17 @@ export declare function saveTestComparisonRun(options: {
 }): string;
 export declare function runSavedRawTest(options: {
     sourcePath: string;
-    datasetConfig: SourceDatasetConfig;
-    executor?: WorkflowExecutor | null;
-    executionProfile?: WorkflowExecutionProfile;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    executionProfile?: MethodExecutionProfile;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;
 }): Promise<SavedTestOutcome | null>;
 export declare function runSavedCompiledTest(options: {
     sourcePath: string;
-    datasetConfig: SourceDatasetConfig;
-    executor?: WorkflowExecutor | null;
-    executionProfile?: WorkflowExecutionProfile;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    executionProfile?: MethodExecutionProfile;
     compiledPath?: string | null;
     preserveSandboxes?: TestSandboxRetentionMode;
     runSuffix?: string | null;