@fusionkit/cli 0.1.0 → 0.1.1

package/dist/fusion-init.js

@@ -0,0 +1,119 @@
+/**
+ * `fusionkit fusion init` — an interactive wizard that scaffolds a committed
+ * per-repo `fusionkit.json`. On a non-interactive stdin the prompts fall back to
+ * their defaults, so `fusion init` still produces a sensible config in CI.
+ */
+import { DEFAULT_CLOUD_PANEL, DEFAULT_TRIO, defaultKeyEnv } from "./fusion-quickstart.js";
+import { FUSION_CONFIG_VERSION, FusionConfigError, fusionConfigPath, writeFusionConfig } from "./fusion-config.js";
+import { parsePanelModelSpec } from "./shared/options.js";
+import { confirm, done, note, select, text } from "./ui/prompt.js";
+import { uiStream } from "./ui/runtime.js";
+import { bold, brandHeader, cyan, dim, red } from "./ui/theme.js";
+const out = uiStream();
+/** Ensure each cloud spec records the env var holding its key (self-documenting). */
+function withKeyEnv(spec) {
+    const provider = spec.provider ?? "mlx";
+    if (spec.keyEnv !== undefined || provider === "mlx")
+        return { ...spec };
+    const keyEnv = defaultKeyEnv(provider);
+    return keyEnv !== undefined ? { ...spec, keyEnv } : { ...spec };
+}
+async function buildCustomPanel() {
+    out.write(dim("Add panel models as ID=PROVIDER:MODEL (e.g. gpt=openai:gpt-5.5). Blank line to finish.\n"));
+    const specs = [];
+    for (let index = 0; index < 16; index++) {
+        const entry = await text({ message: `model ${index + 1}` });
+        if (entry.length === 0)
+            break;
+        try {
+            specs.push(withKeyEnv(parsePanelModelSpec(entry, {})));
+        }
+        catch (error) {
+            out.write(`${red("!")} ${error instanceof Error ? error.message : String(error)}\n`);
+            index--;
+        }
+    }
+    if (specs.length === 0) {
+        out.write(dim("No models entered; using the default cloud panel.\n"));
+        return DEFAULT_CLOUD_PANEL.map((spec) => withKeyEnv(spec));
+    }
+    return specs;
+}
+export async function runFusionInit(input) {
+    if (input.repoRoot === undefined) {
+        out.write(`${red("error:")} not inside a git repository.\n` +
+            "  cd into your project (or run from a repo) so fusionkit.json lands at the repo root.\n");
+        return 1;
+    }
+    out.write(`\n${brandHeader("let's set up model fusion for this repo")}\n\n`);
+    const tool = await select({
+        message: "Default coding agent",
+        options: [
+            { value: "codex", label: "codex", hint: "OpenAI Codex CLI" },
+            { value: "claude", label: "claude", hint: "Claude Code" },
+            { value: "cursor", label: "cursor", hint: "cursor-agent (needs a Cursorkit checkout)" },
+            { value: "serve", label: "serve", hint: "just run the gateway and print setup" }
+        ],
+        defaultIndex: 0
+    });
+    const preset = await select({
+        message: "Panel",
+        options: [
+            { value: "cloud", label: "cloud (default)", hint: DEFAULT_CLOUD_PANEL.map((s) => s.id).join(" + ") },
+            { value: "local", label: "local MLX trio", hint: "Apple Silicon, no API keys" },
+            { value: "custom", label: "custom", hint: "pick your own models" }
+        ],
+        defaultIndex: 0
+    });
+    let panel;
+    switch (preset) {
+        case "cloud":
+            panel = DEFAULT_CLOUD_PANEL.map((spec) => withKeyEnv(spec));
+            break;
+        case "local":
+            panel = DEFAULT_TRIO.map((spec) => ({ ...spec }));
+            break;
+        case "custom":
+            panel = await buildCustomPanel();
+            break;
+        default: {
+            const exhaustive = preset;
+            throw new Error(`unknown panel preset: ${String(exhaustive)}`);
+        }
+    }
+    const judgeDefault = panel[0]?.model ?? "";
+    const judgeModel = await text({ message: "Judge model (for synthesis)", defaultValue: judgeDefault });
+    let cursorKitDir;
+    if (tool === "cursor") {
+        const answer = await text({
+            message: "Cursorkit checkout dir (optional, can set FUSIONKIT_CURSORKIT_DIR later)"
+        });
+        if (answer.length > 0)
+            cursorKitDir = answer;
+    }
+    const observe = await confirm({ message: "Enable the observability dashboard by default?", defaultValue: false });
+    const config = {
+        version: FUSION_CONFIG_VERSION,
+        tool,
+        panel,
+        ...(judgeModel.length > 0 ? { judgeModel } : {}),
+        local: preset === "local",
+        observe,
+        ...(cursorKitDir !== undefined ? { cursorKitDir } : {})
+    };
+    let path;
+    try {
+        path = writeFusionConfig(input.repoRoot, config, { force: input.force === true });
+    }
+    catch (error) {
+        if (error instanceof FusionConfigError) {
+            out.write(`${red("error:")} ${error.message}\n`);
+            return 1;
+        }
+        throw error;
+    }
+    out.write("\n");
+    done(`wrote ${cyan(fusionConfigPath(input.repoRoot))}`);
+    note(`commit it, then just run: ${bold(`fusionkit ${tool === "serve" ? "serve" : tool}`)}`);
+    return 0;
+}

