@interf/compiler 0.22.0 → 0.33.0

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

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

package/dist/cli/commands/project.js

@@ -0,0 +1,202 @@
+/**
+ * `interf project` — Project CRUD against a connected instance.
+ *
+ *   interf project ls
+ *   interf project create <id> --source <path> [--build-plan <id>]
+ *   interf project show <id>
+ *   interf project 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/runtime/connection-config.js";
+import { projectResourcePath } from "../../packages/runtime/service/routes.js";
+import { ProjectListResponseSchema, ProjectResourceSchema, ProjectWireShapeSchema, } from "../../packages/runtime/schemas/index.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 };
+}
+function statusColor(status) {
+    if (status === "ready")
+        return chalk.green;
+    if (status === "failed")
+        return chalk.red;
+    if (status === "skipped")
+        return chalk.dim;
+    return chalk.yellow;
+}
+function renderProjectSummary(project) {
+    console.log();
+    console.log(`  ${chalk.bold(project.name)}`);
+    console.log(chalk.dim(`    Build Plan: ${project.build_plan_id ?? "(not selected)"}`));
+    if (project.source_path)
+        console.log(chalk.dim(`    source:  ${project.source_path}`));
+    const contextGraphPath = project.context_graph_path;
+    if (contextGraphPath) {
+        console.log(chalk.dim(`    Context Graph: ${contextGraphPath}`));
+    }
+    if (project.readiness?.status) {
+        const aggColor = project.readiness.ready ? chalk.green : chalk.yellow;
+        console.log(`    readiness: ${aggColor(project.readiness.status)}${project.readiness.summary ? chalk.dim(` (${project.readiness.summary})`) : ""}`);
+    }
+    if (project.artifacts && project.artifacts.length > 0) {
+        console.log();
+        console.log(chalk.bold("    Artifacts"));
+        const idWidth = Math.max(...project.artifacts.map((entry) => entry.artifact_id.length), 8);
+        for (const artifact of project.artifacts) {
+            const colored = statusColor(artifact.status)(artifact.status);
+            const stages = artifact.built_by_stages && artifact.built_by_stages.length > 0
+                ? chalk.dim(` ← ${artifact.built_by_stages.join(", ")}`)
+                : "";
+            console.log(`      ${artifact.artifact_id.padEnd(idWidth)}  ${colored}${stages}`);
+        }
+    }
+    if (project.latest_build_run_id) {
+        console.log();
+        console.log(chalk.dim(`    latest Build: ${project.latest_build_run_id}`));
+    }
+    if (project.latest_benchmark_run_id) {
+        console.log(chalk.dim(`    latest benchmark:   ${project.latest_benchmark_run_id}`));
+    }
+    console.log();
+    console.log(chalk.dim(`  Run with --json for the raw resource record.`));
+    console.log();
+}
+export const projectCommand = {
+    command: "project <subcommand>",
+    describe: "Manage Projects on the connected instance",
+    aliases: [],
+    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 Projects", (y) => y, async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/projects`, token);
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to list Projects (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const parsed = ProjectListResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red("Failed to parse Project list."));
+            process.exit(1);
+        }
+        const projects = parsed.data.projects;
+        if (projects.length === 0) {
+            console.log(chalk.dim("  No Projects yet. Create one with `interf project create <id> --source <path>`."));
+            return;
+        }
+        console.log();
+        console.log(chalk.bold("  Projects"));
+        console.log();
+        for (const project of projects) {
+            const sourceLabel = project.source.locator;
+            const buildPlan = project.build_plan_id ?? "(no Build Plan)";
+            console.log(`  ${project.id}`);
+            console.log(chalk.dim(`    source: ${sourceLabel}`));
+            console.log(chalk.dim(`    Build Plan: ${buildPlan}`));
+        }
+    })
+        .command("create <project-id>", "Create a Project (Build Plan optional — select or draft it later)", (y) => y
+        .positional("project-id", { type: "string", demandOption: true, describe: "Project id (lowercase, dash-separated)" })
+        .option("source", { type: "string", demandOption: true, describe: "Path to the Source" })
+        .option("build-plan", { type: "string", describe: "Build Plan id. Optional — select later with `interf plan select`." }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const sourceAbs = resolve(process.cwd(), args.source);
+        const requestBody = {
+            id: args.projectId,
+            source: { kind: "local-folder", locator: sourceAbs },
+            ...(args.buildPlan ? { build_plan_id: args.buildPlan } : {}),
+        };
+        const { status, body, raw } = await callJson(`${url}/v1/projects`, token, { method: "POST", body: JSON.stringify(requestBody) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to create Project (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Created Project ${chalk.bold(args.projectId)}.`));
+        if (!args.buildPlan) {
+            console.log(chalk.dim(`  no Build Plan selected yet — pick or draft one before building:`));
+            console.log(chalk.dim(`    interf plan select ${args.projectId} <plan-id>`));
+            console.log(chalk.dim(`    interf plan draft ${args.projectId} --intent "..."`));
+        }
+        const parsed = ProjectWireShapeSchema.safeParse(body);
+        if (parsed.success && parsed.data.build_plan_id && parsed.data.context_graph.value) {
+            console.log(chalk.dim(`  Context Graph: ${parsed.data.context_graph.value}`));
+        }
+    })
+        .command("show <project-id>", "Show a Project's full record", (y) => y
+        .positional("project-id", { type: "string", demandOption: true, describe: "Project id" })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        describe: "Print the raw JSON record instead of the formatted summary",
+    }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, body, raw } = await callJson(`${url}${projectResourcePath(args.projectId)}`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read Project ${args.projectId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        if (args.json || !body) {
+            console.log(JSON.stringify(body, null, 2));
+            return;
+        }
+        const parsed = ProjectResourceSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red(`Failed to parse Project ${args.projectId}.`));
+            process.exit(1);
+        }
+        renderProjectSummary(parsed.data);
+    })
+        .command("rm <project-id>", "Delete a Project", (y) => y.positional("project-id", { type: "string", demandOption: true, describe: "Project id" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, raw } = await callJson(`${url}${projectResourcePath(args.projectId)}`, token, { method: "DELETE" });
+        if (status !== 200 && status !== 204) {
+            console.error(chalk.red(`Failed to delete Project ${args.projectId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Deleted Project ${chalk.bold(args.projectId)}.`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

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

@@ -1,6 +1,6 @@
 import type { CommandModule } from "yargs";
 interface ResetArgs {
-    prepId: string;
+    projectId: string;
     mode?: "build" | "all";
     url?: string;
     token?: string;

package/dist/cli/commands/reset.js

@@ -1,11 +1,11 @@
 /**
- * `interf reset <prep-id>` — reset a preparation's built output (or all state).
+ * `interf reset <project-id>` — reset a Project's built output (or all state).
  *
- *   interf reset bristol             # default mode = build
- *   interf reset bristol --mode all  # also clear Build Plan draft / runs
+ *   interf reset bristol             # default mode = build (clears the Context Graph)
+ *   interf reset bristol --mode all  # also clear Build Plan draft runs
  */
 import chalk from "chalk";
