@bpmnkit/proxy 0.0.11 → 0.0.13

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/bpmnkit/monorepo/main/doc/logos/logo-2-gateway.svg" width="72" height="72" alt="BPMN Kit logo">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="72" height="72" alt="BPMN Kit logo"></a>
   <h1>@bpmnkit/proxy</h1>
   <p>Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles</p>
 
@@ -87,3 +87,7 @@ curl -H "X-Profile: production" http://localhost:3033/api/v2/process-definitions
 ## License
 
 [MIT](https://github.com/bpmnkit/monorepo/blob/main/LICENSE) © BPMN Kit — made by [u11g](https://u11g.com)
+
+<div align="center">
+  <a href="https://bpmnkit.com"><img src="https://bpmnkit.com/favicon.svg" width="32" height="32" alt="BPMN Kit"></a>
+</div>

package/dist/index.js

@@ -10,7 +10,7 @@ import { getActiveName, getActiveProfile, getAuthHeader, getProfile, listProfile
 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, buildSystemPrompt, } from "./prompt.js";
+import { buildIncidentSystemPrompt, buildIncidentUserMessage, buildMcpExplainPrompt, buildMcpImprovePrompt, buildMcpSystemPrompt, 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.
@@ -531,6 +531,206 @@ const server = http.createServer(async (req, res) => {
         res.end();
         return;
     }
+    // ── POST /operate/ai-search ────────────────────────────────────────────────
+    // Translates a plain-text query to a Camunda API filter, executes the search,
+    // and returns results as JSON.  AI is only called when the quick-parser cannot
+    // resolve the query deterministically (saves tokens for simple queries).
+    if (url.pathname === "/operate/ai-search" && req.method === "POST") {
+        const body = await readBody(req);
+        let query;
+        try {
+            const parsed = JSON.parse(body);
+            query = parsed.query?.trim() ?? "";
+            if (!query)
+                throw new Error("empty");
+        }
+        catch {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "{ query: string } required" }));
+            return;
+        }
+        const profileName = req.headers["x-profile"];
+        const profile = profileName ? getProfile(profileName) : getActiveProfile();
+        if (!profile?.config.baseUrl) {
+            res.writeHead(401, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "No active profile" }));
+            return;
+        }
+        let authHeader;
+        try {
+            authHeader = await getAuthHeader(profile.config);
+        }
+        catch (err) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Auth failed: ${String(err)}` }));
+            return;
+        }
+        const baseUrl = profile.config.baseUrl.replace(/\/$/, "");
+        const apiHeaders = {
+            authorization: authHeader,
+            "content-type": "application/json",
+            accept: "application/json",
+        };
+        function tryQuickParse(q) {
+            const trimmed = q.trim();
+            // Pure numeric string → instance key lookup
+            if (/^\d+$/.test(trimmed)) {
+                return { endpoint: "instances", filter: { processInstanceKey: trimmed } };
+            }
+            // Single state keyword
+            const stateMap = {
+                active: "ACTIVE",
+                completed: "COMPLETED",
+                terminated: "TERMINATED",
+            };
+            const lower = trimmed.toLowerCase();
+            if (stateMap[lower]) {
+                return { endpoint: "instances", filter: { state: stateMap[lower] } };
+            }
+            return null;
+        }
+        function extractSearchSpec(text) {
+            // Try raw JSON first, then a ```json block, then any {...} substring
+            const candidates = [
+                text.trim(),
+                (/```(?:json)?\s*\n?([\s\S]*?)\n?```/.exec(text) ?? [])[1] ?? "",
+                (/(\{[\s\S]*\})/.exec(text) ?? [])[1] ?? "",
+            ];
+            for (const candidate of candidates) {
+                if (!candidate)
+                    continue;
+                try {
+                    const parsed = JSON.parse(candidate);
+                    if (typeof parsed === "object" &&
+                        parsed !== null &&
+                        "endpoint" in parsed &&
+                        "filter" in parsed) {
+                        return parsed;
+                    }
+                }
+                catch {
+                    /* try next */
+                }
+            }
+            return null;
+        }
+        let spec = tryQuickParse(query);
+        console.log(`[server] /operate/ai-search → query: "${query}", quick-parse: ${spec ? "hit" : "miss"}`);
+        // Step 2: AI translation — only when quick-parse has no answer
+        if (!spec) {
+            const available = await detectAll();
+            const detected = available[0];
+            if (!detected) {
+                res.writeHead(503, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "No AI adapter available" }));
+                return;
+            }
+            console.log(`[server] /operate/ai-search → adapter: ${detected.name}`);
+            const tokens = [];
+            try {
+                await detected.adapter.stream([{ role: "user", content: query }], buildSearchSystemPrompt(), null, (t) => tokens.push(t));
+            }
+            catch (err) {
+                res.writeHead(500, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: String(err) }));
+                return;
+            }
+            spec = extractSearchSpec(tokens.join(""));
+            if (!spec) {
+                res.writeHead(422, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Could not interpret search query" }));
+                return;
+            }
+        }
+        // Step 3: Execute search against Camunda
+        // Coerce variables filter.value to JSON-serialized string form.
+        // The Camunda API stores variable values as JSON strings (e.g. "3355" for the number 3355).
+        // If the AI emits a number or boolean, stringify it to match the stored representation.
+        if (spec.endpoint === "variables" &&
+            spec.filter.value !== undefined &&
+            typeof spec.filter.value !== "string") {
+            spec.filter.value = JSON.stringify(spec.filter.value);
+        }
+        const finalSpec = spec;
+        let items = [];
+        let total = 0;
+        try {
+            if (finalSpec.endpoint === "variables") {
+                const r = await fetch(`${baseUrl}/variables/search`, {
+                    method: "POST",
+                    headers: apiHeaders,
+                    body: JSON.stringify({ filter: finalSpec.filter, page: { limit: 100 } }),
+                });
+                if (r.ok) {
+                    const result = (await r.json());
+                    items = result.items ?? [];
+                    total = result.page?.totalItems ?? items.length;
+                    // Enrich variable results with instance startDate (best-effort, single batch request)
+                    const keys = [
+                        ...new Set(items
+                            .map((v) => v.processInstanceKey)
+                            .filter((k) => typeof k === "string")),
+                    ];
+                    if (keys.length > 0) {
+                        try {
+                            const ir = await fetch(`${baseUrl}/process-instances/search`, {
+                                method: "POST",
+                                headers: apiHeaders,
+                                body: JSON.stringify({
+                                    filter: { processInstanceKey: { $in: keys } },
+                                    page: { limit: keys.length },
+                                }),
+                            });
+                            if (ir.ok) {
+                                const instResult = (await ir.json());
+                                const instMap = new Map((instResult.items ?? []).map((inst) => [inst.processInstanceKey, inst]));
+                                items = items.map((v) => {
+                                    const inst = instMap.get(v.processInstanceKey);
+                                    return {
+                                        ...v,
+                                        instanceStartDate: inst?.startDate ?? null,
+                                        instanceProcessName: inst?.processDefinitionName ?? null,
+                                        instanceProcessId: inst?.processDefinitionId ?? null,
+                                        instanceState: inst?.state ?? null,
+                                        instanceIsSubprocess: inst != null &&
+                                            inst.parentProcessInstanceKey != null &&
+                                            inst.parentProcessInstanceKey !== "",
+                                    };
+                                });
+                            }
+                        }
+                        catch {
+                            // Enrichment is best-effort; variable results are still returned
+                        }
+                    }
+                }
+            }
+            else {
+                const r = await fetch(`${baseUrl}/process-instances/search`, {
+                    method: "POST",
+                    headers: apiHeaders,
+                    body: JSON.stringify({
+                        filter: finalSpec.filter,
+                        page: { limit: 100 },
+                        sort: [{ field: "startDate", order: "DESC" }],
+                    }),
+                });
+                if (r.ok) {
+                    const result = (await r.json());
+                    items = result.items ?? [];
+                    total = result.page?.totalItems ?? items.length;
+                }
+            }
+        }
+        catch (err) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: `Search failed: ${String(err)}` }));
+            return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ endpoint: finalSpec.endpoint, filter: finalSpec.filter, items, total }));
+        return;
+    }
     // ── ALL /api/* — transparent Camunda API proxy ─────────────────────────────
     if (url.pathname.startsWith("/api/")) {
         const profileName = req.headers["x-profile"];

package/dist/prompt.js

@@ -171,6 +171,40 @@ export function buildIncidentUserMessage(incident, variables, processXml) {
     }
     return lines.join("\n");
 }
