@interf/compiler 0.9.5 → 0.16.0

package/dist/cli/commands/agents.js

@@ -0,0 +1,213 @@
+/**
+ * `interf agents` — manage connected agents + role mapping.
+ *
+ *   interf agents ls                                # list registered + detected
+ *   interf agents use <name>                        # set active agent
+ *   interf agents register <name> --command <cmd> [--display-name <s>]
+ *   interf agents unregister <name>                 # custom CLIs only
+ *   interf agents map <role> <agent>                # pin a role to an agent
+ *   interf agents unmap <role>                      # clear a role
+ *
+ * All subcommands hit the connected local service. They never touch
+ * `~/.interf/agents.json` directly — the service is the source of truth.
+ */
+import chalk from "chalk";
+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.length > 0) {
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = null;
+        }
+    }
+    return { status: response.status, body, raw };
+}
+function formatAgentLine(agent, registry) {
+    const isActive = agent.name === registry.active_agent?.name;
+    const sourceLabel = agent.source === "builtin" ? "builtin" : "user";
+    const activeMarker = isActive ? chalk.green(" (active)") : "";
+    const availabilityMarker = agent.available === false ? chalk.yellow(" (not installed)") : "";
+    return `  ${chalk.bold(agent.name)} ${chalk.dim(`[${sourceLabel}]`)} ${chalk.dim(agent.display_name)} — ${chalk.dim(agent.command)}${activeMarker}${availabilityMarker}`;
+}
+function printRegistry(registry) {
+    if (registry.agents.length === 0) {
+        console.log();
+        console.log(chalk.yellow("  No agents available."));
+        console.log();
+        console.log("  Install Claude Code, Codex, Gemini, or another agent CLI,");
+        console.log("  or register a custom CLI: `interf agents register <name> --command <cmd>`.");
+        console.log();
+        return;
+    }
+    console.log();
+    console.log(chalk.bold("  Connected agents"));
+    for (const agent of registry.agents) {
+        console.log(formatAgentLine(agent, registry));
+    }
+    if (Object.keys(registry.role_map).length > 0) {
+        console.log();
+        console.log(chalk.bold("  Role mapping"));
+        for (const [role, agentName] of Object.entries(registry.role_map)) {
+            console.log(`  ${chalk.bold(role.padEnd(11))} → ${agentName}`);
+        }
+    }
+    console.log();
+}
+export const agentsCommand = {
+    command: "agents <subcommand>",
+    describe: "Manage connected agents and role mapping",
+    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 registered + detected agents", (y) => y, async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/agents`, token);
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to list agents (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        printRegistry(body);
+    })
+        .command("use <name>", "Set the active agent (mirrors to role_map.general + sweeps roles still on the prior active)", (y) => y.positional("name", {
+        type: "string",
+        demandOption: true,
+        describe: "Agent name (e.g. claude-code, codex, opencode)",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/executor`, token, {
+            method: "POST",
+            body: JSON.stringify({ agent: args.name }),
+        });
+        if (status !== 200 && status !== 202) {
+            console.error(chalk.red(`Failed to set active agent (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        const display = body?.executor?.display_name ?? args.name;
+        console.log(chalk.green(`  Active agent: ${chalk.bold(display)}.`));
+    })
+        .command("register <name>", "Register a custom agent CLI", (y) => y
+        .positional("name", {
+        type: "string",
+        demandOption: true,
+        describe: "Agent name (lowercase identifier, e.g. opencode)",
+    })
+        .option("command", {
+        type: "string",
+        demandOption: true,
+        describe: "Command to invoke (e.g. \"opencode --prompt\")",
+    })
+        .option("display-name", {
+        type: "string",
+        describe: "Human-readable name (defaults to the agent name)",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const displayName = args.displayName ?? args.name;
+        const { status, body, raw } = await callJson(`${url}/v1/agents`, token, {
+            method: "POST",
+            body: JSON.stringify({
+                name: args.name,
+                display_name: displayName,
+                command: args.command,
+            }),
+        });
+        if (status !== 201 || !body) {
+            console.error(chalk.red(`Failed to register agent (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`  Registered ${chalk.bold(args.name)} → ${args.command}.`));
+        printRegistry(body);
+    })
+        .command("unregister <name>", "Unregister a custom agent (built-ins cannot be unregistered)", (y) => y.positional("name", {
+        type: "string",
+        demandOption: true,
+        describe: "Agent name to remove",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const { status, body, raw } = await callJson(`${url}/v1/agents/${encodeURIComponent(args.name)}`, token, { method: "DELETE" });
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to unregister agent (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`  Unregistered ${chalk.bold(args.name)}.`));
+        printRegistry(body);
+    })
+        .command("map <role> <agent>", "Map a role to an agent", (y) => y
+        .positional("role", {
+        type: "string",
+        demandOption: true,
+        describe: "Role name (e.g. extractor, summarizer, verifier, general)",
+    })
+        .positional("agent", {
+        type: "string",
+        demandOption: true,
+        describe: "Agent name to bind to the role",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const patch = { [args.role]: args.agent };
+        const { status, body, raw } = await callJson(`${url}/v1/agents/role-map`, token, {
+            method: "PATCH",
+            body: JSON.stringify(patch),
+        });
+        if (status !== 200 || !body) {
+            console.error(chalk.red(`Failed to update role map (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`  Mapped ${chalk.bold(args.role)} → ${args.agent}.`));
+    })
+        .command("unmap <role>", "Clear a role mapping (falls back to active agent)", (y) => y.positional("role", {
+        type: "string",
+        demandOption: true,
+        describe: "Role name to clear",
+    }), async (args) => {
+        const { url, token } = resolveConnection(args);
+        const patch = { [args.role]: "" };
+        const { status, raw } = await callJson(`${url}/v1/agents/role-map`, token, {
+            method: "PATCH",
+            body: JSON.stringify(patch),
+        });
+        if (status !== 200) {
+            console.error(chalk.red(`Failed to clear role mapping (HTTP ${status}).`));
+            if (raw)
+                console.error(raw);
+            process.exit(1);
+        }
+        console.log(chalk.green(`  Cleared role ${chalk.bold(args.role)}.`));
+    })
+        .demandCommand(1)
+        .strict(),
+    handler: () => {
+        /* yargs subcommand handlers do the work */
+    },
+};

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

@@ -1,28 +1,11 @@
-import * as p from "@clack/prompts";
-import { detectInterf } from "../../packages/project-model/interf.js";
-import type { SourcePreparationConfig } from "../../packages/project-model/lib/schema.js";
 import type { CommandModule } from "yargs";
-import { choosePreparationConfig } from "./preparation-picker.js";
-export declare const compileCommand: CommandModule;
-interface CompileCommandDeps {
-    choosePreparationConfig: typeof choosePreparationConfig;
-    confirm: typeof p.confirm;
-    detectInterf: typeof detectInterf;
-    resolveInteractiveCompileLoopOverrides: typeof resolveInteractiveCompileLoopOverrides;
+interface CompileArgs {
+    prepId: string;
+    watch?: boolean;
+    quiet?: boolean;
+    idempotencyKey?: string;
+    url?: string;
+    token?: string;
 }
-export interface CompileCommandResult {
-    compiledPath: string;
-    testedDuringCompile: boolean;
-}
-export declare function runCompileCommand(argv?: Record<string, unknown>, deps?: Partial<CompileCommandDeps>): Promise<CompileCommandResult | null>;
-export declare function resolveInteractiveCompileLoopOverrides(options: {
-    compiledPath: string;
-    compiledConfig: SourcePreparationConfig | null;
-    maxAttemptsOverride: number | null;
-    maxLoopsOverride: number | null;
-}): Promise<{
-    compiledConfig: SourcePreparationConfig | null;
-    maxAttemptsOverride: number | null;
-    maxLoopsOverride: number | null;
-} | null>;
+export declare const compileCommand: CommandModule<unknown, CompileArgs>;
 export {};