-import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/engine/connection-config.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/runtime/connection-config.js";
 function resolveConnection(args) {
     const conn = readActiveConnection({
         urlOverride: args.url,
@@ -28,10 +28,10 @@ async function callJson(url, token, init = {}) {
     return { status: response.status, raw };
 }
 export const resetCommand = {
-    command: "reset <prep-id>",
-    describe: "Reset a preparation's built output",
+    command: "reset <project-id>",
+    describe: "Reset a Project's built output",
     builder: (yargs) => yargs
-        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .positional("project-id", { type: "string", demandOption: true, describe: "Project id" })
         .option("mode", {
         type: "string",
         choices: ["build", "all"],
@@ -42,13 +42,13 @@ export const resetCommand = {
         .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 }) });
+        const { status, raw } = await callJson(`${url}/v1/projects/${encodeURIComponent(args.projectId)}/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}).`));
+            console.error(chalk.red(`Failed to reset ${args.projectId} (HTTP ${status}).`));
             if (raw)
                 console.error(raw);
             process.exit(1);
         }
-        console.log(chalk.green(`Reset ${chalk.bold(args.prepId)} (${args.mode}).`));
+        console.log(chalk.green(`Reset ${chalk.bold(args.projectId)} (${args.mode}).`));
     },
 };

package/dist/cli/commands/runs.js