+// ── Operate AI search prompt ───────────────────────────────────────────────────
+/**
+ * Minimal system prompt for the AI search endpoint.
+ * Instructs the model to output ONLY a JSON object (no prose) to keep token usage low.
+ */
+export function buildSearchSystemPrompt() {
+    return [
+        "You are a Camunda 8 search assistant.",
+        "Convert the user query into a JSON search request. Output ONLY a valid JSON object — no explanation, no markdown, no extra text.",
+        "",
+        'Schema: { "endpoint": "instances" | "variables", "filter": { ... } }',
+        "",
+        'Instance filter fields (endpoint "instances"):',
+        '  state: "ACTIVE" | "COMPLETED" | "TERMINATED"',
+        "  processDefinitionKey: string (numeric ID)",
+        "  processDefinitionId: string (BPMN process ID, substring)",
+        "  hasIncident: boolean",
+        "  processInstanceKey: string (numeric key)",
+        "  parentProcessInstanceKey: string",
+        "",
+        'Variable filter fields (endpoint "variables"):',
+        "  name: string (exact variable name)",
+        '  value: string (JSON-serialized form — number 3355 → "3355", boolean true → "true", string hello → "\\"hello\\"")',
+        "  processInstanceKey: string",
+        "  isTruncated: boolean",
+        "  tenantId: string",
+        "",
+        'Use "instances" for queries about process state, definition, incidents, or dates.',
+        'Use "variables" whenever a variable name or value is mentioned — even if phrased as "instances with variable X" or "find instances where variable Y equals Z" (the instances endpoint has no variable filter; use variables instead).',
+        "",
+        'Example: "find instances with the variable value 3355" → {"endpoint":"variables","filter":{"value":"3355"}}',
+        "Omit filter fields that are not relevant. Output ONLY the JSON object.",
+    ].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.11",
+  "version": "0.0.13",
   "description": "Local proxy server for BPMN Kit — AI bridge (SSE/MCP) and Camunda API proxy using stored CLI profiles",
   "type": "module",
   "bin": {
@@ -16,9 +16,9 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@bpmnkit/api": "0.0.11",
-    "@bpmnkit/core": "0.0.11",
-    "@bpmnkit/profiles": "0.0.8"
+    "@bpmnkit/api": "0.0.12",
+    "@bpmnkit/core": "0.0.13",
+    "@bpmnkit/profiles": "0.0.9"
   },
   "publishConfig": {
     "access": "public"