@bpmnkit/proxy 0.0.15 → 0.0.17

package/dist/index.js

@@ -4,13 +4,13 @@ import http from "node:http";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Bpmn, expand, optimize } from "@bpmnkit/core";
+import { Bpmn, applyOperations, compactify, expand, optimize } from "@bpmnkit/core";
 import { createClientFromProfile } from "@bpmnkit/profiles";
 import { getActiveName, getActiveProfile, getAuthHeader, getProfile, listProfiles, } from "@bpmnkit/profiles";
 import * as claude from "./adapters/claude.js";
 import * as copilot from "./adapters/copilot.js";
 import * as gemini from "./adapters/gemini.js";
-import { buildIncidentSystemPrompt, buildIncidentUserMessage, buildMcpExplainPrompt, buildMcpImprovePrompt, buildMcpSystemPrompt, buildSearchSystemPrompt, buildSystemPrompt, } from "./prompt.js";
+import { buildImproveSystemPrompt, buildImproveUserMessage, buildIncidentSystemPrompt, buildIncidentUserMessage, buildMcpExplainPrompt, buildMcpImprovePrompt, buildMcpSystemPrompt, buildOperateChatSystemPrompt, buildSearchSystemPrompt, buildSystemPrompt, } from "./prompt.js";
 const PORT = process.env.AI_SERVER_PORT ? Number(process.env.AI_SERVER_PORT) : 3033;
 // Resolve the compiled mcp-server entry point relative to this file.
 // When bundled as bundle.cjs, import.meta.url ends with .cjs → use mcp-server.cjs.
@@ -62,6 +62,24 @@ function extractCompactDiagram(text) {
     }
     return null;
 }