@@ -1,12 +1,13 @@
 /**
- * `interf runs` — observe / cancel / fetch run records on the connected instance.
+ * `interf runs` — observe, cancel, and fetch durable run records on the connected instance.
  *
- *   interf runs ls [--prep <id>]
+ *   interf runs ls [--project <id>]
  *   interf runs status <run-id>
  *   interf runs cancel <run-id>
  */
 import chalk from "chalk";
-import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/engine/connection-config.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/runtime/connection-config.js";
+import { RunObservabilityListResponseSchema, RunObservabilityResourceSchema, } from "../../packages/runtime/schemas/index.js";
 function resolveConnection(args) {
     const conn = readActiveConnection({
         urlOverride: args.url,
@@ -54,8 +55,8 @@ function renderRunStatus(run) {
     console.log(chalk.dim(`    run: ${run.run_id}`));
     if (run.run_type)
         console.log(chalk.dim(`    type: ${run.run_type}`));
-    if (run.preparation)
-        console.log(chalk.dim(`    preparation: ${run.preparation}`));
+    if (run.project)
+        console.log(chalk.dim(`    project: ${run.project}`));
     if (run.build_plan)
         console.log(chalk.dim(`    Build Plan: ${run.build_plan}`));
     if (run.agent_label)
@@ -64,8 +65,8 @@ function renderRunStatus(run) {
         console.log(chalk.dim(`    started: ${run.started_at}`));
     if (run.finished_at)
         console.log(chalk.dim(`    finished: ${run.finished_at}`));
-    if (run.output_path ?? run.verifiable_context_path) {
-        console.log(chalk.dim(`    output: ${run.output_path ?? run.verifiable_context_path}`));
+    if (run.output_path) {
+        console.log(chalk.dim(`    output: ${run.output_path}`));
     }
     if (run.trace?.run?.error?.message) {
         console.log();
@@ -83,8 +84,7 @@ function renderRunStatus(run) {
         console.log();
         console.log(chalk.bold("    Metrics"));
         for (const metric of metrics.slice(0, 8)) {
-            const value = metric.value !== undefined ? `${metric.value}${metric.unit ? ` ${metric.unit}` : ""}` : "";
-            console.log(chalk.dim(`      ${metric.label ?? "metric"}: ${value}`));
+            console.log(chalk.dim(`      ${metric.label}: ${metric.value}${metric.detail ? ` (${metric.detail})` : ""}`));
         }
     }
     const artifacts = run.artifacts ?? [];
@@ -93,21 +93,21 @@ function renderRunStatus(run) {
         console.log(chalk.bold("    Artifacts"));
         for (const artifact of artifacts.slice(0, 12)) {
             const stage = artifact.stage_id ? chalk.dim(` ← ${artifact.stage_id}`) : "";
-            console.log(`      ${artifact.label ?? artifact.role}: ${chalk.dim(artifact.path)}${stage}`);
+            console.log(`      ${artifact.label ?? "output"}: ${chalk.dim(artifact.path)}${stage}`);
         }
         if (artifacts.length > 12)
             console.log(chalk.dim(`      ... ${artifacts.length - 12} more`));
     }
-    const proof = run.proof ?? [];
-    if (proof.length > 0) {
+    const checks = run.checks ?? [];
+    if (checks.length > 0) {
         console.log();
-        console.log(chalk.bold("    Proof"));
-        for (const check of proof.slice(0, 12)) {
+        console.log(chalk.bold("    Checks"));
+        for (const check of checks.slice(0, 12)) {
             const marker = check.ok ? chalk.green("pass") : chalk.red("fail");
             console.log(`      ${marker} ${check.label}${check.detail ? chalk.dim(` — ${check.detail}`) : ""}`);
         }
-        if (proof.length > 12)
-            console.log(chalk.dim(`      ... ${proof.length - 12} more`));
+        if (checks.length > 12)
+            console.log(chalk.dim(`      ... ${checks.length - 12} more`));
     }
     const events = run.trace?.events ?? [];
     if (events.length > 0) {
@@ -123,11 +123,19 @@ function renderRunStatus(run) {
 }
 export const runsCommand = {
     command: "runs <subcommand>",
-    describe: "Inspect runs on the connected instance",
+    describe: "Inspect durable 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) => {
+        .command("ls", "List Runs across the instance (optionally filter by Project or type)", (y) => y
+        .option("project", {
+        type: "string",
+        describe: "Filter by Project id",
+    })
+        .option("type", {
+        type: "string",
+        describe: "Filter by run type (build, verify, build-plan-draft, build-plan-improvement, benchmark-question-draft)",
+    }), async (args) => {
         const { url, token } = resolveConnection(args);
         const { status, body, raw } = await callJson(`${url}/v1/runs`, token);
         if (status !== 200) {
@@ -136,10 +144,21 @@ export const runsCommand = {
                 console.error(raw);
             process.exit(1);
         }
-        const runs = body?.runs ?? [];
-        const visibleRuns = args.prep
-            ? runs.filter((run) => run.preparation === args.prep)
-            : runs;
+        const parsed = RunObservabilityListResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red("Failed to parse runs response."));
+            process.exit(1);
+        }
+        const runs = parsed.data.runs;
+        const projectId = args.project;
+        const runType = args.type;
+        const visibleRuns = runs.filter((run) => {
+            if (projectId && run.project !== projectId)
+                return false;
+            if (runType && run.run_type !== runType)
+                return false;
+            return true;
+        });
         if (visibleRuns.length === 0) {
             console.log(chalk.dim("  No runs."));
             return;
@@ -147,8 +166,10 @@ export const runsCommand = {
         console.log();
         for (const run of visibleRuns) {
             console.log(`  ${chalk.bold(run.run_id)} ${chalk.dim(`(${run.status ?? "?"})`)}`);
-            if (run.preparation)
-                console.log(chalk.dim(`    prep: ${run.preparation}`));
+            if (run.run_type)
+                console.log(chalk.dim(`    type: ${run.run_type}`));
+            if (run.project)
+                console.log(chalk.dim(`    project: ${run.project}`));
             if (run.started_at)
                 console.log(chalk.dim(`    started: ${run.started_at}`));
         }
@@ -171,11 +192,16 @@ export const runsCommand = {
             console.log(raw);
             return;
         }
-        renderRunStatus(body);
+        const parsed = RunObservabilityResourceSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red(`Failed to parse run ${args.runId}.`));
+            process.exit(1);
+        }
+        renderRunStatus(parsed.data);
     })
         .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/build-runs/${encodeURIComponent(args.runId)}/cancel`, token, { method: "POST", body: JSON.stringify({}) });
+        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)

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

@@ -0,0 +1,24 @@
+import type { CommandModule } from "yargs";
+export interface RuntimeArgs {
+    host?: string;
+    port?: number;
+    appOwned?: boolean;
+    parentPid?: number;
+}
+export interface RuntimeStopArgs {
+    url?: string;
+    token?: string;
+}
+export interface RuntimeStatusArgs extends RuntimeStopArgs {
+    requireOwnerKind?: "desktop-app" | "headless";
+    requireOwnerPid?: number;
+}
+export interface RuntimeStartArgs extends RuntimeArgs {
+    timeoutMs?: number;
+    log?: string;
+}
+export declare function runRuntimeForeground(args: RuntimeArgs): Promise<void>;
+export declare function runRuntimeStart(args: RuntimeStartArgs): Promise<void>;
+export declare function runRuntimeStop(args: RuntimeStopArgs): Promise<void>;
+export declare function runRuntimeStatus(args: RuntimeStatusArgs): Promise<void>;
+export declare const runtimeCommand: CommandModule;