package/dist/fusion-quickstart.d.ts

@@ -92,6 +92,8 @@ export type Observability = {
  */
 export declare function startObservability(input: {
     log: (line: string) => void;
+    logFile?: string;
+    report?: StackReporter;
 }): Promise<Observability>;
 export type ModelServers = {
     endpoints: Record<string, string>;
@@ -100,6 +102,44 @@ export type ModelServers = {
     models: EnsembleModel[];
     close: () => Promise<void>;
 };
+/**
+ * Structured boot progress. When a reporter is supplied the stack emits these
+ * events instead of the plain `fusion: ...` log lines, so a live TUI (or any
+ * other consumer) can render per-stage status. Without one, callers keep getting
+ * the existing line logs.
+ */
+export type StackEvent = {
+    kind: "server.start";
+    id: string;
+    label: string;
+} | {
+    kind: "server.ready";
+    id: string;
+    detail: string;
+} | {
+    kind: "server.fail";
+    id: string;
+    detail: string;
+} | {
+    kind: "synth.start";
+} | {
+    kind: "synth.ready";
+    detail: string;
+} | {
+    kind: "gateway.start";
+} | {
+    kind: "gateway.ready";
+    detail: string;
+} | {
+    kind: "dashboard.start";
+} | {
+    kind: "dashboard.ready";
+    detail: string;
+} | {
+    kind: "dashboard.fail";
+    detail: string;
+};
+export type StackReporter = (event: StackEvent) => void;
 /**
  * Bring up one real model server per panel model and return an id -> base URL
  * map. `mlx` specs run locally; cloud specs are fronted by FusionKit. When
@@ -110,6 +150,8 @@ export declare function startModelServers(options: {
     specs: PanelModelSpec[];
     endpoints?: Record<string, string>;
     fusionkitDir?: string;
+    logsDir?: string;
+    report?: StackReporter;
     log: (line: string) => void;
 }): Promise<ModelServers>;
 export type FusionStack = {
@@ -130,6 +172,8 @@ export type StartFusionStackOptions = {
     port?: number;
     authToken?: string;
     timeoutMs?: number;
+    logsDir?: string;
+    report?: StackReporter;
     log: (line: string) => void;
 };
 /**
@@ -142,6 +186,7 @@ export declare function startSynthesisServer(input: {
     judgeModel: string;
     judgeBaseUrl: string;
     env: Record<string, string | undefined>;
+    logFile?: string;
     log: (line: string) => void;
 }): Promise<{
     url: string;
@@ -155,6 +200,7 @@ export declare function startFusionStack(options: StartFusionStackOptions): Prom
 export declare function startCursorBridge(input: {
     cursorKitDir: string;
     fusionUrl: string;
+    logFile?: string;
     log: (line: string) => void;
 }): Promise<{
     child: ChildProcess;
@@ -175,6 +221,8 @@ export type RunFusionOptions = {
     local?: boolean;
     /** Boot the local scope dashboard and stream trace events into it. */
     observe?: boolean;
+    /** Skip the interactive cost/scope confirmation for the cloud panel. */
+    yes?: boolean;
     log?: (line: string) => void;
 };
 export declare function runFusion(tool: FusionTool, toolArgs: string[], options?: RunFusionOptions): Promise<number>;