@interf/compiler 0.22.0 → 0.33.0

package/dist/cli/commands/graphs.js

@@ -0,0 +1,199 @@
+/**
+ * `interf graphs` — inspect Context Graphs on the connected instance.
+ *
+ *   interf graphs ls --project <id>
+ *   interf graphs show <graphId> --project <id>
+ *   interf graphs open <graphId> --project <id>
+ */
+import chalk from "chalk";
+import { CONNECT_OR_ERROR_HINT, readActiveConnection } from "../../packages/runtime/connection-config.js";
+import { ContextGraphListResponseSchema, ContextGraphResourceSchema, } from "../../packages/runtime/schemas/index.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 };
+}
+function graphUrl(baseUrl, projectId, graphId) {
+    const root = `${baseUrl}/v1/projects/${encodeURIComponent(projectId)}/graphs`;
+    return graphId ? `${root}/${encodeURIComponent(graphId)}` : root;
+}
+function statusColor(graph) {
+    const status = graph.readiness?.status;
+    if (graph.readiness?.ready || status === "ready")
+        return chalk.green;
+    if (status === "failed" || status === "not-ready")
+        return chalk.red;
+    return chalk.yellow;
+}
+function renderGraph(graph) {
+    const color = statusColor(graph);
+    const graphId = graph.graph_id ?? graph.latest_build_run_id ?? `${graph.project}-latest`;
+    const status = graph.readiness?.status ?? "unknown";
+    console.log();
+    console.log(`  ${chalk.bold(graphId)} ${color(`(${status})`)}`);
+    console.log(chalk.dim(`    project: ${graph.project_id ?? graph.project}`));
+    if (graph.build_run_id ?? graph.latest_build_run_id) {
+        console.log(chalk.dim(`    run: ${graph.build_run_id ?? graph.latest_build_run_id}`));
+    }
+    if (graph.build_plan)
+        console.log(chalk.dim(`    Build Plan: ${graph.build_plan}`));
+    if (graph.created_at)
+        console.log(chalk.dim(`    created: ${graph.created_at}`));
+    console.log(chalk.dim(`    path: ${graph.path}`));
+    if (graph.build_evidence?.summary)
+        console.log(chalk.dim(`    evidence: ${graph.build_evidence.summary}`));
+    console.log();
+}
+export const graphsCommand = {
+    command: "graphs <subcommand>",
+    describe: "Inspect Context Graphs produced for a Project",
+    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 Context Graphs for a Project", (y) => y.option("project", {
+        type: "string",
+        demandOption: true,
+        describe: "Project id",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(graphUrl(url, args.project), token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to list Context Graphs (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const parsed = ContextGraphListResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red("Failed to parse Context Graph list."));
+            process.exit(1);
+        }
+        const graphs = parsed.data.graphs;
+        if (graphs.length === 0) {
+            console.log(chalk.dim("  No Context Graphs."));
+            return;
+        }
+        console.log();
+        for (const graph of graphs) {
+            const marker = graph.is_latest ? " latest" : "";
+            const statusLabel = graph.readiness?.status ?? "unknown";
+            const graphId = graph.graph_id ?? graph.latest_build_run_id ?? `${graph.project}-latest`;
+            console.log(`  ${chalk.bold(graphId)} ${chalk.dim(`(${statusLabel}${marker})`)}`);
+            console.log(chalk.dim(`    path: ${graph.path}`));
+        }
+        console.log();
+    })
+        .command("show <graphId>", "Show one Context Graph", (y) => y
+        .positional("graphId", {
+        type: "string",
+        demandOption: true,
+        describe: "Context Graph id, or latest",
+    })
+        .option("project", {
+        type: "string",
+        demandOption: true,
+        describe: "Project id",
+    })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        describe: "Print the raw JSON record",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const resource = await readGraph(url, token, args.project, args.graphId);
+        if (args.json) {
+            console.log(JSON.stringify(resource, null, 2));
+            return;
+        }
+        renderGraph(resource);
+    })
+        .command("open <graphId>", "Open a Context Graph folder", (y) => y
+        .positional("graphId", {
+        type: "string",
+        demandOption: true,
+        describe: "Context Graph id, or latest",
+    })
+        .option("project", {
+        type: "string",
+        demandOption: true,
+        describe: "Project id",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const resource = await readGraph(url, token, args.project, args.graphId);
+        const { status, raw } = await callJson(`${url}/v1/open-path`, token, {
+            method: "POST",
+            body: JSON.stringify({ path: resource.path }),
+        });
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to open Context Graph (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.dim(`  Opened ${resource.path}`));
+    })
+        .demandCommand(1, "Choose a graphs subcommand."),
+    handler: () => {
+        // Subcommands own all behavior.
+    },
+};
+async function readGraph(url, token, projectId, graphId) {
+    if (graphId === "latest") {
+        const { status, body, raw } = await callJson(graphUrl(url, projectId), token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read latest Context Graph (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const parsed = ContextGraphListResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red("Failed to parse Context Graph list."));
+            process.exit(1);
+        }
+        const latest = parsed.data.graphs.find((graph) => graph.is_latest) ?? parsed.data.graphs[0] ?? null;
+        if (!latest) {
+            console.error(chalk.red(`Project ${projectId} has no Context Graph.`));
+            process.exit(1);
+        }
+        return latest;
+    }
+    const { status, body, raw } = await callJson(graphUrl(url, projectId, graphId), token);
+    if (status !== 200 || !body) {
+        console.error(chalk.red(`Failed to read Context Graph ${graphId} (HTTP ${status}).`));
+        if (raw)
+            console.error(raw);
+        process.exit(1);
+    }
+    const parsed = ContextGraphResourceSchema.safeParse(body);
+    if (!parsed.success) {
+        console.error(chalk.red(`Failed to parse Context Graph ${graphId}.`));
+        process.exit(1);
+    }
+    return parsed.data;
+}

