@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/mcp.js

@@ -0,0 +1,239 @@
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection, } from "../../packages/engine/connection-config.js";
+import { LOCAL_SERVICE_ROUTES, preparationResourcePath, preparationSubresourcePath, runResourcePath, runSubresourcePath, } from "../../packages/engine/routes.js";
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function resolveConnection(args) {
+    const conn = readActiveConnection({
+        urlOverride: args.url ?? null,
+        authTokenOverride: args.token ?? null,
+    });
+    if (!conn) {
+        process.stderr.write(`${CONNECT_OR_ERROR_HINT}\n`);
+        process.exit(1);
+    }
+    return {
+        url: trimTrailingSlash(conn.url),
+        token: conn.auth_token ?? null,
+    };
+}
+async function callApi(conn, path, init = {}) {
+    const headers = new Headers(init.headers ?? {});
+    if (conn.token)
+        headers.set("authorization", `Bearer ${conn.token}`);
+    if (init.body && !headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+    }
+    const response = await fetch(`${conn.url}${path}`, { ...init, headers });
+    const raw = await response.text();
+    let body = null;
+    if (raw.length > 0) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = raw;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+function toolResultJson(payload) {
+    const text = typeof payload === "string"
+        ? payload
+        : JSON.stringify(payload, null, 2);
+    return {
+        content: [{ type: "text", text }],
+    };
+}
+function toolErrorJson(message, payload) {
+    const text = payload !== undefined
+        ? `${message}\n${typeof payload === "string" ? payload : JSON.stringify(payload, null, 2)}`
+        : message;
+    return {
+        content: [{ type: "text", text }],
+        isError: true,
+    };
+}
+async function callAndReturn(conn, path, init = {}) {
+    const response = await callApi(conn, path, init);
+    if (response.status >= 200 && response.status < 300) {
+        return toolResultJson(response.body ?? response.raw);
+    }
+    return toolErrorJson(`Local service responded with HTTP ${response.status}.`, response.body ?? response.raw);
+}
+function registerTools(server, conn) {
+    // ── Preparations ────────────────────────────────────────────────────────
+    server.registerTool("prep_list", {
+        title: "List preparations",
+        description: "List every Preparation registered on the connected Interf instance, "
+            + "with source binding, Method id, and current readiness.",
+        inputSchema: {},
+    }, async () => callAndReturn(conn, LOCAL_SERVICE_ROUTES.preparations));
+    server.registerTool("prep_create", {
+        title: "Create a preparation",
+        description: "Create a new Preparation. The Preparation binds a Source Folder "
+            + "to an optional Method and is the saved unit of work for compile runs.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id (kebab-case)."),
+            source_path: z.string().min(1).describe("Absolute or workspace-relative Source Folder path."),
+            method_id: z.string().min(1).optional().describe("Optional Method id to bind. Bind later with prep_set_method if omitted."),
+            about: z.string().min(1).optional().describe("Optional human-readable description."),
+        },
+    }, async (args) => callAndReturn(conn, LOCAL_SERVICE_ROUTES.preparations, {
+        method: "POST",
+        body: JSON.stringify({
+            id: args.id,
+            source: { kind: "local-folder", locator: args.source_path },
+            ...(args.method_id ? { method_id: args.method_id } : {}),
+            ...(args.about ? { about: args.about } : {}),
+        }),
+    }));
+    server.registerTool("prep_show", {
+        title: "Show one preparation",
+        description: "Return the full resource for one Preparation by id.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationResourcePath(args.id)));
+    server.registerTool("prep_set_method", {
+        title: "Bind a Method to a preparation",
+        description: "Update the Method binding on a Preparation. Use this to swap "
+            + "Methods between compile runs without rebuilding the Preparation.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id."),
+            method_id: z.string().min(1).describe("Method id to bind."),
+        },
+    }, async (args) => callAndReturn(conn, preparationResourcePath(args.id), {
+        method: "PATCH",
+        body: JSON.stringify({ method_id: args.method_id }),
+    }));
+    server.registerTool("prep_remove", {
+        title: "Remove a preparation",
+        description: "Delete a Preparation. Portable context is removed too.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationResourcePath(args.id), {
+        method: "DELETE",
+    }));
+    // ── Compile + verify runs ──────────────────────────────────────────────
+    server.registerTool("prep_compile", {
+        title: "Start a compile run",
+        description: "Kick off a compile run for a Preparation. Returns the new run "
+            + "resource immediately; use runs_status to poll progress and "
+            + "runs_fetch when the run finishes.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationSubresourcePath(args.id, "compileRuns"), { method: "POST", body: "{}" }));
+    server.registerTool("prep_verify", {
+        title: "Run readiness checks",
+        description: "Run the Preparation's readiness checks against the latest portable "
+            + "context. Verify runs always judge against the compiled output in 0.15+.",
+        inputSchema: {
+            id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationSubresourcePath(args.id, "verifyRuns"), {
+        method: "POST",
+        body: JSON.stringify({}),
+    }));
+    // ── Methods ─────────────────────────────────────────────────────────────
+    server.registerTool("method_list", {
+        title: "List Methods",
+        description: "List every Method visible to the connected instance: workspace "
+            + "drafts, the user library at ~/.interf/methods/, and bundled Methods.",
+        inputSchema: {},
+    }, async () => callAndReturn(conn, LOCAL_SERVICE_ROUTES.methods));
+    server.registerTool("method_draft", {
+        title: "Author a new Method draft",
+        description: "Run the Method-authoring agent for a Preparation. Produces a new "
+            + "Method package draft under <workspace>/methods/<id>/.",
+        inputSchema: {
+            prep_id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationSubresourcePath(args.prep_id, "methodAuthoringRuns"), { method: "POST", body: "{}" }));
+    server.registerTool("method_improve", {
+        title: "Run Method improvement",
+        description: "Run the Method-improvement agent for a Preparation. Iterates on "
+            + "the bound Method based on the latest readiness-check results.",
+        inputSchema: {
+            prep_id: z.string().min(1).describe("Preparation id."),
+        },
+    }, async (args) => callAndReturn(conn, preparationSubresourcePath(args.prep_id, "methodImprovementRuns"), { method: "POST", body: "{}" }));
+    // ── Runs ────────────────────────────────────────────────────────────────
+    server.registerTool("runs_status", {
+        title: "Get run status",
+        description: "Return the run record for one observable run.",
+        inputSchema: {
+            run_id: z.string().min(1).describe("Run id."),
+        },
+    }, async (args) => callAndReturn(conn, runResourcePath(args.run_id)));
+    server.registerTool("runs_watch", {
+        title: "Read run events",
+        description: "Read the events log for one run as a snapshot. Returns the same "
+            + "stream the UI consumes via SSE; agents that need live progress "
+            + "should poll runs_status until the run reaches a terminal state.",
+        inputSchema: {
+            run_id: z.string().min(1).describe("Run id."),
+        },
+    }, async (args) => callAndReturn(conn, runSubresourcePath(args.run_id, "events")));
+    server.registerTool("runs_cancel", {
+        title: "Cancel a run",
+        description: "Request cancellation of an in-flight run.",
+        inputSchema: {
+            run_id: z.string().min(1).describe("Run id."),
+        },
+    }, async (args) => callAndReturn(conn, runSubresourcePath(args.run_id, "cancel"), { method: "POST", body: "{}" }));
+    server.registerTool("runs_fetch", {
+        title: "Fetch run artifacts",
+        description: "Return the artifact manifest for a finished run (portable context, "
+            + "proof records, logs, run-scoped audit trail).",
+        inputSchema: {
+            run_id: z.string().min(1).describe("Run id."),
+        },
+    }, async (args) => callAndReturn(conn, runSubresourcePath(args.run_id, "artifacts")));
+    // ── Instance ────────────────────────────────────────────────────────────
+    server.registerTool("instance_status", {
+        title: "Show instance status",
+        description: "Return the engine's instance resource: started_at, package "
+            + "version, registered preparations, active runs, idle seconds.",
+        inputSchema: {},
+    }, async () => callAndReturn(conn, LOCAL_SERVICE_ROUTES.instance));
+}
+async function startStdioServer(args) {
+    const conn = resolveConnection(args);
+    const server = new McpServer({ name: "interf", version: "0.14.0" }, { capabilities: { tools: {} } });
+    registerTools(server, conn);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export const mcpCommand = {
+    command: "mcp",
+    describe: "Run the Interf Model Context Protocol server (stdio by default).",
+    builder: (yargs) => yargs
+        .option("transport", {
+        type: "string",
+        choices: ["stdio", "http"],
+        default: "stdio",
+        describe: "Transport for the MCP server.",
+    })
+        .option("url", {
+        type: "string",
+        describe: "Override the active connection URL.",
+    })
+        .option("token", {
+        type: "string",
+        describe: "Override the active bearer token.",
+    }),
+    handler: async (args) => {
+        if (args.transport && args.transport !== "stdio") {
+            process.stderr.write("interf mcp: only the stdio transport is implemented today. "
+                + "Open an issue if you need --transport=http.\n");
+            process.exit(2);
+        }
+        await startStdioServer(args);
+    },
+};

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

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

package/dist/cli/commands/method.js

@@ -0,0 +1,113 @@
+/**
+ * `interf method` — manage methods on the connected instance.
+ *
+ *   interf method ls                          # list methods (instance-wide)
+ *   interf method install <path>              # install a method package
+ *   interf method draft <prep-id>             # start a method-authoring run
+ *   interf method improve <prep-id>           # start a method-improvement run
+ */
+import chalk from "chalk";
+import { 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 methodCommand = {
+    command: "method <subcommand>",
+    describe: "Manage methods 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 methods on the instance", (y) => y, async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/methods`, token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to list methods (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const methods = body?.methods ?? [];
+        if (methods.length === 0) {
+            console.log(chalk.dim("  No methods on this instance."));
+            return;
+        }
+        console.log();
+        for (const m of methods) {
+            const id = m.method_id ?? m.id ?? "(?)";
+            const label = m.label ? ` ${chalk.dim(m.label)}` : "";
+            const kind = m.source_kind ? chalk.dim(`[${m.source_kind}]`) : "";
+            console.log(`  ${chalk.bold(id)} ${kind}${label}`);
+            if (m.active_for_preparations?.length) {
+                console.log(chalk.dim(`    used by: ${m.active_for_preparations.join(", ")}`));
+            }
+        }
+        console.log();
+    })
+        .command("install <path>", "Install a method package from a local folder", (y) => y.positional("path", { type: "string", demandOption: true, describe: "Path to the method package" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const absolute = resolve(process.cwd(), args.path);
+        const { status, raw } = await callJson(`${url}/v1/methods`, token, { method: "POST", body: JSON.stringify({ source_path: absolute }) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to install method (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Installed method from ${absolute}.`));
+    })
+        .command("draft <prep-id>", "Start a method-authoring run for a preparation", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/method-authoring-runs`, token, { method: "POST", body: JSON.stringify({}) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to start method-authoring run (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Method-authoring run ${chalk.bold(body?.run_id ?? "(?)")} started.`));
+    })
+        .command("improve <prep-id>", "Start a method-improvement run for a preparation", (y) => y.positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/preparations/${encodeURIComponent(args.prepId)}/method-improvement-runs`, token, { method: "POST", body: JSON.stringify({}) });
+        if (status !== 201 && status !== 200) {
+            console.error(chalk.red(`Failed to start method-improvement run (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Method-improvement run ${chalk.bold(body?.run_id ?? "(?)")} started.`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

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

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

package/dist/cli/commands/prep.js

@@ -0,0 +1,152 @@
+/**
+ * `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/engine/connection-config.js";
+import { preparationResourcePath } from "../../packages/engine/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 (method binding optional — set later if you don't have one yet)", (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", describe: "Method id (e.g. interf-default). Optional — bind later via `interf prep set-method`." })
+        .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 },
+            ...(args.method ? { 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 (!args.method) {
+            console.log(chalk.dim(`  no method bound yet — pick or draft one before compiling:`));
+            console.log(chalk.dim(`    interf prep set-method ${args.prepId} <method-id>`));
+            console.log(chalk.dim(`    interf method draft ${args.prepId}`));
+        }
+        if (body?.portable_context?.value) {
+            console.log(chalk.dim(`  portable context (locator): ${body.portable_context.value}`));
+        }
+    })
+        .command("set-method <prep-id> <method-id>", "Bind a method to a preparation (or change which method it uses)", (y) => y
+        .positional("prep-id", { type: "string", demandOption: true, describe: "Preparation id" })
+        .positional("method-id", { type: "string", demandOption: true, describe: "Method id to bind" }), async (args) => {
+        const { url, token } = requireConnection(args);
+        const { status, raw } = await callJson(`${url}${preparationResourcePath(args.prepId)}`, token, { method: "PATCH", body: JSON.stringify({ method_id: args.methodId }) });
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to set method (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`Bound ${chalk.bold(args.methodId)} to ${chalk.bold(args.prepId)}.`));
+    })
+        .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/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();
+    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;