@bpmnkit/proxy 0.0.8

package/dist/adapters/claude.js

@@ -0,0 +1,108 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+export const supportsMcp = true;
+export async function available() {
+    return new Promise((resolve) => {
+        const proc = spawn("claude", ["--version"], { stdio: "ignore" });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+export async function stream(messages, systemPrompt, mcpConfigFile, onToken) {
+    // Build conversation as a single prompt string
+    const parts = [systemPrompt, ""];
+    for (const msg of messages) {
+        parts.push(`${msg.role === "user" ? "Human" : "Assistant"}: ${msg.content}`);
+    }
+    parts.push("Assistant:");
+    const fullPrompt = parts.join("\n");
+    const MCP_TOOLS = [
+        "mcp__bpmn__get_diagram",
+        "mcp__bpmn__compose_diagram",
+        "mcp__bpmn__add_elements",
+        "mcp__bpmn__remove_elements",
+        "mcp__bpmn__update_element",
+        "mcp__bpmn__set_condition",
+        "mcp__bpmn__add_http_call",
+        "mcp__bpmn__replace_diagram",
+    ];
+    const args = [
+        "-p",
+        fullPrompt,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--dangerously-skip-permissions",
+        "--permission-mode",
+        "bypassPermissions",
+    ];
+    // Write a project-level .claude/settings.json that pre-approves all bpmn tools,
+    // then spawn claude with cwd pointing there so it reads the settings.
+    let spawnCwd;
+    if (mcpConfigFile) {
+        const tmpDir = dirname(mcpConfigFile);
+        spawnCwd = tmpDir;
+        const claudeDir = join(tmpDir, ".claude");
+        mkdirSync(claudeDir, { recursive: true });
+        writeFileSync(join(claudeDir, "settings.json"), JSON.stringify({ permissions: { allow: MCP_TOOLS } }));
+        args.push("--mcp-config", mcpConfigFile);
+        args.push("--allowedTools", MCP_TOOLS.join(","));
+        args.push("--strict-mcp-config");
+    }
+    // Strip CLAUDECODE so the nested-session guard in the CLI doesn't block us.
+    const spawnEnv = { ...process.env };
+    spawnEnv.CLAUDECODE = undefined;
+    console.log(`[claude] spawning with MCP: ${mcpConfigFile !== null}`);
+    await new Promise((resolve, reject) => {
+        const proc = spawn("claude", args, {
+            cwd: spawnCwd,
+            env: spawnEnv,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let buf = "";
+        let stderrBuf = "";
+        proc.stdout?.on("data", (chunk) => {
+            buf += chunk.toString();
+            const lines = buf.split("\n");
+            buf = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const event = JSON.parse(line);
+                    if (event.type === "assistant" && event.message?.content) {
+                        for (const block of event.message.content) {
+                            if (block.type === "text" && block.text) {
+                                onToken(block.text);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    /* non-JSON line, skip */
+                }
+            }
+        });
+        proc.stderr?.on("data", (chunk) => {
+            const text = chunk.toString();
+            stderrBuf += text;
+            process.stderr.write(`[claude stderr] ${text}`);
+        });
+        proc.on("error", (err) => {
+            console.error(`[claude] spawn error: ${String(err)}`);
+            reject(err);
+        });
+        proc.on("close", (code) => {
+            console.log(`[claude] exited with code ${code}`);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                const detail = stderrBuf.trim() ? `: ${stderrBuf.trim()}` : "";
+                reject(new Error(`claude exited with code ${code}${detail}`));
+            }
+        });
+    });
+}
+//# sourceMappingURL=claude.js.map

package/dist/adapters/copilot.js

@@ -0,0 +1,46 @@
+/**
+ * Adapter for the new GitHub Copilot CLI (`copilot` / `@github/copilot`, GA Feb 2026).
+ * Note: the old `gh copilot` extension was deprecated Oct 2025 and is no longer supported.
+ */
+import { spawn } from "node:child_process";
+export const supportsMcp = true;
+export async function available() {
+    return new Promise((resolve) => {
+        const proc = spawn("copilot", ["--version"], { stdio: "ignore" });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+export async function stream(messages, systemPrompt, mcpConfigFile, onToken) {
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    const prompt = `${systemPrompt}\n\nUser: ${lastUser?.content ?? "help"}`;
+    const args = ["-p", prompt, "--yolo"];
+    if (mcpConfigFile) {
+        args.push("--additional-mcp-config", mcpConfigFile);
+        args.push("--allow-all-tools");
+    }
+    console.log(`[copilot] spawning with MCP: ${mcpConfigFile !== null}`);
+    await new Promise((resolve, reject) => {
+        const proc = spawn("copilot", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.stdout?.on("data", (chunk) => {
+            onToken(chunk.toString());
+        });
+        proc.stderr?.on("data", (chunk) => {
+            process.stderr.write(`[copilot stderr] ${chunk.toString()}`);
+        });
+        proc.on("error", (err) => {
+            console.error(`[copilot] spawn error: ${String(err)}`);
+            reject(err);
+        });
+        proc.on("close", (code) => {
+            console.log(`[copilot] exited with code ${code}`);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`copilot exited with code ${code}`));
+        });
+    });
+}
+//# sourceMappingURL=copilot.js.map

package/dist/adapters/gemini.js

@@ -0,0 +1,43 @@
+/**
+ * Adapter for Google Gemini CLI.
+ * MCP is not supported per-invocation (requires global settings.json),
+ * so this adapter falls back to the system-prompt approach.
+ */
+import { spawn } from "node:child_process";
+export const supportsMcp = false;
+export async function available() {
+    return new Promise((resolve) => {
+        const proc = spawn("gemini", ["--version"], { stdio: "ignore" });
+        proc.on("error", () => resolve(false));
+        proc.on("close", (code) => resolve(code === 0));
+    });
+}
+export async function stream(messages, systemPrompt, _mcpConfigFile, onToken) {
+    const lastUser = [...messages].reverse().find((m) => m.role === "user");
+    const prompt = `${systemPrompt}\n\nUser: ${lastUser?.content ?? "help"}`;
+    const args = ["--prompt", prompt, "--yolo"];
+    console.log("[gemini] spawning (no MCP support — using system prompt fallback)");
+    await new Promise((resolve, reject) => {
+        const proc = spawn("gemini", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        proc.stdout?.on("data", (chunk) => {
+            onToken(chunk.toString());
+        });
+        proc.stderr?.on("data", (chunk) => {
+            process.stderr.write(`[gemini stderr] ${chunk.toString()}`);
+        });
+        proc.on("error", (err) => {
+            console.error(`[gemini] spawn error: ${String(err)}`);
+            reject(err);
+        });
+        proc.on("close", (code) => {
+            console.log(`[gemini] exited with code ${code}`);
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`gemini exited with code ${code}`));
+        });
+    });
+}
+//# sourceMappingURL=gemini.js.map

package/dist/apply-ops.js

@@ -0,0 +1,79 @@
+// ── Apply ops ─────────────────────────────────────────────────────────────────
+/**
+ * Apply a list of operations to a copy of the given CompactDiagram.
+ * Returns the modified copy — the original is never mutated.
+ */
+export function applyOps(compact, ops) {
+    const result = JSON.parse(JSON.stringify(compact));
+    for (const op of ops) {
+        const proc = result.processes.find((p) => p.id === op.processId);
+        if (!proc)
+            continue;
+        if (op.op === "add") {
+            for (const elem of op.elements ?? []) {
+                if (!proc.elements.some((e) => e.id === elem.id)) {
+                    proc.elements.push(elem);
+                }
+            }
+            for (const flow of op.flows ?? []) {
+                if (!proc.flows.some((f) => f.id === flow.id)) {
+                    proc.flows.push(flow);
+                }
+            }
+        }
+        else if (op.op === "remove") {
+            const dropEls = new Set(op.elementIds ?? []);
+            const dropFlows = new Set(op.flowIds ?? []);
+            proc.elements = proc.elements.filter((e) => !dropEls.has(e.id));
+            proc.flows = proc.flows.filter((f) => !dropFlows.has(f.id) && !dropEls.has(f.from) && !dropEls.has(f.to));
+        }
+        else if (op.op === "update") {
+            const elem = proc.elements.find((e) => e.id === op.elementId);
+            if (elem) {
+                Object.assign(elem, op.changes);
+            }
+        }
+        else if (op.op === "condition") {
+            proc.flows = proc.flows.map((f) => {
+                if (f.id !== op.flowId)
+                    return f;
+                if (op.condition === null) {
+                    // Rebuild without condition field (noDelete rule)
+                    return { id: f.id, from: f.from, to: f.to, ...(f.name ? { name: f.name } : {}) };
+                }
+                return { ...f, condition: op.condition };
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Extract either an ops patch or a full CompactDiagram from the LLM response.
+ * Returns null if no valid JSON block is found or the format is unrecognised.
+ */
+export function parseResponse(text, current) {
+    const match = /```json\s*\n([\s\S]*?)\n```/.exec(text);
+    if (!match?.[1])
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(match[1]);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null)
+        return null;
+    // Ops format: { "ops": [...] }
+    if ("ops" in parsed && Array.isArray(parsed.ops)) {
+        if (!current)
+            return null; // ops require an existing diagram to patch
+        return applyOps(current, parsed.ops);
+    }
+    // Full CompactDiagram: { "processes": [...] }
+    if ("processes" in parsed && Array.isArray(parsed.processes)) {
+        return parsed;
+    }
+    return null;
+}
+//# sourceMappingURL=apply-ops.js.map