package/dist/cli/commands/login.js

@@ -4,13 +4,11 @@
  *   interf login --url <url> [--token <token>]
  *
  * Writes `~/.interf/connection.json` so subsequent CLI commands target the
- * remote (or alternate local) URL. There is no remote backend in 0.13 — this
- * is the on-disk config layer that the cloud product will consume. Equivalent
- * to running `interf web` (which writes a local connection record on
- * startup).
+ * remote (or alternate local) URL. Equivalent to running `interf runtime`,
+ * which writes a local connection record on startup.
  */
 import chalk from "chalk";
-import { ConnectionRecordSchema, writeConnection, } from "../../packages/engine/connection-config.js";
+import { ConnectionRecordSchema, writeConnection, } from "../../packages/runtime/connection-config.js";
 export const loginCommand = {
     command: "login",
     describe: "Set the active Interf instance connection (URL + optional bearer token)",
@@ -18,7 +16,7 @@ export const loginCommand = {
         .option("url", {
         type: "string",
         demandOption: true,
-        describe: "Engine URL, e.g. https://api.interf.cloud or http://127.0.0.1:4873",
+        describe: "Service URL, e.g. https://api.interf.cloud or http://127.0.0.1:4873",
     })
         .option("token", {
         type: "string",

package/dist/cli/commands/logout.js

@@ -5,7 +5,7 @@
  * non-zero with the connect-or-error hint until a new connection is set.
  */
 import chalk from "chalk";
-import { clearConnection } from "../../packages/engine/connection-config.js";
+import { clearConnection } from "../../packages/runtime/connection-config.js";
 export const logoutCommand = {
     command: "logout",
     describe: "Clear the active Interf instance connection",

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

@@ -1,8 +1,9 @@
 import type { CommandModule } from "yargs";
-interface McpArgs {
+export interface McpArgs {
     transport?: "stdio" | "http";
+    profile?: "headless" | "app";
     url?: string;
     token?: string;
 }
+export declare function startInterfMcpServer(args: McpArgs): Promise<void>;
 export declare const mcpCommand: CommandModule<unknown, McpArgs>;
-export {};