+/**
+ * Extract a BpmnOperation[] from LLM text output.
+ * Looks for the first ```json block containing a JSON array.
+ */
+function extractOperations(text) {
+    const match = /```json\s*\n([\s\S]*?)\n```/.exec(text);
+    if (!match?.[1])
+        return null;
+    try {
+        const parsed = JSON.parse(match[1]);
+        if (Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        /* invalid JSON */
+    }
+    return null;
+}
 const server = http.createServer(async (req, res) => {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
@@ -260,6 +278,8 @@ const server = http.createServer(async (req, res) => {
             apiType: p.apiType,
             baseUrl: p.config.baseUrl ?? null,
             authType: p.config.auth?.type ?? "none",
+            description: p.description,
+            tags: p.tags,
         }));
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify(payload));
@@ -731,6 +751,170 @@ const server = http.createServer(async (req, res) => {
         res.end(JSON.stringify({ endpoint: finalSpec.endpoint, filter: finalSpec.filter, items, total }));
         return;
     }
+    // ── POST /improve — structured AI-assisted BPMN improvement ─────────────────
+    // Token-efficient alternative to /chat?action=improve.
+    // Phase 1: optimize() auto-fix (no AI). Phase 2: AI outputs BpmnOperation[].
+    // Emits SSE: tokens (explanation) + ops event + xml event + done.
+    if (url.pathname === "/improve" && req.method === "POST") {
+        const body = await readBody(req);
+        let context;
+        let instruction;
+        let backend;
+        try {
+            const parsed = JSON.parse(body);
+            context = parsed.context;
+            instruction = parsed.instruction ?? null;
+            backend = parsed.backend ?? null;
+        }
+        catch {
+            res.writeHead(400);
+            res.end("Bad Request");
+            return;
+        }
+        const available = await detectAll();
+        const detected = backend
+            ? (available.find((a) => a.name === backend) ?? available[0])
+            : available[0];
+        if (!detected) {
+            res.writeHead(503);
+            res.end("No AI CLI available. Install claude, copilot, or gemini.");
+            return;
+        }
+        // ── Phase 1: auto-fix ─────────────────────────────────────────────────
+        let fixedCompact = context;
+        let autoFixCount = 0;
+        try {
+            const defs = expand(context);
+            const report = optimize(defs);
+            const fixable = report.findings
+                .filter((f) => f.applyFix)
+                .sort((a, b) => {
+                const ord = { error: 0, warning: 1, info: 2 };
+                return (ord[a.severity] ?? 2) - (ord[b.severity] ?? 2);
+            });
+            for (const f of fixable)
+                f.applyFix?.(defs);
+            autoFixCount = fixable.length;
+            if (autoFixCount > 0) {
+                fixedCompact = compactify(defs);
+                console.log(`[server] /improve → auto-fixed ${autoFixCount} issue(s)`);
+            }
+        }
+        catch (err) {
+            console.error("[server] /improve auto-fix failed:", String(err));
+        }
+        // ── Phase 2: collect remaining findings ───────────────────────────────
+        const findings = [];
+        try {
+            const remaining = optimize(expand(fixedCompact));
+            for (const f of remaining.findings) {
+                findings.push({
+                    category: f.category,
+                    severity: f.severity,
+                    message: f.message,
+                    suggestion: f.suggestion,
+                    elementIds: f.elementIds,
+                });
+            }
+        }
+        catch {
+            /* non-fatal */
+        }
+        console.log(`[server] /improve → adapter: ${detected.name}, findings: ${findings.length}, autoFix: ${autoFixCount}`);
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        // ── Phase 3: AI call — outputs explanation + ```json operations block ─
+        const systemPrompt = buildImproveSystemPrompt();
+        const improveCtx = {
+            compact: fixedCompact,
+            findings,
+            autoFixCount,
+            instruction,
+        };
+        const userMessage = buildImproveUserMessage(improveCtx);
+        const accumulated = [];
+        try {
+            await detected.adapter.stream([{ role: "user", content: userMessage }], systemPrompt, null, (token) => {
+                accumulated.push(token);
+                res.write(`data: ${JSON.stringify({ type: "token", text: token })}\n\n`);
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[server] /improve adapter error: ${msg}`);
+            res.write(`data: ${JSON.stringify({ type: "error", message: msg })}\n\n`);
+            res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
+            res.end();
+            return;
+        }
+        // ── Phase 4: parse ops, apply, expand, emit ───────────────────────────
+        const fullText = accumulated.join("");
+        const ops = extractOperations(fullText) ?? [];
+        res.write(`data: ${JSON.stringify({ type: "ops", ops, autoFixCount })}\n\n`);
+        if (ops.length > 0 || autoFixCount > 0) {
+            try {
+                const finalCompact = ops.length > 0 ? applyOperations(fixedCompact, ops) : fixedCompact;
+                const xml = Bpmn.export(expand(finalCompact));
+                res.write(`data: ${JSON.stringify({ type: "xml", xml })}\n\n`);
+                console.log(`[server] /improve → ${ops.length} ops applied, XML emitted`);
+            }
+            catch (err) {
+                console.error("[server] /improve expand failed:", String(err));
+                res.write(`data: ${JSON.stringify({ type: "error", message: `Failed to apply operations: ${String(err)}` })}\n\n`);
+            }
+        }
+        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
+        res.end();
+        return;
+    }
+    // ── POST /operate/chat — operations-context AI chat ──────────────────────────
+    if (url.pathname === "/operate/chat" && req.method === "POST") {
+        const body = await readBody(req);
+        let messages;
+        let stats;
+        let backend;
+        try {
+            const parsed = JSON.parse(body);
+            messages = parsed.messages;
+            stats = parsed.stats ?? null;
+            backend = parsed.backend ?? null;
+        }
+        catch {
+            res.writeHead(400);
+            res.end("Bad Request");
+            return;
+        }
+        const available = await detectAll();
+        const detected = backend
+            ? (available.find((a) => a.name === backend) ?? available[0])
+            : available[0];
+        if (!detected) {
+            res.writeHead(503);
+            res.end("No AI adapter available. Install claude, copilot, or gemini.");
+            return;
+        }
+        console.log(`[server] /operate/chat → adapter: ${detected.name}`);
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        });
+        const systemPrompt = buildOperateChatSystemPrompt(stats);
+        try {
+            await detected.adapter.stream(messages, systemPrompt, null, (token) => {
+                res.write(`data: ${JSON.stringify({ type: "token", text: token })}\n\n`);
+            });
+        }
+        catch (err) {
+            res.write(`data: ${JSON.stringify({ type: "error", message: String(err) })}\n\n`);
+        }
+        res.write(`data: ${JSON.stringify({ type: "done" })}\n\n`);
+        res.end();
+        return;
+    }
     // ── ALL /api/* — transparent Camunda API proxy ─────────────────────────────
     if (url.pathname.startsWith("/api/")) {
         const profileName = req.headers["x-profile"];
@@ -782,6 +966,46 @@ const server = http.createServer(async (req, res) => {
         res.end(await upstream.text());
         return;
     }
+    // ── POST /http-request — CORS bypass for wasm worker REST connectors ─────
+    if (url.pathname === "/http-request" && req.method === "POST") {
+        const body = await readBody(req);
+        let targetUrl;
+        let method;
+        let headers;
+        let reqBody;
+        try {
+            const parsed = JSON.parse(body);
+            targetUrl = parsed.url;
+            method = (parsed.method ?? "GET").toUpperCase();
+            headers = parsed.headers ?? {};
+            reqBody = parsed.body;
+        }
+        catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Invalid JSON body" }));
+            return;
+        }
+        console.log(`[http-request] ${method} ${targetUrl}`);
+        try {
+            const upstream = await fetch(targetUrl, {
+                method,
+                headers,
+                body: method !== "GET" && method !== "HEAD" ? reqBody : undefined,
+            });
+            const responseText = await upstream.text();
+            const contentType = upstream.headers.get("content-type") ?? "application/json";
+            res.writeHead(upstream.status, {
+                "Content-Type": contentType,
+                "Access-Control-Allow-Origin": "*",
+            });
+            res.end(responseText);
+        }
+        catch (err) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Upstream unreachable: ${String(err)}` }));
+        }
+        return;
+    }
     res.writeHead(404);
     res.end("Not Found");
 });

