@interf/compiler 0.22.2 → 0.50.0

package/dist/cli/commands/graphs.js

@@ -0,0 +1,344 @@
+/**
+ * `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>
+ *   interf graphs sessions --project <id>
+ *   interf graphs session <stageRunId> --project <id>
+ */
+import chalk from "chalk";
+import { callJson, resolveConnection } from "../lib/http-client.js";
+import { ContextGraphListResponseSchema, ContextGraphResourceSchema, ContextGraphSessionResponseSchema, ContextGraphSessionsResponseSchema, } from "../../packages/runtime/schemas/index.js";
+function graphUrl(baseUrl, projectId, graphId) {
+    const root = `${baseUrl}/v1/projects/${encodeURIComponent(projectId)}/graphs`;
+    return graphId ? `${root}/${encodeURIComponent(graphId)}` : root;
+}
+function sessionsUrl(baseUrl, projectId, stageRunId) {
+    const root = `${baseUrl}/v1/projects/${encodeURIComponent(projectId)}/context-graph/sessions`;
+    return stageRunId ? `${root}/${encodeURIComponent(stageRunId)}` : 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 formatMetric(metric) {
+    const count = typeof metric.total === "number"
+        ? `${metric.value} / ${metric.total}`
+        : `${metric.value}`;
+    const unit = metric.unit ? ` ${metric.unit}` : "";
+    return metric.detail ? `${count}${unit} (${metric.detail})` : `${count}${unit}`;
+}
+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}`));
+    for (const metric of graph.primary_metrics.slice(0, 5)) {
+        console.log(chalk.dim(`    ${metric.label}: ${formatMetric(metric)}`));
+    }
+    if (graph.graph_manifest?.graph_outputs) {
+        const outputs = graph.graph_manifest.graph_outputs;
+        console.log(chalk.dim(`    graph: ${outputs.nodes} nodes, ${outputs.edges} edges`));
+    }
+    if (graph.build_evidence?.summary)
+        console.log(chalk.dim(`    evidence: ${graph.build_evidence.summary}`));
+    console.log();
+}
+function sessionStatusColor(status) {
+    if (status === "succeeded")
+        return chalk.green;
+    if (status === "failed")
+        return chalk.red;
+    return chalk.yellow;
+}
+function renderSessionLine(session) {
+    const color = sessionStatusColor(session.status);
+    console.log(`  ${chalk.bold(session.stage_run_id)} ${color(`(${session.status})`)}`);
+    console.log(chalk.dim(`    stage: ${session.stage_label} [${session.stage_id}] · attempt ${session.attempt} · ${session.contract_type}`));
+    const model = session.executor.model ? ` (${session.executor.model})` : "";
+    console.log(chalk.dim(`    executor: ${session.executor.display_name || session.executor.name}${model}`));
+    const replay = session.shell.replay_ready
+        ? chalk.green("replay-ready")
+        : chalk.dim(session.shell.retention_reason ? `pruned: ${session.shell.retention_reason}` : "no replay shell");
+    console.log(chalk.dim(`    shell: ${replay}`));
+}
+function renderSession(session) {
+    const color = sessionStatusColor(session.status);
+    console.log();
+    console.log(`  ${chalk.bold(session.stage_run_id)} ${color(`(${session.status})`)}`);
+    console.log(chalk.dim(`    stage: ${session.stage_label} [${session.stage_id}]`));
+    console.log(chalk.dim(`    attempt: ${session.attempt}`));
+    console.log(chalk.dim(`    contract: ${session.contract_type}`));
+    console.log(chalk.dim(`    project: ${session.project}`));
+    if (session.build_run_id)
+        console.log(chalk.dim(`    build run: ${session.build_run_id}`));
+    console.log(chalk.dim(`    Build Plan: ${session.build_plan}`));
+    const model = session.executor.model ? ` (${session.executor.model})` : "";
+    console.log(chalk.dim(`    executor: ${session.executor.display_name || session.executor.name}${model}`));
+    console.log(chalk.dim(`    updated: ${session.updated_at}`));
+    console.log();
+    console.log(chalk.bold("    Shell"));
+    console.log(chalk.dim(`      root: ${session.shell.root_path}`));
+    console.log(`      replay: ${session.shell.replay_ready ? chalk.green("ready") : chalk.yellow("not ready")}`
+        + (session.shell.retention_reason ? chalk.dim(` (${session.shell.retention_reason})`) : ""));
+    const logPaths = Object.entries(session.logs).filter(([, value]) => Boolean(value));
+    if (logPaths.length > 0) {
+        console.log();
+        console.log(chalk.bold("    Logs"));
+        for (const [label, value] of logPaths) {
+            console.log(chalk.dim(`      ${label.replace(/_path$/, "")}: ${value}`));
+        }
+    }
+    const reads = session.artifacts.reads;
+    const writes = session.artifacts.writes;
+    if (reads.length > 0 || writes.length > 0) {
+        console.log();
+        console.log(chalk.bold("    Artifacts"));
+        for (const mount of reads)
+            console.log(chalk.dim(`      read  ${mount.artifact_id}: ${mount.artifact_path}`));
+        for (const mount of writes)
+            console.log(chalk.dim(`      write ${mount.artifact_id}: ${mount.artifact_path}`));
+    }
+    if (session.validation_attempts.length > 0) {
+        console.log();
+        console.log(chalk.bold("    Validation"));
+        for (const attempt of session.validation_attempts) {
+            const marker = attempt.status === "succeeded" ? chalk.green("pass") : chalk.red("fail");
+            console.log(`      ${marker} attempt ${attempt.attempt}: ${chalk.dim(attempt.summary)}`);
+        }
+    }
+    if (session.summary) {
+        console.log();
+        console.log(chalk.bold("    Summary"));
+        console.log(chalk.dim(`      ${session.summary}`));
+    }
+    if (session.error) {
+        console.log();
+        console.log(chalk.red("    Error"));
+        console.log(chalk.dim(`      ${session.error}`));
+    }
+    console.log();
+    console.log(chalk.dim("  Run with --json for the full session record (all runtime-file paths)."));
+    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}`));
+            const metric = graph.primary_metrics[0];
+            if (metric)
+                console.log(chalk.dim(`    ${metric.label}: ${formatMetric(metric)}`));
+        }
+        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}`));
+    })
+        .command("sessions", "List stage execution sessions for the latest Context Graph", (y) => y
+        .option("project", {
+        type: "string",
+        demandOption: true,
+        describe: "Project id",
+    })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        describe: "Print the raw JSON session records",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(sessionsUrl(url, args.project), token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to list execution sessions (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const parsed = ContextGraphSessionsResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red("Failed to parse execution sessions."));
+            process.exit(1);
+        }
+        if (args.json) {
+            console.log(JSON.stringify(parsed.data.sessions, null, 2));
+            return;
+        }
+        const sessions = parsed.data.sessions;
+        if (sessions.length === 0) {
+            console.log(chalk.dim("  No stage execution sessions for the latest Build run."));
+            return;
+        }
+        console.log();
+        for (const session of sessions)
+            renderSessionLine(session);
+        console.log();
+        console.log(chalk.dim("  interf graphs session <stage-run-id> --project <id> for one session."));
+        console.log();
+    })
+        .command("session <stageRunId>", "Show one stage execution session", (y) => y
+        .positional("stageRunId", {
+        type: "string",
+        demandOption: true,
+        describe: "Stage execution session id (stage_run_id)",
+    })
+        .option("project", {
+        type: "string",
+        demandOption: true,
+        describe: "Project id",
+    })
+        .option("json", {
+        type: "boolean",
+        default: false,
+        describe: "Print the raw JSON session record",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(sessionsUrl(url, args.project, args.stageRunId), token);
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to read execution session ${args.stageRunId} (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const parsed = ContextGraphSessionResponseSchema.safeParse(body);
+        if (!parsed.success) {
+            console.error(chalk.red(`Failed to parse execution session ${args.stageRunId}.`));
+            process.exit(1);
+        }
+        if (args.json) {
+            console.log(JSON.stringify(parsed.data.session, null, 2));
+            return;
+        }
+        renderSession(parsed.data.session);
+    })
+        .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,10 @@
 import type { CommandModule } from "yargs";
-interface McpArgs {
+export interface McpArgs {
     transport?: "stdio" | "http";
+    profile?: "headless" | "app";
     url?: string;
     token?: string;
 }
+export declare function generatedMcpId(prefix: string): string;
+export declare function startInterfMcpServer(args: McpArgs): Promise<void>;
 export declare const mcpCommand: CommandModule<unknown, McpArgs>;
-export {};