@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/runs.js

@@ -0,0 +1,120 @@
+/**
+ * `interf runs` — observe / cancel / fetch run records on the connected instance.
+ *
+ *   interf runs ls [--prep <id>]
+ *   interf runs status <run-id>
+ *   interf runs cancel <run-id>
+ *   interf runs fetch <run-id> --to <path>
+ */
+import chalk from "chalk";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/engine/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
+}
+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) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+export const runsCommand = {
+    command: "runs <subcommand>",
+    describe: "Inspect runs on the connected instance",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" })
+        .command("ls", "List runs (optionally filtered by preparation)", (y) => y.option("prep", { type: "string", describe: "Filter by preparation id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const path = args.prep
+            ? `/v1/preparations/${encodeURIComponent(args.prep)}/runs`
+            : "/v1/runs";
+        const { status, body, raw } = await callJson(`${url}${path}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to list runs (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const runs = body?.runs
+            ?? (body?.compile_runs ?? []).map((r) => r.run).filter(Boolean);
+        if (runs.length === 0) {
+            console.log(chalk.dim("  No runs."));
+            return;
+        }
+        console.log();
+        for (const run of runs) {
+            console.log(`  ${chalk.bold(run.run_id)} ${chalk.dim(`(${run.status ?? "?"})`)}`);
+            if (run.preparation)
+                console.log(chalk.dim(`    prep: ${run.preparation}`));
+            if (run.started_at)
+                console.log(chalk.dim(`    started: ${run.started_at}`));
+        }
+        console.log();
+    })
+        .command("status <run-id>", "Show full record for a run", (y) => y.positional("run-id", { type: "string", demandOption: true, describe: "Run id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, raw } = await callJson(`${url}/v1/runs/${encodeURIComponent(args.runId)}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read run ${args.runId} (HTTP ${status}).`));
+            process.exit(1);
+        }
+        console.log(raw);
+    })
+        .command("cancel <run-id>", "Cancel a running run", (y) => y.positional("run-id", { type: "string", demandOption: true, describe: "Run id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, raw } = await callJson(`${url}/v1/runs/${encodeURIComponent(args.runId)}/cancel`, token, { method: "POST", body: JSON.stringify({}) });
+        if (status !== 200 && status !== 202 && status !== 204) {
+            console.error(chalk.red(`Failed to cancel ${args.runId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Cancelled ${chalk.bold(args.runId)}.`));
+    })
+        .command("fetch <run-id>", "Download a run's portable context", (y) => y
+        .positional("run-id", { type: "string", demandOption: true, describe: "Run id" })
+        .option("to", { type: "string", demandOption: true, describe: "Target path" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const headers = new Headers();
+        if (token)
+            headers.set("authorization", `Bearer ${token}`);
+        const response = await fetch(`${url}/v1/runs/${encodeURIComponent(args.runId)}/artifacts/portable-context`, { headers });
+        if (response.status !== 200) {
+            console.error(chalk.red(`Failed to fetch artifact (HTTP ${response.status}).`));
+            process.exit(1);
+        }
+        const target = isAbsolute(args.to) ? args.to : resolve(process.cwd(), args.to);
+        mkdirSync(dirname(target), { recursive: true });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        writeFileSync(target, buffer);
+        console.log(chalk.green(`Wrote ${target} (${buffer.length} bytes).`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

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

@@ -1,2 +1,7 @@
 import type { CommandModule } from "yargs";
-export declare const statusCommand: CommandModule;
+interface StatusArgs {
+    url?: string;
+    token?: string;
+}
+export declare const statusCommand: CommandModule<unknown, StatusArgs>;
+export {};

package/dist/cli/commands/status.js

@@ -1,121 +1,78 @@
+/**
+ * `interf status` — print connection state + preparation summary.
+ */
 import chalk from "chalk";
-import { detectInterf, resolveSourceControlPath, } from "../../packages/project-model/interf.js";
-import { findLocalService, readLocalServiceRunSnapshot, } from "../../packages/local-service/index.js";
-import { resolveCommandControlPath } from "./control-path.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/engine/connection-config.js";
+async function callJson(url, token) {
+    const headers = new Headers();
+    if (token)
+        headers.set("authorization", `Bearer ${token}`);
+    try {
+        const response = await fetch(url, { headers });
+        const raw = await response.text();
+        let body = null;
+        if (raw) {
+            try {
+                body = JSON.parse(raw);
+            }
+            catch {
+                body = null;
+            }
+        }
+        return { status: response.status, body };
+    }
+    catch {
+        return { status: 0, body: null };
+    }
+}
 export const statusCommand = {
     command: "status",
-    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) => {
-        const detected = detectInterf(process.cwd());
-        const serviceProjectPath = detected ? resolveSourceControlPath(detected.path) : resolveCommandControlPath();
-        const service = await findLocalService({
-            projectPath: serviceProjectPath,
-            timeoutMs: 200,
+    describe: "Show connection + preparation summary",
+    builder: (yargs) => yargs
+        .option("url", { type: "string", describe: "Override the active connection URL" })
+        .option("token", { type: "string", describe: "Override the active bearer token" }),
+    handler: async (args) => {
+        const conn = readActiveConnection({
+            urlOverride: args.url,
+            authTokenOverride: args.token,
         });
-        if (service) {
-            await printLocalServiceStatus(service.serviceUrl);
-            if (argv.watch === true) {
-                await watchLocalServiceStatus(service.serviceUrl);
-            }
-            return;
+        if (!conn) {
+            console.error(CONNECT_OR_ERROR_HINT);
+            process.exit(1);
+        }
+        const url = conn.url.replace(/\/+$/, "");
+        const token = conn.auth_token;
+        const instance = await callJson(`${url}/v1/instance`, token);
+        if (instance.status === 0) {
+            console.error(chalk.red(`Connection ${url} is unreachable.`));
+            console.error(CONNECT_OR_ERROR_HINT);
+            process.exit(1);
         }
-        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) {
-    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.readiness_run?.compiled;
-    const raw = run.readiness_run?.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}`));
+        console.log(chalk.bold("  Interf engine"));
+        console.log(`  URL:      ${url}`);
+        if (instance.body?.pid)
+            console.log(`  PID:      ${instance.body.pid}`);
+        if (instance.body?.package_version)
+            console.log(`  Version:  ${instance.body.package_version}`);
+        if (instance.body?.uptime_seconds !== undefined) {
+            console.log(`  Uptime:   ${instance.body.uptime_seconds}s`);
         }
-    }
-    if (latestCompile) {
+        console.log(`  Auth:     ${instance.body?.auth_required ? "required (token in connection.json)" : "open (loopback)"}`);
+        const preps = await callJson(`${url}/v1/preparations`, token);
+        const list = preps.body?.preparations ?? [];
         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}`));
+        console.log(chalk.bold(`  Preparations (${list.length})`));
+        if (list.length === 0) {
+            console.log(chalk.dim("  No preparations yet. `interf prep create <id> --source <path> --method <id>`."));
+        }
+        else {
+            for (const prep of list) {
+                const readiness = prep.readiness?.status ?? "—";
+                console.log(`  ${chalk.bold(prep.id)} ${chalk.dim(`(${prep.method_id} · ${readiness})`)}`);
+                console.log(chalk.dim(`    source: ${prep.source.locator}`));
+            }
         }
-    }
-    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/verify.d.ts

@@ -1,2 +1,8 @@
 import type { CommandModule } from "yargs";
-export declare const verifyCommand: CommandModule;
+interface VerifyArgs {
+    prepId: string;
+    url?: string;
+    token?: string;
+}
+export declare const verifyCommand: CommandModule<unknown, VerifyArgs>;
+export {};

package/dist/cli/commands/verify.js

@@ -1,94 +1,78 @@
+/**
+ * `interf verify <prep-id>` — verify a preparation's claim-checks via a
+ * judge against the latest compiled portable context. Together with the
+ * method's structural checks (auto-run on every `interf compile`), this
+ * feeds the preparation's overall readiness state.
+ *
+ *   interf verify bristol
+ */
 import chalk from "chalk";
-import { detectInterf } from "../../packages/project-model/interf.js";
-import { validateCompiledCompile, validateCompiledStage, } from "../../packages/compiler/validate.js";
-import { validateMethodPackage } from "../../packages/method-package/local-methods.js";
-function normalizeVerifyCheck(value) {
-    if (!value)
-        return null;
-    if (value === "stage")
-        return "stage";
-    if (value === "portable-context")
-        return "portable-context";
-    if (value === "method")
-        return "method";
-    return null;
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/engine/connection-config.js";
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url,
+        authTokenOverride: args.token,
+    });
+    if (!conn) {
+        console.error(CONNECT_OR_ERROR_HINT);
+        process.exit(1);
+    }
+    return { url: conn.url.replace(/\/+$/, ""), token: conn.auth_token };
 }
-export const verifyCommand = {
-    command: "verify <check> [stageId]",
-    describe: "Run deterministic verification checks",
-    builder: (yargs) => yargs
-        .positional("check", {
-        type: "string",
-        describe: "Check to run (`stage`, `portable-context`, or `method`)",
-    })
-        .positional("stageId", {
-        type: "string",
-        describe: "Stage id when using `verify stage <stage-id>`",
-    })
-        .option("path", {
-        type: "string",
-        describe: "Path to a Method package when using `verify method`",
-    })
-        .option("json", {
-        type: "boolean",
-        default: false,
-        describe: "Print JSON output",
-    }),
-    handler: async (argv) => {
-        const check = normalizeVerifyCheck(argv.check);
-        if (!check) {
-            process.exitCode = 1;
-            console.log(chalk.red(`Unknown verify check: ${String(argv.check)}`));
-            return;
+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);
         }
-        let result;
-        if (check === "method") {
-            const path = argv.path;
-            if (!path) {
-                process.exitCode = 1;
-                console.log(chalk.red("`interf verify method` needs --path <method-dir>."));
-                return;
-            }
-            result = validateMethodPackage(path);
+        catch {
+            body = null;
         }
-        else {
-            const detected = detectInterf(process.cwd());
-            if (!detected) {
-                process.exitCode = 1;
-                console.log(chalk.red("Run this from inside Portable Context."));
-                return;
-            }
-            if (check === "portable-context") {
-                result = validateCompiledCompile(detected.path);
-            }
-            else {
-                const stageId = argv.stageId;
-                if (!stageId) {
-                    process.exitCode = 1;
-                    console.log(chalk.red("`interf verify stage` needs <stage-id>."));
-                    return;
-                }
-                result = validateCompiledStage(detected.path, stageId);
-            }
+    }
+    return { status: response.status, body, raw };
+}
+export const verifyCommand = {
+    command: "verify <prep-id>",
+    describe: "Verify a preparation's claim-checks against its portable context",
+    builder: (yargs) => yargs
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .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);
+        // 0.15 hard-error: refuse to start a verify run if the engine has
+        // zero connected agents — verifier-role stages can't run without
+        // one.
+        const instance = await callJson(`${url}/v1/instance`, token);
+        if (instance.body && instance.body.agent_count === 0) {
+            console.error(chalk.red("  Cannot verify — no agents available."));
+            console.error("  Install Claude Code, Codex, Gemini, or another agent CLI, or");
+            console.error("  register a custom CLI: `interf agents register <name> --command <cmd>`.");
+            process.exit(1);
         }
-        if (argv.json) {
-            console.log(JSON.stringify(result, null, 2));
-            if (typeof result === "object" && result && "ok" in result && !result.ok) {
-                process.exitCode = 1;
-            }
-            return;
+        // Verify the user's claims against the compiled portable context.
+        // The legacy "source-files" / "both" targets (file-as-is judging)
+        // are gone — claims are evaluated against the compiled output only.
+        const { status, body, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/verify-runs`, token, { method: "POST", body: JSON.stringify({ mode: "compiled" }) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to start verify run for ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
         }
-        const typed = result;
         console.log();
-        if (typed.ok) {
-            console.log(chalk.green(`  ${typed.summary ?? "Verification passed."}`));
-        }
-        else {
-            process.exitCode = 1;
-            console.log(chalk.red(`  ${typed.summary ?? "Verification failed."}`));
-            for (const error of typed.errors ?? []) {
-                console.log(chalk.dim(`  - ${error}`));
-            }
-        }
+        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>;