callman-mcp 0.2.0 → 0.3.0

package/dist-cjs/resources/docs/diagramSchema.js

@@ -92,39 +92,84 @@ asks for a specific arrangement. Keep diagrams readable: 8–25 nodes, short lab
 per relationship.
 
 ## Editing: patch_diagram ops
+Ops describe CHANGES; the rest of the diagram stays exactly as it is. The op list below is the
+same vocabulary the desktop's AI assistant uses — one implementation (callman-core) applies both.
 \`\`\`jsonc
 { "op": "addNode",    "node": { "type": "db.redis", "label": "cache", "parent": "k8s" } }
 { "op": "updateNode", "id": "orders", "changes": { "label": "Orders API", "style": { "fill": "#EFF6FF" } } }
 { "op": "updateNode", "id": "orders", "changes": { "style": { "fill": null } } }   // remove one style key
 { "op": "updateNode", "id": "orders", "changes": { "style": null } }                // clear the style
 { "op": "removeNode", "id": "bus" }                 // its edges are removed, its children move to the top level
-{ "op": "addEdge",    "edge": { "source": "orders", "target": "n6", "semantic": "async", "color": "#F59E0B" } }
+{ "op": "addEdge",    "edge": { "source": "orders", "target": "cache", "semantic": "async", "color": "#F59E0B" } }
 { "op": "updateEdge", "id": "e2", "changes": { "label": "gRPC", "semantic": "fallback" } }  // color is kept
 { "op": "updateEdge", "id": "e2", "changes": { "color": null } }                  // back to the default color
 { "op": "removeEdge", "id": "e3" }
 { "op": "setTitle",   "title": "New title" }
+{ "op": "moveNode",   "id": "orders", "position": { "x": 320, "y": 80 } }
+{ "op": "reparent",   "id": "orders", "parent": "k8s" }                          // null = top level
+{ "op": "setEdgeRoute", "id": "e2", "routing": "smart", "sourceSide": "right", "targetSide": "left" }
+{ "op": "reorder",    "id": "k8s", "index": "back" }
+{ "op": "setCanvas",  "canvas": { "background": "grid", "defaultRouting": "orthogonal" } }
+{ "op": "group",      "ids": ["orders", "db"], "label": "Order domain" }         // a new frame around them
+{ "op": "ungroup",    "id": "k8s" }                                             // members stay where they are
+{ "op": "relayout",   "scope": "new" }                                           // hint: place only the new nodes (or "all")
 \`\`\`
 - updateNode \`changes\` accepts: type, label, parent (null/"" = top level), position, size,
-  style, rotation, locked, hidden, data. \`style\` and \`data\` MERGE into what the node has;
-  a key set to null is removed.
+  style, rotation, locked, hidden, collapsed, data. \`style\` and \`data\` MERGE into what the
+  node has; a key set to null is removed.
 - updateEdge \`changes\` accepts: source, target, label ("" removes it), semantic, color,
-  routing, markerEnd, markerStart.
+  routing, markerEnd, markerStart, sourceSide, targetSide (null = floating).
+- Ids: a node written without an id gets a slug of its label (\`orders-service\`, \`-2\` on a
+  clash); the result's \`idMap\` reports any id that had to change.
 - Moving a node (position, size or parent) or re-pointing an edge drops the saved route of
   the edges involved; the studio re-routes them (\`reroutedEdges\` in the result).
 - \`relayout\`: \`new\` (default — only new nodes get a place), \`all\` (re-run layout), \`none\`.
 - \`get_diagram\` (view \`graph\`) returns nodes and edges in this same shape — ids, parents,
-  styles, colors — so read it before a patch.
+  styles, colors, routing, sides — so read it before a patch.
+- If someone saved the diagram between your read and your patch, the ops are re-applied on
+  the newer version automatically (they describe intent, not a whole document).
+
+## Mermaid
+- \`get_diagram\` view \`mermaid\` renders any diagram as a Mermaid flowchart (\`id@{ shape, label }\`
+  nodes, \`subgraph\` containers, \`e1@-->\` edge ids, \`-->\`/\`-.->\`/\`==>\` for sync/async/bus).
+- \`create_diagram\` / \`update_diagram\` accept \`source: { format: "mermaid", text }\` instead of
+  nodes: a flowchart/graph becomes nodes and edges (laid out automatically) and the text stays
+  attached as the diagram's source — later ops keep it in sync (the desktop shows both).
+  Bracket shapes map to component types (\`[( )]\` → database, \`{ }\` → decision, \`([ ])\` →
+  terminator …); \`click\`, \`%%\` comments and unknown statements are kept untouched.
+- Any other Mermaid type (sequenceDiagram, classDiagram, erDiagram …) is stored as source only:
+  \`get_diagram\` view \`source\` returns it, the desktop previews it, and structural ops are
+  refused with \`DIAGRAM_SOURCE_UNSUPPORTED_TYPE\`.
+
+## BPMN
+- A BPMN diagram keeps its truth in BPMN 2.0 XML: \`create_diagram\` with \`kind: "bpmn"\` (or nodes
+  typed bpmn.*) writes the XML from your nodes and edges; \`source: { format: "bpmn", text }\` stores a
+  file you already have (from Camunda Modeler, for example). The desktop opens it in its BPMN editor.
+- Node \`type\` is one of the bpmn.* types listed under DIAGRAM OPS above (bpmn.start-event,
+  bpmn.user-task, bpmn.service-task, bpmn.exclusive-gateway, bpmn.parallel-gateway, bpmn.subprocess,
+  bpmn.pool, bpmn.lane, bpmn.boundary-event …). \`data.bpmn\` carries the BPMN facts:
+  \`eventDefinition\` (message | timer | error | signal | …), \`attachedTo\` (boundary events),
+  \`cancelActivity\`, \`isExpanded\`. Edges are sequence flows; \`data.bpmn\` may set
+  \`flow: "message"\` (between pools), \`conditionExpression\` and \`isDefault\`.
+- Pools and lanes are containers (\`parent\`); a boundary event's parent is its host's parent.
+  New nodes need no position: they are placed after their predecessor.
+- \`patch_diagram\` works as on any diagram: every op lands on the XML as a minimal edit — extension
+  elements, annotations and the modeler's formatting stay untouched. \`get_diagram\` view \`source\`
+  returns the XML; view \`graph\` shows the derived nodes/edges with their \`bpmn\` facts.
 
 ## Stored document (get_diagram view: "full")
 \`\`\`ts
 interface DiagramDocument {
   schemaVersion: 1; id: string;
-  meta: { title: string; createdAt: string; updatedAt: string };
-  canvas?: { background?: "grid" | "dots" | "blank"; gridSize?: number };
+  meta: { title: string; createdAt: string; updatedAt: string; revision?: number };
+  canvas?: { background?: "grid" | "dots" | "blank"; gridSize?: number;
+             defaultRouting?: "orthogonal" | "straight" | "curved" | "smart";
+             layout?: { algorithm; direction }; viewport?: { x; y; zoom } };
   nodes: { id; type; position: {x,y}; size: {width,height}; label?; parentId?; rotation?;
-           locked?; hidden?; style?: DiagramStyle; data? }[];
-  edges: { id; source?; target?; label?; routing?; style?: DiagramStyle; markerStart?; markerEnd?;
-           waypoints?; sourceAnchor?; targetAnchor? }[];
+           locked?; hidden?; collapsed?; collapsedSize?; style?: DiagramStyle; data? }[];
+  edges: { id; source?; target?; label?; labelPosition?; routing?; sourceHandle?; targetHandle?;
+           style?: DiagramStyle; markerStart?; markerEnd?; waypoints? }[];
+  source?: { format: "mermaid"; text; diagramType; grammar?; valid? };
 }
 // Stored colors are { raw: "#3B82F6" } (or a theme { token }); bold/italic/underline are
 // the bitmask fontStyle (1 | 2 | 4). The tools convert both ways — write plain colors.

package/dist-cjs/resources/generated/aiPacks.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AI_PACKS = exports.AI_PACKS_CORE_VERSION = void 0;
-// GENERATED by scripts/build-static-resources.mjs from callman-core@1.28.1 ai-packs — do not edit.
-exports.AI_PACKS_CORE_VERSION = "1.28.1";
+// GENERATED by scripts/build-static-resources.mjs from callman-core@1.29.0 ai-packs — do not edit.
+exports.AI_PACKS_CORE_VERSION = "1.29.0";
 exports.AI_PACKS = {
     "db-queries": "<!-- GENERATED FILE — do not edit by hand. Source: callman_core (npm run ai:packs). -->\n\n# Callman data access from scripts (`pm.db.query` / `pm.redis.command`)\n\n`pm.db.query({ connectionId, query })` — ALWAYS `await`. `query` is coerced to a string, `{{tokens}}` are resolved, then dispatched by the connection's type. `connectionId` may be omitted to use the request's configured DB connection. IMPORTANT: `pm.db.query` does NOT accept a `params`/bind array — inline values (quote strings) or use `{{env.X}}` tokens; SQL placeholders like `$1` or `?` are NOT bound.\n\n## MongoDB\n`query` MUST be a JSON STRING of a command object (use `JSON.stringify`), NOT a `db.coll.find(...)` shell string. The match key is `filter` (a top-level `query` key is rejected).\n\n```js\nconst body = pm.response.json();\nconst res = await pm.db.query({\n  connectionId: \"…\",\n  query: JSON.stringify({\n    collection: \"users\",\n    operation: \"findOne\",        // find | findOne | aggregate | countDocuments | insertOne | insertMany | updateOne | updateMany | deleteOne | deleteMany | findOneAndUpdate | findOneAndReplace | findOneAndDelete\n    filter: { email: body.data.user.email },\n  }),\n});\npm.expect(res.rowCount).to.be.above(0);   // existence check\n```\n\nPer-operation fields: `find`/`findOne` use `filter` (+ optional `projection`,`sort`,`limit`,`skip`); `aggregate` uses `pipeline` (array); `insertOne` uses `document`, `insertMany` uses `documents`; `updateOne`/`updateMany`/`findOneAndUpdate` use `filter`+`update` (Mongo update operators, e.g. `{ $set: { … } }`); `deleteOne`/`deleteMany` use `filter`; `findOneAndUpdate`/`findOneAndReplace` accept `returnDocument: \"before\"|\"after\"`. A 24-hex string in a filter is auto-coerced to ObjectId (or use `{ \"$oid\": \"…\" }`). Rows are in `res.rows`; write ops surface counts in `res.rowCount`.\n\n## PostgreSQL / MySQL / Oracle (SQL)\n`query` is plain SQL text. Because `pm.db.query` binds no params, inline the value and quote strings yourself (or use a `{{token}}`):\n\n```js\nconst email = pm.response.json().data.user.email;\nconst res = await pm.db.query({\n  connectionId: \"…\",\n  query: `SELECT id FROM users WHERE email = '${email}'`,\n});\npm.expect(res.rowCount).to.be.above(0);\n```\n\nNotes: a trailing `;` is stripped (except Oracle PL/SQL blocks, which keep it). **Oracle** returns column names UPPERCASE — read `res.rows[0].EMAIL`, not `.email`. `res.rowCount` is the row count for SELECT and the affected-row count for INSERT/UPDATE/DELETE.\n\n## SQL Server (mssql)\nSingle statement per query; a trailing `;` is stripped; `GO` batch separators are REJECTED (client-tool syntax, not T-SQL). Positional params bind as named inputs: `params[0]` → `@p1`, `params[1]` → `@p2`… (scenario db node only — `pm.db.query` has no params).\n\n```sql\nSELECT TOP 1 id, amount FROM dbo.orders WHERE customer_id = @p1 ORDER BY created_at DESC\n```\n\n## Redis (`pm.redis.command`)\n`command` is a single string. Supported commands: **GET, SET, DEL, EXISTS, TTL, HGET, HSET, HGETALL, HDEL, LPUSH, RPUSH, LRANGE, LLEN, SADD, SMEMBERS, SISMEMBER, INCR, DECR, INCRBY, EXPIRE, PERSIST, TYPE, ZADD, ZRANGE, ZSCORE, SCAN**. Quote a value that contains spaces.\n\nStructured replies land in `res.result` as real values: `HGETALL` → object, `LRANGE`/`SMEMBERS`/`ZRANGE` → array, `EXISTS`/`SISMEMBER`/`EXPIRE`/`PERSIST` → boolean; `res.resultText` is the stringified form. `SCAN pattern [count]` is Callman-managed: the cursor loop runs internally (capped at 1000 keys / 100 iterations) and returns `{ keys, count, truncated }` — no raw cursors.\n\n```js\nconst res = await pm.redis.command({ connectionId: \"…\", command: `GET session:${id}` });\npm.expect(res.success).to.be.true;\n// res.result / res.resultText hold the value; res.commandName, res.key are set.\n```\n",
     "diagram-components": "<!-- GENERATED FILE — do not edit by hand. Source: callman_core (npm run ai:packs). -->\n\n# Diagram components and edge notation\n\nA diagram node's `type` MUST be one of the keys below (`callman-core` `DIAGRAM_COMPONENT_CATALOG`). Sizes are the defaults the studio uses; `container` types hold children via `parentId`.\n\n## Edge notation\n\n| Semantic | Meaning | Style tuple |\n| --- | --- | --- |\n| `sync` | Request / response call | dashed=false, strokeWidth=1.5 |\n| `async` | Fire-and-forget, event or callback | dashed=true, dashPattern=\"6 4\", strokeWidth=1.5 |\n| `fallback` | Retry, fallback or optional path | dashed=true, dashPattern=\"1 3\", strokeWidth=1.25 |\n| `bus` | Message bus or stream | dashed=false, strokeWidth=3 |\n\n## Generic (`generic`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `line` | Line | 160×0 | connector, edge, link |\n| `arrow` | Arrow | 160×0 | connector, directed, link |\n| `line.dashed` | Dashed Line | 160×0 | dotted, connector |\n| `rect` | Rectangle | 140×64 | box, card |\n| `square` | Square | 90×90 |  |\n| `ellipse` | Ellipse | 140×64 | oval |\n| `circle` | Circle | 90×90 |  |\n| `diamond` | Diamond | 140×64 | rhombus |\n| `triangle` | Triangle | 140×64 |  |\n| `hexagon` | Hexagon | 140×64 |  |\n| `pentagon` | Pentagon | 140×64 |  |\n| `octagon` | Octagon | 140×64 |  |\n| `parallelogram` | Parallelogram | 140×64 |  |\n| `trapezoid` | Trapezoid | 140×64 |  |\n| `cylinder` | Cylinder | 140×64 | can, tube |\n| `cloud-shape` | Cloud | 140×64 |  |\n| `callout` | Callout | 140×64 | speech, bubble |\n| `text` | Text | 120×36 |  |\n| `sticky` | Sticky note | 140×100 | postit, comment |\n| `card` | Card | 140×64 |  |\n| `frame` | Frame / Container (container) | 220×160 | group, container, boundary |\n| `pool.horizontal` | Pool (horizontal) (swimlane) | 360×220 | swimlane, lane, container, subsystem |\n| `pool.vertical` | Pool (vertical) (swimlane) | 220×360 | swimlane, lane, container, subsystem |\n| `image` | Image | 140×64 | picture |\n\n## Flowchart (`flowchart`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `flow.process` | Process | 140×64 | step, action |\n| `flow.alt-process` | Alternate Process | 140×64 |  |\n| `flow.decision` | Decision | 140×100 | if, branch |\n| `flow.terminator` | Start / End | 130×56 | terminator, begin, stop |\n| `flow.data` | Data (I/O) | 140×64 | input, output, io |\n| `flow.document` | Document | 140×64 |  |\n| `flow.multi-document` | Multi-Document | 140×64 |  |\n| `flow.predefined` | Predefined Process | 140×64 | subroutine |\n| `flow.manual-input` | Manual Input | 140×64 |  |\n| `flow.manual-op` | Manual Operation | 140×64 |  |\n| `flow.preparation` | Preparation | 140×64 |  |\n| `flow.stored-data` | Stored Data | 140×64 |  |\n| `flow.database` | Database | 140×64 | db, store |\n| `flow.display` | Display | 140×64 |  |\n| `flow.delay` | Delay | 140×64 |  |\n| `flow.merge` | Merge | 140×64 |  |\n| `flow.or` | Or | 140×64 |  |\n| `flow.connector` | On-page Connector | 48×48 |  |\n| `flow.off-page` | Off-page Connector | 140×64 |  |\n| `flow.annotation` | Annotation | 140×64 |  |\n\n## UML (`uml`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `uml.class` | Class | 140×64 | entity |\n| `uml.abstract` | Abstract Class | 140×64 |  |\n| `uml.interface` | Interface | 140×64 |  |\n| `uml.enum` | Enum | 140×64 |  |\n| `uml.object` | Object | 140×64 |  |\n| `uml.package` | Package | 140×64 |  |\n| `uml.component` | Component | 140×64 |  |\n| `uml.node` | Node / Deployment | 140×64 |  |\n| `uml.actor` | Actor | 60×100 | user, role |\n| `uml.usecase` | Use Case | 140×64 |  |\n| `uml.boundary` | Boundary | 140×64 |  |\n| `uml.control` | Control | 140×64 |  |\n| `uml.entity` | Entity | 140×64 |  |\n| `uml.state` | State | 140×64 |  |\n| `uml.initial` | Initial State | 36×36 |  |\n| `uml.final` | Final State | 40×40 |  |\n| `uml.decision` | Decision | 60×60 |  |\n| `uml.note` | Note / Comment | 140×64 | comment |\n\n## ERD (`erd`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `erd.entity` | Entity | 140×64 | table |\n| `erd.weak-entity` | Weak Entity | 140×64 |  |\n| `erd.attribute` | Attribute | 140×64 |  |\n| `erd.key-attribute` | Key Attribute | 140×64 | pk, primary key |\n| `erd.multivalued` | Multivalued Attribute | 140×64 |  |\n| `erd.derived` | Derived Attribute | 140×64 |  |\n| `erd.relationship` | Relationship | 140×64 |  |\n| `erd.identifying` | Identifying Relationship | 140×64 |  |\n\n## Architecture (`networking`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `net.user` | User / Client | 60×100 | client, person |\n| `net.admin` | Admin | 60×100 |  |\n| `net.browser` | Browser | 140×64 |  |\n| `net.mobile` | Mobile Device | 90×130 | phone |\n| `net.desktop` | Desktop | 140×64 |  |\n| `net.iot` | IoT Device | 140×64 |  |\n| `net.server` | Server | 140×64 |  |\n| `net.service` | Service | 140×64 | microservice |\n| `net.monolith` | Monolith | 140×64 |  |\n| `net.api-gateway` | API Gateway | 140×64 | api, gateway |\n| `net.load-balancer` | Load Balancer | 140×64 | lb |\n| `net.reverse-proxy` | Reverse Proxy | 140×64 | proxy |\n| `net.firewall` | Firewall | 140×64 | waf |\n| `net.router` | Router | 140×64 |  |\n| `net.switch` | Switch | 140×64 |  |\n| `net.dns` | DNS | 140×64 |  |\n| `net.cdn` | CDN | 140×64 | edge |\n| `net.cache` | Cache | 140×64 |  |\n| `net.queue` | Queue | 140×64 | mq |\n| `net.websocket` | Web Socket | 140×64 | ws |\n| `net.rest` | REST endpoint | 140×64 | http, api |\n| `net.internet` | Internet / Cloud | 140×64 | wan |\n| `net.datacenter` | Datacenter | 140×64 |  |\n| `net.container` | Container | 140×64 |  |\n| `net.pod` | Pod | 140×64 |  |\n| `net.vm` | Virtual Machine | 140×64 | vm |\n\n## Databases (`database`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `db.postgres` | PostgreSQL | 176×56 | postgres, pg |\n| `db.mysql` | MySQL | 176×56 |  |\n| `db.mariadb` | MariaDB | 176×56 |  |\n| `db.mongodb` | MongoDB | 176×56 | mongo |\n| `db.redis` | Redis | 176×56 |  |\n| `db.sqlite` | SQLite | 176×56 |  |\n| `db.mssql` | MS SQL Server | 176×56 | sqlserver, mssql |\n| `db.oracle` | Oracle | 176×56 |  |\n| `db.cassandra` | Cassandra | 176×56 |  |\n| `db.elasticsearch` | Elasticsearch | 176×56 | elastic, es |\n| `db.neo4j` | Neo4j | 176×56 | graph |\n| `db.couchdb` | CouchDB | 176×56 | couch |\n| `db.couchbase` | Couchbase | 176×56 |  |\n| `db.clickhouse` | ClickHouse | 176×56 |  |\n| `db.cockroachdb` | CockroachDB | 176×56 | cockroach |\n| `db.influxdb` | InfluxDB | 176×56 | influx, tsdb |\n| `db.snowflake` | Snowflake | 176×56 |  |\n| `db.supabase` | Supabase | 176×56 |  |\n\n## Messaging (`messaging`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `mq.kafka` | Apache Kafka | 176×56 | kafka |\n| `mq.rabbitmq` | RabbitMQ | 176×56 | rabbit, amqp |\n| `mq.nats` | NATS | 176×56 |  |\n| `mq.pulsar` | Apache Pulsar | 176×56 | pulsar |\n| `mq.mqtt` | MQTT | 176×56 |  |\n| `mq.pubsub` | Pub/Sub | 176×56 | pubsub |\n| `mq.activemq` | ActiveMQ | 176×56 | jms |\n\n## Languages (`language`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `lang.node` | Node.js | 176×56 | node, js runtime |\n| `lang.python` | Python | 176×56 | py |\n| `lang.java` | Java | 176×56 | jvm |\n| `lang.go` | Go | 176×56 | golang |\n| `lang.rust` | Rust | 176×56 |  |\n| `lang.dotnet` | C# / .NET | 176×56 | csharp, c# |\n| `lang.typescript` | TypeScript | 176×56 | ts |\n| `lang.javascript` | JavaScript | 176×56 | js |\n| `lang.ruby` | Ruby | 176×56 |  |\n| `lang.php` | PHP | 176×56 |  |\n| `lang.kotlin` | Kotlin | 176×56 |  |\n| `lang.swift` | Swift | 176×56 |  |\n| `lang.scala` | Scala | 176×56 |  |\n| `lang.elixir` | Elixir | 176×56 |  |\n| `lang.cpp` | C++ | 176×56 | cpp |\n\n## Frameworks (`framework`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `fw.express` | Express | 176×56 |  |\n| `fw.nestjs` | NestJS | 176×56 | nest |\n| `fw.spring` | Spring Boot | 176×56 | spring |\n| `fw.django` | Django | 176×56 |  |\n| `fw.flask` | Flask | 176×56 |  |\n| `fw.fastapi` | FastAPI | 176×56 |  |\n| `fw.rails` | Rails | 176×56 | ruby on rails |\n| `fw.laravel` | Laravel | 176×56 |  |\n| `fw.dotnet` | .NET | 176×56 |  |\n| `fw.react` | React | 176×56 |  |\n| `fw.vue` | Vue | 176×56 | vuejs |\n| `fw.angular` | Angular | 176×56 |  |\n| `fw.next` | Next.js | 176×56 | nextjs |\n| `fw.nuxt` | Nuxt | 176×56 | nuxtjs |\n| `fw.svelte` | Svelte | 176×56 | sveltekit |\n| `fw.electron` | Electron | 176×56 |  |\n| `fw.tailwind` | Tailwind | 176×56 | tailwindcss |\n| `fw.graphql` | GraphQL | 176×56 |  |\n\n## DevOps / CI-CD (`devops`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `ops.docker` | Docker | 176×56 |  |\n| `ops.k8s` | Kubernetes | 176×56 | k8s |\n| `ops.nginx` | Nginx | 176×56 |  |\n| `ops.haproxy` | HAProxy | 176×56 | lb |\n| `ops.traefik` | Traefik | 176×56 | traefik |\n| `ops.terraform` | Terraform | 176×56 | iac |\n| `ops.ansible` | Ansible | 176×56 |  |\n| `ops.jenkins` | Jenkins | 176×56 | ci |\n| `ops.gha` | GitHub Actions | 176×56 | ci, actions |\n| `ops.gitlab` | GitLab CI | 176×56 | ci |\n| `ops.argocd` | ArgoCD | 176×56 | gitops |\n| `ops.helm` | Helm | 176×56 |  |\n| `ops.istio` | Istio | 176×56 | service mesh |\n| `ops.envoy` | Envoy | 176×56 | proxy |\n| `ops.consul` | Consul | 176×56 |  |\n| `ops.vault` | Vault | 176×56 | secrets |\n| `ops.pm2` | PM2 | 176×56 |  |\n| `ops.maven` | Maven | 176×56 | build |\n\n## Auth / Identity (`auth`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `auth.oidc` | OpenID Connect | 176×56 | oidc |\n| `auth.jwt` | JWT | 176×56 | token |\n| `auth.keycloak` | Keycloak | 176×56 |  |\n| `auth.auth0` | Auth0 | 176×56 |  |\n| `auth.okta` | Okta | 176×56 |  |\n| `auth.firebase` | Firebase Auth | 176×56 | firebase |\n| `auth.oauth` | OAuth 2.0 | 176×56 | oauth |\n| `auth.saml` | SAML | 176×56 |  |\n| `auth.ldap` | LDAP | 176×56 |  |\n\n## Observability (`observability`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `obs.prometheus` | Prometheus | 176×56 | metrics |\n| `obs.grafana` | Grafana | 176×56 | dashboard |\n| `obs.datadog` | Datadog | 176×56 |  |\n| `obs.sentry` | Sentry | 176×56 | errors |\n| `obs.elasticsearch` | Elasticsearch | 176×56 | elk |\n| `obs.logstash` | Logstash | 176×56 | elk |\n| `obs.kibana` | Kibana | 176×56 | elk |\n| `obs.jaeger` | Jaeger | 176×56 | tracing |\n| `obs.otel` | OpenTelemetry | 176×56 | otel, tracing |\n| `obs.newrelic` | New Relic | 176×56 |  |\n\n## AWS (`aws`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `aws.ec2` | EC2 | 176×56 | aws |\n| `aws.lambda` | Lambda | 176×56 | aws |\n| `aws.s3` | S3 | 176×56 | aws |\n| `aws.ebs` | EBS | 176×56 | aws |\n| `aws.efs` | EFS | 176×56 | aws |\n| `aws.rds` | RDS | 176×56 | aws |\n| `aws.aurora` | Aurora | 176×56 | aws |\n| `aws.dynamodb` | DynamoDB | 176×56 | aws |\n| `aws.elasticache` | ElastiCache | 176×56 | aws |\n| `aws.redshift` | Redshift | 176×56 | aws |\n| `aws.vpc` | VPC | 176×56 | aws |\n| `aws.subnet` | Subnet | 176×56 | aws |\n| `aws.internet-gateway` | Internet Gateway | 176×56 | aws |\n| `aws.nat-gateway` | NAT Gateway | 176×56 | aws |\n| `aws.elb` | ELB | 176×56 | aws |\n| `aws.alb` | ALB | 176×56 | aws |\n| `aws.nlb` | NLB | 176×56 | aws |\n| `aws.api-gateway` | API Gateway | 176×56 | aws |\n| `aws.cloudfront` | CloudFront | 176×56 | aws |\n| `aws.route-53` | Route 53 | 176×56 | aws |\n| `aws.sqs` | SQS | 176×56 | aws |\n| `aws.sns` | SNS | 176×56 | aws |\n| `aws.eventbridge` | EventBridge | 176×56 | aws |\n| `aws.kinesis` | Kinesis | 176×56 | aws |\n| `aws.step-functions` | Step Functions | 176×56 | aws |\n| `aws.ecs` | ECS | 176×56 | aws |\n| `aws.eks` | EKS | 176×56 | aws |\n| `aws.fargate` | Fargate | 176×56 | aws |\n| `aws.ecr` | ECR | 176×56 | aws |\n| `aws.iam` | IAM | 176×56 | aws |\n| `aws.cognito` | Cognito | 176×56 | aws |\n| `aws.secrets-manager` | Secrets Manager | 176×56 | aws |\n| `aws.kms` | KMS | 176×56 | aws |\n| `aws.cloudwatch` | CloudWatch | 176×56 | aws |\n| `aws.cloudtrail` | CloudTrail | 176×56 | aws |\n| `aws.glue` | Glue | 176×56 | aws |\n| `aws.athena` | Athena | 176×56 | aws |\n| `aws.sagemaker` | SageMaker | 176×56 | aws |\n| `aws.appsync` | AppSync | 176×56 | aws |\n| `aws.amplify` | Amplify | 176×56 | aws |\n\n## Azure (`azure`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `azure.virtual-machine` | Virtual Machine | 176×56 | azure |\n| `azure.vm-scale-set` | VM Scale Set | 176×56 | azure |\n| `azure.app-service` | App Service | 176×56 | azure |\n| `azure.functions` | Functions | 176×56 | azure |\n| `azure.container-instances` | Container Instances | 176×56 | azure |\n| `azure.aks` | AKS | 176×56 | azure |\n| `azure.container-registry` | Container Registry | 176×56 | azure |\n| `azure.blob-storage` | Blob Storage | 176×56 | azure |\n| `azure.files` | Files | 176×56 | azure |\n| `azure.disk` | Disk | 176×56 | azure |\n| `azure.sql-database` | SQL Database | 176×56 | azure |\n| `azure.cosmos-db` | Cosmos DB | 176×56 | azure |\n| `azure.cache-for-redis` | Cache for Redis | 176×56 | azure |\n| `azure.synapse` | Synapse | 176×56 | azure |\n| `azure.virtual-network` | Virtual Network | 176×56 | azure |\n| `azure.load-balancer` | Load Balancer | 176×56 | azure |\n| `azure.application-gateway` | Application Gateway | 176×56 | azure |\n| `azure.front-door` | Front Door | 176×56 | azure |\n| `azure.service-bus` | Service Bus | 176×56 | azure |\n| `azure.event-hub` | Event Hub | 176×56 | azure |\n| `azure.event-grid` | Event Grid | 176×56 | azure |\n| `azure.key-vault` | Key Vault | 176×56 | azure |\n| `azure.entra-id` | Entra ID | 176×56 | azure |\n| `azure.monitor` | Monitor | 176×56 | azure |\n| `azure.application-insights` | Application Insights | 176×56 | azure |\n| `azure.logic-apps` | Logic Apps | 176×56 | azure |\n| `azure.api-management` | API Management | 176×56 | azure |\n\n## GCP (`gcp`)\n\n| Type | Label | Default size | Aliases |\n| --- | --- | --- | --- |\n| `gcp.compute-engine` | Compute Engine | 176×56 | gcp, google |\n| `gcp.app-engine` | App Engine | 176×56 | gcp, google |\n| `gcp.cloud-functions` | Cloud Functions | 176×56 | gcp, google |\n| `gcp.cloud-run` | Cloud Run | 176×56 | gcp, google |\n| `gcp.gke` | GKE | 176×56 | gcp, google |\n| `gcp.artifact-registry` | Artifact Registry | 176×56 | gcp, google |\n| `gcp.cloud-storage` | Cloud Storage | 176×56 | gcp, google |\n| `gcp.persistent-disk` | Persistent Disk | 176×56 | gcp, google |\n| `gcp.cloud-sql` | Cloud SQL | 176×56 | gcp, google |\n| `gcp.cloud-spanner` | Cloud Spanner | 176×56 | gcp, google |\n| `gcp.firestore` | Firestore | 176×56 | gcp, google |\n| `gcp.bigtable` | Bigtable | 176×56 | gcp, google |\n| `gcp.bigquery` | BigQuery | 176×56 | gcp, google |\n| `gcp.memorystore` | Memorystore | 176×56 | gcp, google |\n| `gcp.vpc` | VPC | 176×56 | gcp, google |\n| `gcp.cloud-load-balancing` | Cloud Load Balancing | 176×56 | gcp, google |\n| `gcp.cloud-cdn` | Cloud CDN | 176×56 | gcp, google |\n| `gcp.cloud-dns` | Cloud DNS | 176×56 | gcp, google |\n| `gcp.pub-sub` | Pub/Sub | 176×56 | gcp, google |\n| `gcp.dataflow` | Dataflow | 176×56 | gcp, google |\n| `gcp.cloud-tasks` | Cloud Tasks | 176×56 | gcp, google |\n| `gcp.iam` | IAM | 176×56 | gcp, google |\n| `gcp.secret-manager` | Secret Manager | 176×56 | gcp, google |\n| `gcp.cloud-kms` | Cloud KMS | 176×56 | gcp, google |\n| `gcp.cloud-monitoring` | Cloud Monitoring | 176×56 | gcp, google |\n| `gcp.vertex-ai` | Vertex AI | 176×56 | gcp, google |\n",

package/dist-cjs/tools/diagrams.js

@@ -14,13 +14,116 @@ const pagination_js_1 = require("../lib/pagination.js");
 const lookups_js_1 = require("./lookups.js");
 const shared_js_1 = require("./shared.js");
 const directionArg = zod_1.z.enum(["DOWN", "RIGHT", "UP", "LEFT"]).optional().describe("Layout flow direction (default DOWN)");
+const sourceArg = zod_1.z
+    .object({
+    format: zod_1.z.enum(["mermaid", "bpmn"]).describe('"mermaid": Mermaid text; "bpmn": a BPMN 2.0 XML file'),
+    text: zod_1.z
+        .string()
+        .min(1)
+        .max(2_000_000)
+        .describe("Mermaid: a flowchart/graph becomes nodes and edges (laid out automatically) and stays attached as the diagram's source; any other Mermaid type is stored as source only. BPMN: the XML is the diagram (its shapes, flows, pools and lanes are derived from it with their positions)"),
+})
+    .strict()
+    .optional()
+    .describe("Create the diagram from Mermaid text or BPMN 2.0 XML instead of nodes/edges");
+// A BPMN diagram keeps its truth in BPMN 2.0 XML: the model is derived from it.
+const bpmnSource = (text) => ({ format: "bpmn", text, diagramType: "bpmn", grammar: callman_core_1.BPMN_GRAMMAR_VERSION });
+// Typed bpmn.* nodes → a BPMN diagram: the model becomes XML, the XML becomes
+// the diagram's source, and the shapes are derived back from it.
+const bpmnDocumentFromModel = (model, unpositionedNodeIds, base) => {
+    const placed = unpositionedNodeIds.length > 0 ? (0, callman_core_1.applyDiagramOps)(model, (0, callman_core_1.placeBpmnNodesOps)(model, unpositionedNodeIds)).doc : model;
+    const xml = (0, callman_core_1.bpmnXmlFromDocument)({ ...placed, source: undefined });
+    const document = (0, callman_core_1.applyDiagramOps)({ ...base, nodes: [], edges: [], source: undefined }, [{ op: "setSource", source: bpmnSource(xml), resync: true }], { now: now() }).doc;
+    return { document, layoutNote: unpositionedNodeIds.length > 0 ? `Written as BPMN 2.0 XML; ${unpositionedNodeIds.length} node(s) placed left to right after their predecessors.` : "Written as BPMN 2.0 XML with the positions given." };
+};
+// Every document entering a tool goes through the shared gate (legacy fields
+// stripped, ids deduped, parents healed) — the same one the studio applies.
 const loadDocument = (diagram) => {
-    const parsed = (0, callman_core_1.safeParseDiagramDocument)(diagram.document);
+    const result = (0, callman_core_1.normalizeDocument)(diagram.document);
+    if (!result.document.nodes && !result.document.edges) {
+        throw new errors_js_1.ToolInputError("DIAGRAM_DOCUMENT_INVALID", `The stored diagram "${diagram.name}" is not a valid document.`);
+    }
+    return result.document;
+};
+const now = () => new Date().toISOString();
+// A source-backed diagram whose Mermaid type is not a flowchart has no model
+// to edit: structural tools refuse it clearly instead of guessing. (BPMN
+// diagrams are editable: their ops patch the XML.)
+const assertEditableStructure = (doc) => {
+    if (doc.source && doc.source.format === "mermaid" && doc.source.diagramType !== "flowchart") {
+        throw new errors_js_1.ToolInputError("DIAGRAM_SOURCE_UNSUPPORTED_TYPE", `This diagram is a Mermaid ${doc.source.diagramType} kept as source only; nodes and edges cannot be edited through ops. Update its source with update_diagram { source } or read it with get_diagram view:"source".`, { diagramType: doc.source.diagramType });
+    }
+};
+// Mermaid text → the document it describes: a flowchart is parsed into
+// nodes/edges (positions come from layout); anything else is kept as
+// source only (the desktop previews it, tools read it back).
+const documentFromSource = async (title, text, existing, direction, format = "mermaid") => {
+    if (format === "bpmn") {
+        if (!(0, callman_core_1.looksLikeBpmn)(text))
+            throw new errors_js_1.ToolInputError("DIAGRAM_SOURCE_INVALID", "The text is not a BPMN 2.0 document (no <definitions> root).");
+        const parsed = (0, callman_core_1.parseBpmn)(text);
+        if (!parsed.ok) {
+            throw new errors_js_1.ToolInputError("DIAGRAM_SOURCE_INVALID", "The BPMN XML could not be read.", { diagnostics: parsed.structure.diagnostics.filter((entry) => entry.severity === "error").slice(0, 20) });
+        }
+        const base = existing ?? (0, callman_core_1.createEmptyDocument)(title);
+        let document;
+        try {
+            document = (0, callman_core_1.applyDiagramOps)(base, [{ op: "setSource", source: bpmnSource(text), resync: true }], { now: now() }).doc;
+        }
+        catch (error) {
+            return (0, build_js_1.toToolError)(error);
+        }
+        // Shapes the XML has no diagram interchange for are placed after their predecessors.
+        const unplaced = parsed.structure.nodes.filter((node) => !node.position).map((node) => node.id).filter((id) => document.nodes.some((node) => node.id === id));
+        if (unplaced.length > 0)
+            document = (0, callman_core_1.applyDiagramOps)(document, (0, callman_core_1.placeBpmnNodesOps)(document, unplaced), { now: now() }).doc;
+        const warnings = parsed.structure.diagnostics.filter((entry) => entry.severity !== "error").map((entry) => entry.message);
+        return { document, layoutNote: unplaced.length > 0 ? `Positions from the BPMN diagram interchange; ${unplaced.length} shape(s) without one were placed.` : "Positions from the BPMN diagram interchange.", warnings };
+    }
+    if (!(0, callman_core_1.looksLikeMermaid)(text)) {
+        throw new errors_js_1.ToolInputError("DIAGRAM_SOURCE_INVALID", "The text does not start with a Mermaid diagram header (flowchart, graph, sequenceDiagram, …).");
+    }
+    const base = existing ?? (0, callman_core_1.createEmptyDocument)(title);
+    if (!(0, callman_core_1.isMermaidFlowchart)(text)) {
+        const header = text.replace(/^---[\s\S]*?\n---\s*\n/, "").split("\n").map((line) => line.trim()).find((line) => line !== "" && !line.startsWith("%%")) ?? "";
+        const diagramType = header.split(/\s+/)[0] ?? "unknown";
+        const source = { format: "mermaid", text, diagramType, grammar: callman_core_1.MERMAID_GRAMMAR_VERSION, valid: true };
+        const doc = (0, callman_core_1.applyDiagramOps)(base, [{ op: "setSource", source, resync: false }], { now: now() }).doc;
+        return { document: doc, layoutNote: `Stored as Mermaid ${diagramType} source (no nodes to lay out).`, warnings: [] };
+    }
+    const parsed = (0, callman_core_1.parseMermaid)(text);
     if (!parsed.ok) {
-        throw new errors_js_1.ToolInputError("DIAGRAM_DOCUMENT_INVALID", `The stored diagram "${diagram.name}" is not a valid document: ${parsed.errors.join("; ")}`, { errors: parsed.errors });
+        throw new errors_js_1.ToolInputError("DIAGRAM_SOURCE_INVALID", "The Mermaid flowchart has syntax errors.", {
+            diagnostics: parsed.structure.diagnostics.filter((entry) => entry.severity === "error").slice(0, 20),
+        });
     }
-    return parsed.document;
+    const source = { format: "mermaid", text, diagramType: "flowchart", grammar: callman_core_1.MERMAID_GRAMMAR_VERSION };
+    let applied;
+    try {
+        applied = (0, callman_core_1.applyDiagramOps)(base, [{ op: "setSource", source }], { now: now() });
+    }
+    catch (error) {
+        return (0, build_js_1.toToolError)(error);
+    }
+    const warnings = parsed.structure.diagnostics.filter((entry) => entry.severity !== "error").map((entry) => entry.message);
+    const newIds = applied.added.nodes;
+    let document = applied.doc;
+    let layoutNote;
+    if (newIds.length > 0) {
+        if (existing && existing.nodes.length > 0) {
+            document = (0, layout_js_1.placeNewNodes)(document, newIds);
+            layoutNote = `Placed ${newIds.length} new node(s) below the existing ones.`;
+        }
+        else {
+            const laid = await (0, layout_js_1.layoutDocument)(document, { direction: direction ?? parsed.structure.direction });
+            document = laid.document;
+            layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
+        }
+    }
+    return { document, layoutNote, warnings };
 };
+// Save with the revision we read; on a 409 the caller reloads and reapplies.
+const isConflict = (error) => error instanceof errors_js_1.CallmanApiError && error.status === 409;
 const registerDiagramTools = (server, ctx) => {
     server.registerTool("list_diagrams", {
         title: "List diagrams",
@@ -36,52 +139,88 @@ const registerDiagramTools = (server, ctx) => {
     }));
     server.registerTool("get_diagram", {
         title: "Get a diagram",
-        description: "Read a diagram: `summary` (counts, owner, sharing), `graph` (default — nodes with type/label/parent/style and edges with semantic/color, in the same shape the write tools accept: enough to describe, restyle or edit it) or `full` (the complete stored DiagramDocument with positions, sizes and routes, up to 512 KB).",
-        inputSchema: { diagram: (0, shared_js_1.refArg)("Diagram"), view: zod_1.z.enum(["summary", "graph", "full"]).default("graph") },
+        description: "Read a diagram: `summary` (counts, owner, sharing), `graph` (default — nodes with type/label/parent/style and edges with semantic/color/routing/sides, in the same shape the write tools accept: enough to describe, restyle or edit it), `mermaid` (the diagram rendered as Mermaid flowchart text), `source` (the Mermaid text or BPMN 2.0 XML a source-backed diagram keeps) or `full` (the complete stored DiagramDocument with positions, sizes and routes, up to 512 KB).",
+        inputSchema: { diagram: (0, shared_js_1.refArg)("Diagram"), view: zod_1.z.enum(["summary", "graph", "mermaid", "source", "full"]).default("graph") },
         annotations: shared_js_1.READ,
     }, (0, shared_js_1.guarded)(async ({ diagram, view }) => {
         const resolved = await (0, lookups_js_1.resolveDiagram)(ctx, diagram);
         const doc = loadDocument(resolved.item);
         const summary = (0, summarize_js_1.diagramListView)(resolved.item);
-        const body = view === "summary" ? summary : view === "graph" ? { ...summary, ...(0, summarize_js_1.diagramGraphView)(doc) } : { ...summary, ...(0, summarize_js_1.diagramFullView)(doc) };
+        const body = view === "summary"
+            ? summary
+            : view === "graph"
+                ? { ...summary, ...(0, summarize_js_1.diagramGraphView)(doc) }
+                : view === "mermaid"
+                    ? { ...summary, ...(0, summarize_js_1.diagramMermaidView)(doc) }
+                    : view === "source"
+                        ? { ...summary, ...(0, summarize_js_1.diagramSourceView)(doc) }
+                        : { ...summary, ...(0, summarize_js_1.diagramFullView)(doc) };
         return (0, shared_js_1.ok)({ diagram: body, ...(resolved.annotation ? { resolved: [(0, resolve_js_1.resolvedSummary)(diagram, resolved)] } : {}) });
     }));
     server.registerTool("create_diagram", {
         title: "Create a system-design diagram",
-        description: "Create a diagram from typed nodes and edges. Node `type` must come from callman://diagram/components (e.g. net.service, net.api-gateway, db.postgres, mq.kafka, aws.lambda, flow.process); unknown types are rejected with suggestions unless strictTypes: false. Group nodes inside a container node — frame, pool.horizontal or pool.vertical — with `parent`. Style nodes with `style` (fill / stroke / textColor as CSS colors, strokeWidth, dashed, radius, bold, fontSize, opacity…) and edges with `semantic` (sync default, async, fallback, bus) plus an optional `color`. Layout is automatic when nodes have no positions. Read callman://docs/diagram-schema for every field. Keep it readable: 8–25 nodes, short labels.",
+        description: "Create a diagram from typed nodes and edges — or from Mermaid text / BPMN 2.0 XML (`source`). A BPMN process (`kind: \"bpmn\"`, or nodes typed bpmn.*) is stored as BPMN 2.0 XML the desktop opens in its BPMN editor. Node `type` must come from callman://diagram/components (e.g. net.service, net.api-gateway, db.postgres, mq.kafka, aws.lambda, flow.process); unknown types are rejected with suggestions unless strictTypes: false. Group nodes inside a container node — frame, pool.horizontal or pool.vertical — with `parent`. Style nodes with `style` (fill / stroke / textColor as CSS colors, strokeWidth, dashed, radius, bold, fontSize, opacity…) and edges with `semantic` (sync default, async, fallback, bus), an optional `color`, `routing` and fixed `sourceSide`/`targetSide`. Layout is automatic when nodes have no positions. Read callman://docs/diagram-schema for every field. Keep it readable: 8–25 nodes, short labels.",
         inputSchema: {
             name: zod_1.z.string().min(1).max(200).describe("Diagram name (library entry)"),
-            ...build_js_1.diagramInputSchema.shape,
+            title: build_js_1.diagramInputSchema.shape.title.optional().describe("Diagram title (defaults to the name)"),
+            nodes: build_js_1.diagramInputSchema.shape.nodes.optional(),
+            edges: build_js_1.diagramInputSchema.shape.edges.optional(),
+            canvas: build_js_1.diagramInputSchema.shape.canvas,
+            source: sourceArg,
+            kind: zod_1.z.enum(["canvas", "bpmn"]).optional().describe('"bpmn": model a business process — nodes use bpmn.* types and the diagram is stored as BPMN 2.0 XML (default: canvas; inferred as bpmn when every node type starts with "bpmn.")'),
             autoLayout: zod_1.z.boolean().optional().describe("Force layout even when positions were given"),
             direction: directionArg,
             strictTypes: zod_1.z.boolean().optional(),
             dryRun: shared_js_1.dryRunArg,
         },
         annotations: shared_js_1.WRITE,
-    }, (0, shared_js_1.guarded)(async ({ name, autoLayout, direction, strictTypes, dryRun, ...input }) => {
-        const built = (0, build_js_1.buildDiagramDocument)(input, { strictTypes });
-        let document = built.document;
+    }, (0, shared_js_1.guarded)(async ({ name, title, nodes, edges, canvas, source, kind, autoLayout, direction, strictTypes, dryRun }) => {
+        if (!nodes && !source)
+            throw new errors_js_1.ToolInputError("NOTHING_TO_CREATE", "Pass nodes (+ edges) or source { format: \"mermaid\" | \"bpmn\", text }.");
+        if (nodes && source)
+            throw new errors_js_1.ToolInputError("CONFLICTING_INPUT", "Pass either nodes or source, not both.");
+        let document;
         let layoutNote;
-        if (autoLayout || built.unpositionedNodeIds.length > 0) {
-            const laid = await (0, layout_js_1.layoutDocument)(document, { direction });
-            document = laid.document;
-            layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
+        let warnings = [];
+        const bpmnKind = kind === "bpmn" || (kind === undefined && Boolean(nodes && nodes.length > 0 && nodes.every((node) => node.type.startsWith("bpmn."))));
+        if (source) {
+            const fromSource = await documentFromSource(title ?? name, source.text, null, direction, source.format);
+            document = canvas ? { ...fromSource.document, canvas: { ...fromSource.document.canvas, ...canvas } } : fromSource.document;
+            layoutNote = fromSource.layoutNote;
+            warnings = fromSource.warnings;
+        }
+        else if (bpmnKind) {
+            const built = (0, build_js_1.buildDiagramDocument)({ title: title ?? name, nodes: nodes ?? [], edges: edges ?? [], canvas }, { strictTypes, kind: "bpmn" });
+            const bpmn = bpmnDocumentFromModel(built.document, built.unpositionedNodeIds, (0, callman_core_1.createEmptyDocument)(title ?? name));
+            document = bpmn.document;
+            layoutNote = bpmn.layoutNote;
+            warnings = built.warnings;
+        }
+        else {
+            const built = (0, build_js_1.buildDiagramDocument)({ title: title ?? name, nodes: nodes ?? [], edges: edges ?? [], canvas }, { strictTypes });
+            document = built.document;
+            warnings = built.warnings;
+            if (autoLayout || built.unpositionedNodeIds.length > 0) {
+                const laid = await (0, layout_js_1.layoutDocument)(document, { direction });
+                document = laid.document;
+                layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
+            }
         }
         if (dryRun) {
-            return (0, shared_js_1.ok)({ dryRun: true, diagram: { name, ...(0, summarize_js_1.diagramGraphView)(document) }, warnings: built.warnings, ...(layoutNote ? { layout: layoutNote } : {}) });
+            return (0, shared_js_1.ok)({ dryRun: true, diagram: { name, ...(0, summarize_js_1.diagramGraphView)(document) }, warnings, ...(layoutNote ? { layout: layoutNote } : {}) });
         }
         const created = await ctx.api.createDiagram({ name: name.trim(), document });
         ctx.invalidate("diagrams");
         return (0, shared_js_1.ok)({
             diagram: { ...(0, summarize_js_1.diagramListView)(created), ...(0, summarize_js_1.diagramGraphView)(document) },
-            warnings: built.warnings,
+            warnings,
             ...(layoutNote ? { layout: layoutNote } : {}),
             note: "Saved. Open it in the desktop app (Diagrams → Refresh). Edit with patch_diagram; share with share_diagram.",
         });
     }));
     server.registerTool("update_diagram", {
         title: "Replace a diagram's content",
-        description: "Replace a diagram's whole document (nodes + edges, same fields as create_diagram) and/or rename it, retitle it or change its canvas, keeping its identity and sharing. Passing nodes replaces ALL nodes and edges (omitted edges are removed). For small edits — including restyling — prefer patch_diagram.",
+        description: "Replace a diagram's whole document (nodes + edges, same fields as create_diagram), replace or attach its Mermaid text or BPMN 2.0 XML `source`, and/or rename it, retitle it or change its canvas — keeping its identity and sharing. Passing nodes replaces ALL nodes and edges (omitted edges are removed). Passing `source` re-derives nodes and edges from the text (existing ones keep their place; new ones are placed). For small edits — including restyling — prefer patch_diagram.",
         inputSchema: {
             diagram: (0, shared_js_1.refArg)("Diagram"),
             name: zod_1.z.string().min(1).max(200).optional(),
@@ -89,15 +228,18 @@ const registerDiagramTools = (server, ctx) => {
             nodes: build_js_1.diagramInputSchema.shape.nodes.optional(),
             edges: build_js_1.diagramInputSchema.shape.edges.optional(),
             canvas: build_js_1.diagramInputSchema.shape.canvas,
+            source: sourceArg,
             autoLayout: zod_1.z.boolean().optional(),
             direction: directionArg,
             strictTypes: zod_1.z.boolean().optional(),
         },
         annotations: shared_js_1.IDEMPOTENT_WRITE,
-    }, (0, shared_js_1.guarded)(async ({ diagram, name, title, nodes, edges, canvas, autoLayout, direction, strictTypes }) => {
-        if (name === undefined && nodes === undefined && title === undefined && canvas === undefined) {
-            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name, title, canvas and/or nodes (+ edges).");
+    }, (0, shared_js_1.guarded)(async ({ diagram, name, title, nodes, edges, canvas, source, autoLayout, direction, strictTypes }) => {
+        if (name === undefined && nodes === undefined && title === undefined && canvas === undefined && source === undefined) {
+            throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", "Pass name, title, canvas, source and/or nodes (+ edges).");
         }
+        if (nodes && source)
+            throw new errors_js_1.ToolInputError("CONFLICTING_INPUT", "Pass either nodes or source, not both.");
         const resolved = await (0, lookups_js_1.resolveDiagram)(ctx, diagram);
         if (!resolved.item.canEdit)
             throw new errors_js_1.ToolInputError("DIAGRAM_READ_ONLY", "You have read-only access to this diagram.");
@@ -105,33 +247,60 @@ const registerDiagramTools = (server, ctx) => {
         let document;
         let layoutNote;
         let warnings = [];
-        if (nodes) {
+        if (nodes && existing.source?.format === "bpmn") {
+            // A BPMN diagram stays BPMN: the new model is written as fresh XML.
+            const built = (0, build_js_1.buildDiagramDocument)({ title: title ?? existing.meta.title, nodes, edges: edges ?? [], canvas: canvas ?? existing.canvas }, { strictTypes, existingId: existing.id, createdAt: existing.meta.createdAt, kind: "bpmn" });
+            const bpmn = bpmnDocumentFromModel(built.document, built.unpositionedNodeIds, existing);
+            document = bpmn.document;
+            layoutNote = bpmn.layoutNote;
+            warnings = [...built.warnings, "The BPMN XML was rewritten from the input; anything in the file that is not a flow node, flow, pool or lane was dropped. Prefer patch_diagram for edits."];
+        }
+        else if (nodes) {
+            assertEditableStructure(existing);
             const built = (0, build_js_1.buildDiagramDocument)({ title: title ?? existing.meta.title, nodes, edges: edges ?? [], canvas: canvas ?? existing.canvas }, { strictTypes, existingId: existing.id, createdAt: existing.meta.createdAt });
             document = built.document;
             warnings = built.warnings;
             if (edges === undefined && existing.edges.length > 0) {
                 warnings.push(`edges was omitted, so the ${existing.edges.length} existing edge(s) were removed. Pass edges to keep connections, or use patch_diagram for partial edits.`);
             }
+            if (existing.source)
+                warnings.push("The diagram's Mermaid source was detached: nodes and edges were replaced from the input.");
             if (autoLayout || built.unpositionedNodeIds.length > 0) {
                 const laid = await (0, layout_js_1.layoutDocument)(document, { direction });
                 document = laid.document;
                 layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
             }
         }
+        else if (source) {
+            const fromSource = await documentFromSource(title ?? existing.meta.title, source.text, existing, direction, source.format);
+            document = fromSource.document;
+            layoutNote = fromSource.layoutNote;
+            warnings = fromSource.warnings;
+            if (title !== undefined || canvas !== undefined) {
+                document = {
+                    ...document,
+                    ...(canvas !== undefined ? { canvas: { ...document.canvas, ...canvas } } : {}),
+                    meta: { ...document.meta, ...(title !== undefined ? { title } : {}) },
+                };
+            }
+        }
         else if (title !== undefined || canvas !== undefined) {
             document = {
                 ...existing,
                 ...(canvas !== undefined ? { canvas: { ...existing.canvas, ...canvas } } : {}),
-                meta: { ...existing.meta, ...(title !== undefined ? { title } : {}), updatedAt: new Date().toISOString() },
+                meta: { ...existing.meta, ...(title !== undefined ? { title } : {}), updatedAt: now() },
             };
         }
-        const updated = await ctx.api.updateDiagram(resolved.item.id, { ...(name !== undefined ? { name: name.trim() } : {}), ...(document ? { document } : {}) });
+        const updated = await ctx.api.updateDiagram(resolved.item.id, {
+            ...(name !== undefined ? { name: name.trim() } : {}),
+            ...(document ? { document, ...(typeof existing.meta.revision === "number" ? { baseRevision: existing.meta.revision } : {}) } : {}),
+        });
         ctx.invalidate("diagrams");
         return (0, shared_js_1.ok)({ diagram: { ...(0, summarize_js_1.diagramListView)(updated), ...(0, summarize_js_1.diagramGraphView)(document ?? existing) }, warnings, ...(layoutNote ? { layout: layoutNote } : {}), resolved: [(0, resolve_js_1.resolvedSummary)(diagram, resolved)] });
     }));
     server.registerTool("patch_diagram", {
         title: "Edit a diagram incrementally",
-        description: "Apply operations to a diagram without resending it: addNode, updateNode, removeNode (drops its edges), addEdge, updateEdge, removeEdge, setTitle. updateNode `changes` MERGE: style and data keys you pass change, a key set to null is removed. updateEdge can change semantic, color, label, arrows and ends. Moving a node (position/size/parent) re-routes its edges. `relayout`: none | new (place only new nodes, default) | all (re-run automatic layout). Call get_diagram (view: graph) first to see node ids and current styles.",
+        description: "Apply operations to a diagram without resending it: addNode, updateNode, removeNode (drops its edges, lifts its children out), addEdge, updateEdge, removeEdge, setTitle, moveNode, reparent, setEdgeRoute (routing, fixed sides, bends), reorder (stacking), setCanvas, group (wrap nodes in a container), ungroup, relayout (a hint: new | all). updateNode `changes` MERGE: style and data keys you pass change, a key set to null is removed. updateEdge can change semantic, color, label, arrows, sides and ends. Moving a node re-routes its edges. `relayout`: none | new (place only new nodes, default) | all (re-run automatic layout). Call get_diagram (view: graph) first to see node ids and current styles. Ops are documented in callman://docs/diagram-schema.",
         inputSchema: {
             diagram: (0, shared_js_1.refArg)("Diagram"),
             ops: zod_1.z.array(patch_js_1.diagramPatchOpSchema).min(1).max(200),
@@ -144,21 +313,53 @@ const registerDiagramTools = (server, ctx) => {
         const resolved = await (0, lookups_js_1.resolveDiagram)(ctx, diagram);
         if (!resolved.item.canEdit)
             throw new errors_js_1.ToolInputError("DIAGRAM_READ_ONLY", "You have read-only access to this diagram.");
-        const existing = loadDocument(resolved.item);
-        const patched = (0, patch_js_1.applyDiagramPatch)(existing, ops, { strictTypes });
-        let document = patched.document;
-        let layoutNote;
-        if (relayout === "all") {
-            const laid = await (0, layout_js_1.layoutDocument)(document, { direction });
-            document = laid.document;
-            layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
+        // Apply on the freshest copy; a 409 (someone saved meanwhile) reloads
+        // and reapplies once — ops describe intent, so they replay cleanly.
+        const attempt = async (record) => {
+            const existing = loadDocument(record);
+            assertEditableStructure(existing);
+            const patched = (0, patch_js_1.applyDiagramPatch)(existing, ops, { strictTypes });
+            let document = patched.document;
+            let layoutNote;
+            const wantsAll = relayout === "all" || patched.relayout?.scope === "all";
+            const layoutDirection = direction ?? patched.relayout?.direction;
+            const bpmn = document.source?.format === "bpmn";
+            if (wantsAll) {
+                // A process reads left to right; the BPMN XML follows the moves.
+                const laid = await (0, layout_js_1.layoutDocument)(document, { direction: layoutDirection ?? (bpmn ? "RIGHT" : undefined) });
+                document = laid.document;
+                layoutNote = laid.warning ?? `Laid out with ${laid.engine}.`;
+            }
+            else if (relayout === "new" && patched.addedNodeIds.length > 0) {
+                const ids = patched.addedNodeIds.filter((id) => document.nodes.some((node) => node.id === id));
+                if (bpmn) {
+                    document = (0, callman_core_1.applyDiagramOps)(document, (0, callman_core_1.placeBpmnNodesOps)(document, ids), { now: now() }).doc;
+                    layoutNote = `Placed ${ids.length} new node(s) after their predecessors.`;
+                }
+                else {
+                    document = (0, layout_js_1.placeNewNodes)(document, ids);
+                    layoutNote = `Placed ${ids.length} new node(s) below the existing ones.`;
+                }
+            }
+            const updated = await ctx.api.updateDiagram(record.id, {
+                document,
+                ...(typeof existing.meta.revision === "number" ? { baseRevision: existing.meta.revision } : {}),
+            });
+            return { updated, document, patched, layoutNote };
+        };
+        let outcome;
+        let retried = false;
+        try {
+            outcome = await attempt(resolved.item);
         }
-        else if (relayout === "new" && patched.addedNodeIds.length > 0) {
-            document = (0, layout_js_1.placeNewNodes)(document, patched.addedNodeIds);
-            layoutNote = `Placed ${patched.addedNodeIds.length} new node(s) below the existing ones.`;
+        catch (error) {
+            if (!isConflict(error))
+                throw error;
+            retried = true;
+            outcome = await attempt(await ctx.api.getDiagram(resolved.item.id));
         }
-        const updated = await ctx.api.updateDiagram(resolved.item.id, { document });
         ctx.invalidate("diagrams");
+        const { updated, document, patched, layoutNote } = outcome;
         return (0, shared_js_1.ok)({
             diagram: { ...(0, summarize_js_1.diagramListView)(updated), ...(0, summarize_js_1.diagramGraphView)(document) },
             applied: ops.length,
@@ -166,7 +367,8 @@ const registerDiagramTools = (server, ctx) => {
             removedNodes: patched.removedNodeIds,
             removedEdges: patched.removedEdgeIds,
             ...(patched.reroutedEdgeIds.length > 0 ? { reroutedEdges: patched.reroutedEdgeIds } : {}),
-            warnings: patched.warnings,
+            ...(Object.keys(patched.idMap).length > 0 ? { idMap: patched.idMap } : {}),
+            warnings: [...patched.warnings, ...(retried ? ["The diagram had been saved by someone else meanwhile; your ops were re-applied on the newer version."] : [])],
             ...(layoutNote ? { layout: layoutNote } : {}),
             resolved: [(0, resolve_js_1.resolvedSummary)(diagram, resolved)],
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "callman-mcp",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "MCP server for Callman: lets Claude Code, Claude Desktop, Cursor, Codex and Gemini CLI manage collections, requests, environments, test scenarios and system-design diagrams in your Callman workspace — cloud or on-prem.",
   "keywords": [
     "callman",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "callman-core": "^1.28.1",
+    "callman-core": "^1.29.0",
     "elkjs": "^0.12.0",
     "js-yaml": "^4.1.0",
     "zod": "^3.25.0"