package/dist/prompt.js

@@ -205,6 +205,80 @@ export function buildSearchSystemPrompt() {
         "Omit filter fields that are not relevant. Output ONLY the JSON object.",
     ].join("\n");
 }
+export function buildOperateChatSystemPrompt(stats) {
+    const lines = [
+        "You are an operations assistant for Camunda 8 process automation.",
+        "Help operators understand what is running in their cluster and what actions to take.",
+        "Be concise, actionable, and prioritize incidents (they block process execution).",
+        "Use markdown for formatting. Keep responses short unless detail is specifically requested.",
+        "",
+    ];
+    if (stats) {
+        lines.push("## Current cluster state", `- Running instances: ${stats.runningInstances}`, `- Active incidents: ${stats.activeIncidents}`, `- Pending user tasks: ${stats.pendingTasks}`, `- Deployed process definitions: ${stats.deployedDefinitions}`, `- Active jobs: ${stats.activeJobs}`, "");
+        if (stats.activeIncidents > 0) {
+            lines.push(`There are ${stats.activeIncidents} active incident(s) — these are blocking process execution.`, "When asked what to do next, prioritize resolving incidents first.", "");
+        }
+    }
+    lines.push("## Available actions (user performs these in the UI)", "- View and cancel running instances → Instances page", "- View and retry failed incidents → Incidents page", "- Claim and complete user tasks → Tasks page", "- Start new process instances → Definitions page → Start Instance button", "- Deploy new processes → Models page → Deploy button", "", "When asked to do something, explain which UI page to visit and what to click.", "If asked about a specific instance/incident/task, say you can only see aggregate counts unless you query for details.");
+    return lines.join("\n");
+}
+// ── Improve prompt builders ───────────────────────────────────────────────────
+const OPERATIONS_FORMAT = `
+BpmnOperation types (use stable element IDs, never array positions):
+  { "op": "rename",        "id": "...", "name": "new name" }
+  { "op": "update",        "id": "...", "patch": { /* partial CompactElement fields */ } }
+  { "op": "delete",        "id": "..." }
+  { "op": "insert",        "element": { /* full CompactElement with new unique id */ }, "after"?: "id", "before"?: "id", "parent"?: "sub-process-id" }
+  { "op": "add_flow",      "from": "id", "to": "id", "condition"?: "FEEL expr", "name"?: "...", "parent"?: "sub-process-id" }
+  { "op": "delete_flow",   "id": "..." }
+  { "op": "redirect_flow", "id": "...", "from"?: "new-source-id", "to"?: "new-target-id" }`.trim();
+export function buildImproveSystemPrompt() {
+    return [
+        "You are a BPMN 2.0 process improvement expert.",
+        "",
+        "Output format — follow this EXACTLY:",
+        "1. Write 2–4 sentences explaining what you will change and why.",
+        "2. Then output a single ```json block containing ONLY a JSON array of BpmnOperation objects.",
+        "",
+        OPERATIONS_FORMAT,
+        "",
+        "Rules:",
+        "- Reference only IDs that exist in the provided model (except 'insert' adds new IDs).",
+        "- For 'insert': generate a short, unique camelCase ID (e.g. 'task_notify', 'gw_valid').",
+        "- Output ONLY the operations array in the ```json block — no prose inside it.",
+        "- If no changes are needed, output [].",
+        "",
+        "Apply Camunda BPMN best practices:",
+        '  • Tasks: "Verb Object" — "Verify Invoice", "Send Notification"',
+        '  • Start events: past participle — "Order Received", "Payment Initiated"',
+        '  • End events: object + state — "Order Fulfilled", "Payment Failed"',
+        '  • XOR split gateways: yes/no question ending in "?" — "Invoice valid?"',
+        '  • XOR split outgoing flows: label with condition — "Yes"/"No", "Approved"/"Rejected"',
+        "  • Join gateways: no label",
+        "  • Never send >1 incoming flow to a task without a join gateway first",
+    ].join("\n");
+}
+export function buildImproveUserMessage(ctx) {
+    const lines = [];
+    if (ctx.autoFixCount > 0) {
+        lines.push(`Note: ${ctx.autoFixCount} structural issue(s) were already auto-fixed before this analysis.`, "");
+    }
+    lines.push("Current process model:", "```json", JSON.stringify(ctx.compact, null, 2), "```", "");
+    if (ctx.findings.length > 0) {
+        lines.push("Detected issues to fix:");
+        for (const f of ctx.findings) {
+            const els = f.elementIds.length > 0 ? ` [elements: ${f.elementIds.join(", ")}]` : "";
+            lines.push(`- [${f.severity}/${f.category}] ${f.message}${els}`);
+            lines.push(`  → ${f.suggestion}`);
+        }
+        lines.push("");
+    }
+    if (ctx.instruction) {
+        lines.push(`Additional instructions: ${ctx.instruction}`, "");
+    }
+    lines.push("Explain your changes, then output the BpmnOperation array in a ```json block.");
+    return lines.join("\n");
+}
 // ── Fallback prompt builders (for non-MCP adapters like Gemini) ───────────────
 /** Full system prompt for non-MCP adapters that must return a CompactDiagram JSON block. */
 export function buildSystemPrompt(context) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpmnkit/proxy",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles",
   "type": "module",
   "bin": {
@@ -17,8 +17,8 @@
   },
   "dependencies": {
     "@bpmnkit/api": "0.0.13",
-    "@bpmnkit/core": "0.0.15",
-    "@bpmnkit/profiles": "0.0.10"
+    "@bpmnkit/core": "0.0.16",
+    "@bpmnkit/profiles": "0.0.11"
   },
   "publishConfig": {
     "access": "public"