@interf/compiler 0.9.5 → 0.13.0

package/dist/cli/commands/prep.js

@@ -0,0 +1,134 @@
+/**
+ * `interf prep` — preparation CRUD against a connected instance.
+ *
+ *   interf prep ls
+ *   interf prep create <id> --source <path> --method <id> [--about <text>]
+ *   interf prep show <id>
+ *   interf prep rm <id>
+ *
+ * Every subcommand requires an active connection. If `~/.interf/connection.json`
+ * is missing or unreachable, the command exits non-zero with the
+ * connect-or-error hint.
+ */
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection, } from "../../packages/local-service/connection-config.js";
+import { preparationResourcePath } from "../../packages/local-service/routes.js";
+function requireConnection(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.length > 0) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+export const prepCommand = {
+    command: "prep <subcommand>",
+    describe: "Manage preparations 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 preparations", (y) => y, async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/preparations`, token);
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to list preparations (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const preparations = body.preparations ?? [];
+        if (preparations.length === 0) {
+            console.log(chalk.dim("  No preparations yet. Create one with `interf prep create <id> --source <path> --method <method-id>`."));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold("  Preparations"));
+        console.log();
+        for (const prep of preparations) {
+            const sourceLabel = prep.source?.locator ?? prep.source_path ?? "(no source)";
+            const method = prep.method_id ?? "(no method)";
+            const readiness = prep.readiness?.status ?? "—";
+            console.log(`  ${prep.id}`);
+            console.log(chalk.dim(`    source: ${sourceLabel}`));
+            console.log(chalk.dim(`    method: ${method}`));
+            console.log(chalk.dim(`    readiness: ${readiness}`));
+        }
+    })
+        .command("create <prep-id>", "Create a preparation", (y) => y
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id (lowercase, dash-separated)" })
+        .option("source", { type: "string", demandOption: true, describe: "Path to the Source Folder" })
+        .option("method", { type: "string", demandOption: true, describe: "Method id (e.g. interf-default)" })
+        .option("about", { type: "string", describe: "One-line description of the agent work" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const sourceAbs = resolve(process.cwd(), args.source);
+        const requestBody = {
+            id: args.prepId,
+            source: { kind: "local-folder", locator: sourceAbs },
+            method_id: args.method,
+            about: args.about,
+            checks: [],
+        };
+        const { status, body, raw } = await callJson(`${url}/v1/preparations`, token, { method: "POST", body: JSON.stringify(requestBody) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to create preparation (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Created preparation ${chalk.bold(args.prepId)}.`));
+        if (body?.portable_context?.value) {
+            console.log(chalk.dim(`  portable context (locator): ${body.portable_context.value}`));
+        }
+    })
+        .command("show <prep-id>", "Show a preparation's full record", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}${preparationResourcePath(args.prepId)}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read preparation ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(JSON.stringify(body, null, 2));
+    })
+        .command("rm <prep-id>", "Delete a preparation", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, raw } = await callJson(`${url}${preparationResourcePath(args.prepId)}`, token, { method: "DELETE" });
+        if (status !== 200 && status !== 204) {
+            console.error(chalk.red(`Failed to delete preparation ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Deleted preparation ${chalk.bold(args.prepId)}.`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

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

@@ -1,2 +1,9 @@
 import type { CommandModule } from "yargs";
-export declare const resetCommand: CommandModule;
+interface ResetArgs {
+    prepId: string;
+    mode?: "compile" | "all";
+    url?: string;
+    token?: string;
+}
+export declare const resetCommand: CommandModule<unknown, ResetArgs>;
+export {};

package/dist/cli/commands/reset.js

@@ -1,33 +1,54 @@
+/**
+ * `interf reset <prep-id>` — reset a preparation's compile output (or all state).
+ *
+ *   interf reset bristol             # default mode = compile
+ *   interf reset bristol --mode all  # also clear method draft / runs
+ */
 import chalk from "chalk";
-import { detectInterf } from "../../packages/project-model/interf.js";
-import { submitResetToLocalService, } from "../../packages/local-service/index.js";
-import { resolveSourceControlPath, } from "../../packages/project-model/interf.js";
+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 (!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();
+    return { status: response.status, raw };
+}
 export const resetCommand = {
-    command: "reset <scope>",
-    describe: "Reset generated Portable Context state while keeping source files and the local Method package",
-    builder: (yargs) => yargs.positional("scope", {
+    command: "reset <prep-id>",
+    describe: "Reset a preparation's compile output",
+    builder: (yargs) => yargs
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .option("mode", {
         type: "string",
         choices: ["compile", "all"],
-    }),
-    handler: async (argv) => {
-        const detected = detectInterf(process.cwd());
-        if (!detected) {
-            process.exitCode = 1;
-            console.log(chalk.red("Run this from inside a Portable Context."));
-            return;
+        default: "compile",
+        describe: "Scope of the reset",
+    })
+        .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 { status, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/reset`, token, { method: "POST", body: JSON.stringify({ scope: args.mode }) });
+        if (status !== 200 && status !== 204) {
+            console.error(chalk.red(`Failed to reset ${args.prepId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
         }
-        const submitted = await submitResetToLocalService({
-            projectPath: resolveSourceControlPath(detected.path),
-            request: {
-                preparation: detected.config.name,
-                scope: argv.scope,
-            },
-        });
-        if (!submitted) {
-            process.exitCode = 1;
-            console.log(chalk.red("Interf local service is not running. Start `interf web`, then retry reset so the mutation is visible through the service API."));
-            return;
-        }
-        console.log(chalk.green(`  ${submitted.result.message}`));
+        console.log(chalk.green(`Reset ${chalk.bold(args.prepId)} (${args.mode}).`));
     },
 };

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

@@ -0,0 +1,2 @@
+import type { CommandModule } from "yargs";
+export declare const runsCommand: CommandModule;

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/local-service/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/local-service/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/test.d.ts

@@ -1,17 +1,9 @@
 import type { CommandModule } from "yargs";
-import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
-type TestMode = "raw" | "compiled" | "both";
-export interface TestCommandResult {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    builtCompiledPath: string | null;
-    mode: TestMode;
-    rows: [];
+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 {};