@bpmnkit/core 0.0.14 → 0.0.16

package/README.md

@@ -186,6 +186,8 @@ const outXml = Bpmn.export(restored)
 | [`@bpmnkit/cli-sdk`](https://www.npmjs.com/package/@bpmnkit/cli-sdk) | Plugin authoring SDK for the casen CLI |
 | [`@bpmnkit/create-casen-plugin`](https://www.npmjs.com/package/@bpmnkit/create-casen-plugin) | Scaffold a new casen CLI plugin in seconds |
 | [`@bpmnkit/casen-report`](https://www.npmjs.com/package/@bpmnkit/casen-report) | HTML reports from Camunda 8 incident and SLA data |
+| [`@bpmnkit/casen-worker-http`](https://www.npmjs.com/package/@bpmnkit/casen-worker-http) | Example HTTP worker plugin — completes jobs with live JSONPlaceholder API data |
+| [`@bpmnkit/casen-worker-ai`](https://www.npmjs.com/package/@bpmnkit/casen-worker-ai) | AI task worker — classify, summarize, extract, and decide using Claude |
 
 ## License
 

package/dist/bpmn/compact.d.ts

@@ -30,6 +30,11 @@ export interface CompactElement {
     attachedTo?: string;
     /** Boundary event: false = non-interrupting */
     interrupting?: boolean;
+    /** Nested content for sub-process container types (subProcess, eventSubProcess, etc.) */
+    children?: {
+        elements: CompactElement[];
+        flows: CompactFlow[];
+    };
 }
 /** A sequence flow in compact form. */
 export interface CompactFlow {

package/dist/bpmn/compact.js

@@ -57,6 +57,21 @@ function compactifyElement(el) {
         if (el.cancelActivity === false)
             result.interrupting = false;
     }
+    // Recurse into sub-process container children
+    if ("flowElements" in el && Array.isArray(el.flowElements) && el.flowElements.length > 0) {
+        const seqFlows = "sequenceFlows" in el && Array.isArray(el.sequenceFlows) ? el.sequenceFlows : [];
+        result.children = {
+            elements: el.flowElements.map(compactifyElement),
+            flows: seqFlows.map((sf) => {
+                const f = { id: sf.id, from: sf.sourceRef, to: sf.targetRef };
+                if (sf.name)
+                    f.name = sf.name;
+                if (sf.conditionExpression)
+                    f.condition = sf.conditionExpression.text;
+                return f;
+            }),
+        };
+    }
     return result;
 }
 /**
@@ -175,6 +190,35 @@ function makeExtensions(el) {
     }
     return ext;
 }
+function buildSubContent(children) {
+    if (!children || children.elements.length === 0) {
+        return { flowElements: [], sequenceFlows: [], textAnnotations: [], associations: [] };
+    }
+    const inc = new Map();
+    const out = new Map();
+    for (const f of children.flows) {
+        const o = out.get(f.from) ?? [];
+        o.push(f.id);
+        out.set(f.from, o);
+        const i = inc.get(f.to) ?? [];
+        i.push(f.id);
+        inc.set(f.to, i);
+    }
+    return {
+        flowElements: children.elements.map((child) => buildFlowElement(child, inc.get(child.id) ?? [], out.get(child.id) ?? [])),
+        sequenceFlows: children.flows.map((f) => ({
+            id: f.id,
+            name: f.name,
+            sourceRef: f.from,
+            targetRef: f.to,
+            conditionExpression: f.condition ? { text: f.condition, attributes: {} } : undefined,
+            extensionElements: [],
+            unknownAttributes: {},
+        })),
+        textAnnotations: [],
+        associations: [],
+    };
+}
 function buildFlowElement(el, incoming, outgoing) {
     const base = {
         id: el.id,
@@ -186,12 +230,7 @@ function buildFlowElement(el, incoming, outgoing) {
     };
     const eventDef = el.eventType ? makeEventDef(el.eventType) : undefined;
     const eventDefs = eventDef ? [eventDef] : [];
-    const subContent = {
-        flowElements: [],
-        sequenceFlows: [],
-        textAnnotations: [],
-        associations: [],
-    };
+    const subContent = buildSubContent(el.children);
     switch (el.type) {
         case "startEvent":
             return { ...base, type: "startEvent", eventDefinitions: eventDefs };

package/dist/bpmn/operations.d.ts

@@ -0,0 +1,82 @@
+import type { CompactDiagram, CompactElement } from "./compact.js";
+/**
+ * An atomic edit operation on a {@link CompactDiagram}.
+ * All element/flow references use stable string IDs, not array positions.
+ *
+ * Used by {@link applyOperations} to apply AI-suggested improvements without
+ * regenerating the full BPMN XML.
+ */
+export type BpmnOperation = 
+/** Rename an element. */
+{
+    op: "rename";
+    id: string;
+    name: string;
+}
+/** Patch arbitrary fields of an element (type-safe subset of CompactElement). */
+ | {
+    op: "update";
+    id: string;
+    patch: Partial<CompactElement>;
+}
+/** Remove an element by ID. */
+ | {
+    op: "delete";
+    id: string;
+}
+/**
+ * Insert a new element.
+ * Optionally place it after or before an existing element ID.
+ * Use `parent` to insert inside a sub-process container.
+ */
+ | {
+    op: "insert";
+    element: CompactElement;
+    after?: string;
+    before?: string;
+    parent?: string;
+}
+/**
+ * Add a sequence flow between two existing elements.
+ * Use `parent` when both elements are inside a sub-process.
+ */
+ | {
+    op: "add_flow";
+    id?: string;
+    from: string;
+    to: string;
+    condition?: string;
+    name?: string;
+    parent?: string;
+}
+/** Remove a sequence flow by ID. */
+ | {
+    op: "delete_flow";
+    id: string;
+}
+/** Redirect a sequence flow to a different source or target. */
+ | {
+    op: "redirect_flow";
+    id: string;
+    from?: string;
+    to?: string;
+};
+/**
+ * Apply a list of {@link BpmnOperation}s to a {@link CompactDiagram}, returning
+ * a new diagram (the original is not mutated).
+ *
+ * Operations are applied in order. Element and flow references use stable IDs
+ * so operations survive concurrent unrelated insertions.
+ *
+ * @example
+ * ```typescript
+ * const updated = applyOperations(compact, [
+ *   { op: "rename", id: "task_1", name: "Approve Invoice" },
+ *   { op: "insert", element: { id: "t_notify", type: "userTask", name: "Notify Finance" }, after: "task_1" },
+ *   { op: "add_flow", from: "t_notify", to: "end_1" },
+ * ])
+ * const xml = Bpmn.export(expand(updated))
+ * ```
+ */
+export declare function applyOperations(diagram: CompactDiagram, ops: BpmnOperation[]): CompactDiagram;
+//# sourceMappingURL=operations.d.ts.map

package/dist/bpmn/operations.js

@@ -0,0 +1,152 @@
+function findElementIn(container, id) {
+    for (let i = 0; i < container.elements.length; i++) {
+        const el = container.elements[i];
+        if (!el)
+            continue;
+        if (el.id === id)
+            return { container, element: el, index: i };
+        if (el.children) {
+            const found = findElementIn(el.children, id);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function findFlowIn(container, id) {
+    for (let i = 0; i < container.flows.length; i++) {
+        const f = container.flows[i];
+        if (!f)
+            continue;
+        if (f.id === id)
+            return { container, flow: f, index: i };
+    }
+    for (const el of container.elements) {
+        if (el.children) {
+            const found = findFlowIn(el.children, id);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+function resolveContainer(process, parentId) {
+    if (!parentId)
+        return process;
+    const found = findElementIn(process, parentId);
+    if (!found)
+        return process;
+    if (!found.element.children)
+        found.element.children = { elements: [], flows: [] };
+    return found.element.children;
+}
+function nextFlowId(process) {
+    const ids = new Set();
+    const collect = (c) => {
+        for (const f of c.flows)
+            ids.add(f.id);
+        for (const e of c.elements)
+            if (e.children)
+                collect(e.children);
+    };
+    collect(process);
+    let n = ids.size + 1;
+    while (ids.has(`flow_${n}`))
+        n++;
+    return `flow_${n}`;
+}
+function applyOne(diagram, op) {
+    for (const process of diagram.processes) {
+        switch (op.op) {
+            case "rename": {
+                const found = findElementIn(process, op.id);
+                if (found)
+                    found.element.name = op.name;
+                break;
+            }
+            case "update": {
+                const found = findElementIn(process, op.id);
+                if (found)
+                    Object.assign(found.element, op.patch);
+                break;
+            }
+            case "delete": {
+                const found = findElementIn(process, op.id);
+                if (found)
+                    found.container.elements.splice(found.index, 1);
+                break;
+            }
+            case "insert": {
+                const container = resolveContainer(process, op.parent);
+                if (op.after !== undefined) {
+                    const idx = container.elements.findIndex((e) => e.id === op.after);
+                    container.elements.splice(idx >= 0 ? idx + 1 : container.elements.length, 0, op.element);
+                }
+                else if (op.before !== undefined) {
+                    const idx = container.elements.findIndex((e) => e.id === op.before);
+                    container.elements.splice(idx >= 0 ? idx : 0, 0, op.element);
+                }
+                else {
+                    container.elements.push(op.element);
+                }
+                break;
+            }
+            case "add_flow": {
+                const container = resolveContainer(process, op.parent);
+                const flow = {
+                    id: op.id ?? nextFlowId(process),
+                    from: op.from,
+                    to: op.to,
+                };
+                if (op.name)
+                    flow.name = op.name;
+                if (op.condition)
+                    flow.condition = op.condition;
+                container.flows.push(flow);
+                break;
+            }
+            case "delete_flow": {
+                const found = findFlowIn(process, op.id);
+                if (found)
+                    found.container.flows.splice(found.index, 1);
+                break;
+            }
+            case "redirect_flow": {
+                const found = findFlowIn(process, op.id);
+                if (found) {
+                    if (op.from !== undefined)
+                        found.flow.from = op.from;
+                    if (op.to !== undefined)
+                        found.flow.to = op.to;
+                }
+                break;
+            }
+        }
+    }
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Apply a list of {@link BpmnOperation}s to a {@link CompactDiagram}, returning
+ * a new diagram (the original is not mutated).
+ *
+ * Operations are applied in order. Element and flow references use stable IDs
+ * so operations survive concurrent unrelated insertions.
+ *
+ * @example
+ * ```typescript
+ * const updated = applyOperations(compact, [
+ *   { op: "rename", id: "task_1", name: "Approve Invoice" },
+ *   { op: "insert", element: { id: "t_notify", type: "userTask", name: "Notify Finance" }, after: "task_1" },
+ *   { op: "add_flow", from: "t_notify", to: "end_1" },
+ * ])
+ * const xml = Bpmn.export(expand(updated))
+ * ```
+ */
+export function applyOperations(diagram, ops) {
+    const result = structuredClone(diagram);
+    for (const op of ops) {
+        applyOne(result, op);
+    }
+    return result;
+}
+//# sourceMappingURL=operations.js.map

package/dist/bpmn/optimize/index.js

@@ -1,8 +1,18 @@
 import { analyzeFeel } from "./feel.js";
 import { analyzeFlow } from "./flow.js";
 import { analyzeNaming } from "./naming.js";
+import { analyzePatterns } from "./patterns.js";
 import { analyzeTasks } from "./tasks.js";
-const ALL_CATEGORIES = ["feel", "flow", "naming", "task-reuse", "extract"];
+import { analyzeVariableFlow } from "./variable-flow.js";
+const ALL_CATEGORIES = [
+    "feel",
+    "flow",
+    "naming",
+    "task-reuse",
+    "extract",
+    "pattern",
+    "data-flow",
+];
 function resolveOptions(opts) {
     return {
         feelLengthThreshold: opts?.feelLengthThreshold ?? 80,
@@ -30,11 +40,22 @@ export function optimize(defs, options) {
         if (resolved.categories.includes("task-reuse")) {
             findings.push(...analyzeTasks(process, resolved));
         }
+        if (resolved.categories.includes("pattern")) {
+            findings.push(...analyzePatterns(process));
+        }
+        if (resolved.categories.includes("data-flow")) {
+            findings.push(...analyzeVariableFlow(process));
+        }
     }
-    const byCategory = Object.fromEntries(["feel", "flow", "naming", "task-reuse", "extract"].map((c) => [
-        c,
-        findings.filter((f) => f.category === c).length,
-    ]));
+    const byCategory = Object.fromEntries([
+        "feel",
+        "flow",
+        "naming",
+        "task-reuse",
+        "extract",
+        "pattern",
+        "data-flow",
+    ].map((c) => [c, findings.filter((f) => f.category === c).length]));
     const bySeverity = Object.fromEntries(["info", "warning", "error"].map((s) => [
         s,
         findings.filter((f) => f.severity === s).length,

package/dist/bpmn/optimize/patterns.d.ts

@@ -0,0 +1,4 @@
+import type { BpmnProcess } from "../bpmn-model.js";
+import type { OptimizationFinding } from "./types.js";
+export declare function analyzePatterns(p: BpmnProcess): OptimizationFinding[];
+//# sourceMappingURL=patterns.d.ts.map