callman-mcp 0.2.0 → 0.3.0

package/dist-cjs/domain/diagram/build.js

@@ -1,23 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDiagramDocument = exports.edgeStyleFor = exports.assertNotConnector = exports.parentWarning = exports.containerTypes = exports.isContainerType = exports.suggestComponentTypes = exports.diagramInputSchema = exports.diagramEdgeInputSchema = exports.diagramNodeInputSchema = exports.EDGE_SEMANTICS_INPUT = void 0;
+exports.buildDiagramDocument = exports.assertNotConnector = exports.suggestComponentTypes = exports.parentWarning = exports.isContainerType = exports.edgeStyleFor = exports.containerTypes = exports.toToolError = exports.diagramInputSchema = exports.diagramCanvasInputSchema = exports.diagramEdgeInputSchema = exports.diagramNodeInputSchema = exports.SIDES = exports.ROUTINGS = exports.EDGE_SEMANTICS_INPUT = void 0;
 const callman_core_1 = require("callman-core");
+Object.defineProperty(exports, "containerTypes", { enumerable: true, get: function () { return callman_core_1.containerTypes; } });
+Object.defineProperty(exports, "edgeStyleFor", { enumerable: true, get: function () { return callman_core_1.edgeStyleFor; } });
+Object.defineProperty(exports, "isContainerType", { enumerable: true, get: function () { return callman_core_1.isContainerType; } });
+Object.defineProperty(exports, "parentWarning", { enumerable: true, get: function () { return callman_core_1.parentWarning; } });
+Object.defineProperty(exports, "suggestComponentTypes", { enumerable: true, get: function () { return callman_core_1.suggestComponentTypes; } });
 const zod_1 = require("zod");
 const errors_js_1 = require("../../client/errors.js");
-const ids_js_1 = require("../../lib/ids.js");
 const strict_js_1 = require("../../lib/strict.js");
 const style_js_1 = require("./style.js");
 // From the COMPACT diagram a model writes (typed nodes with labels, edges
-// with a meaning) to the DiagramDocument the Diagram Studio renders. Ids are
-// short and stable (n1…, e1…), component types are checked against the
-// shared catalog (unknown → suggestions, never a silent blank shape), edge
-// meaning becomes the studio's notation (sync / async / fallback / bus), and
-// the result is validated with the same parser the backend and desktop use.
+// with a meaning) to the DiagramDocument the Diagram Studio renders. The
+// zod schemas here are the tool contract (strict keys, descriptions); the
+// building itself is callman-core's — the same code the desktop's AI edits
+// and the studio use — so ids, sizes, notation and validation match
+// everywhere. Ids are slugs of the label (`orders-service`, `-2` on a
+// clash) so a model regenerating a diagram keeps them stable.
 exports.EDGE_SEMANTICS_INPUT = ["sync", "async", "fallback", "bus"];
 const ARROWS = ["none", "classic", "classicThin", "open", "block", "diamond", "oval"];
+exports.ROUTINGS = ["orthogonal", "straight", "curved", "smart"];
+exports.SIDES = ["top", "right", "bottom", "left"];
 exports.diagramNodeInputSchema = (0, strict_js_1.strictObject)({
-    id: zod_1.z.string().min(1).max(64).optional().describe("Stable id (n1, api, db…); generated when omitted"),
-    type: zod_1.z.string().min(1).max(80).describe("Component type from callman://diagram/components, e.g. net.service, net.api-gateway, db.postgres, mq.kafka, aws.lambda, flow.process"),
+    id: zod_1.z.string().min(1).max(64).optional().describe("Stable id (orders, api, db…); a slug of the label when omitted"),
+    type: zod_1.z.string().min(1).max(80).describe("Component type from callman://diagram/components, e.g. net.service, net.api-gateway, db.postgres, mq.kafka, aws.lambda, flow.process. On a BPMN diagram: a bpmn.* type (bpmn.user-task, bpmn.exclusive-gateway, bpmn.start-event, bpmn.pool, bpmn.lane …)"),
     label: zod_1.z.string().max(200).optional(),
     parent: zod_1.z.string().max(64).optional().describe("Id of a container node this node sits inside: frame, pool.horizontal or pool.vertical"),
     position: zod_1.z.object({ x: zod_1.z.number(), y: zod_1.z.number() }).strict().optional().describe("Top-left corner; relative to the parent container when `parent` is set. Omit to auto-layout"),
@@ -26,6 +33,7 @@ exports.diagramNodeInputSchema = (0, strict_js_1.strictObject)({
     rotation: zod_1.z.number().min(-360).max(360).optional().describe("Degrees, clockwise"),
     locked: zod_1.z.boolean().optional().describe("Locked nodes cannot be moved or resized in the studio"),
     hidden: zod_1.z.boolean().optional(),
+    collapsed: zod_1.z.boolean().optional().describe("Containers only: drawn folded with the children hidden"),
     data: zod_1.z.record(zod_1.z.unknown()).optional().describe("Free-form metadata kept with the node (not rendered), e.g. { owner: \"team-a\", repo: \"…\" }"),
 }, "node field");
 exports.diagramEdgeInputSchema = (0, strict_js_1.strictObject)({
@@ -35,181 +43,57 @@ exports.diagramEdgeInputSchema = (0, strict_js_1.strictObject)({
     label: zod_1.z.string().max(200).optional(),
     semantic: zod_1.z.enum(exports.EDGE_SEMANTICS_INPUT).optional().describe("sync (default, solid) = request/response, async (dashed) = event, fallback (dotted) = retry/optional, bus (heavy) = message bus; automatic bus when an end is a messaging component"),
     color: style_js_1.colorInputSchema.optional().describe('Line CSS color, e.g. "#8B5CF6". Independent of `semantic`'),
-    routing: zod_1.z.enum(["orthogonal", "straight", "curved"]).optional().describe("orthogonal (default, right-angle auto-routing), straight, curved"),
+    routing: zod_1.z.enum(exports.ROUTINGS).optional().describe("orthogonal (default, right-angle auto-routing), straight, curved, smart (routed around other shapes)"),
     markerEnd: zod_1.z.enum(ARROWS).optional().describe("Arrow at the target (default classicThin)"),
     markerStart: zod_1.z.enum(ARROWS).optional().describe("Arrow at the source (default none) — set it for a two-way connection"),
+    sourceSide: zod_1.z.enum(exports.SIDES).optional().describe("Fix which side of the source node the line leaves from (default: floating — chosen from the relative position)"),
+    targetSide: zod_1.z.enum(exports.SIDES).optional().describe("Fix which side of the target node the line enters"),
+    data: zod_1.z.record(zod_1.z.unknown()).optional().describe('Free-form metadata kept with the edge. On a BPMN diagram: { bpmn: { flow?: "sequence"|"message", conditionExpression?: string, isDefault?: boolean } }'),
 }, "edge field");
+exports.diagramCanvasInputSchema = zod_1.z
+    .object({
+    background: zod_1.z.enum(["grid", "dots", "blank"]).optional(),
+    gridSize: zod_1.z.number().int().positive().optional(),
+    defaultRouting: zod_1.z.enum(exports.ROUTINGS).optional().describe("Routing for edges that do not set their own (default orthogonal)"),
+})
+    .strict()
+    .optional()
+    .describe("Canvas background (default dots), grid size (default 16) and the default edge routing");
 exports.diagramInputSchema = zod_1.z.object({
     title: zod_1.z.string().min(1).max(200),
     nodes: zod_1.z.array(exports.diagramNodeInputSchema).min(1).max(500),
     edges: zod_1.z.array(exports.diagramEdgeInputSchema).max(2000).default([]),
-    canvas: zod_1.z
-        .object({ background: zod_1.z.enum(["grid", "dots", "blank"]).optional(), gridSize: zod_1.z.number().int().positive().optional() })
-        .strict()
-        .optional()
-        .describe("Canvas background (default dots) and grid size (default 16)"),
+    canvas: exports.diagramCanvasInputSchema,
 });
-const suggestComponentTypes = (type, limit = 5) => {
-    const seen = new Set();
-    const out = [];
-    const push = (candidate) => {
-        if (!seen.has(candidate) && out.length < limit) {
-            seen.add(candidate);
-            out.push(candidate);
-        }
-    };
-    for (const entry of (0, callman_core_1.searchDiagramComponents)(type))
-        push(entry.type);
-    // A typo usually sits at the END of the last segment ("db.postgresqlx"):
-    // shrink it until something in the catalog contains it.
-    const tail = (type.split(".").pop() ?? type).toLowerCase();
-    for (let length = tail.length; length >= 3 && out.length < limit; length -= 1) {
-        const needle = tail.slice(0, length);
-        for (const entry of callman_core_1.DIAGRAM_COMPONENT_CATALOG) {
-            const haystack = [entry.type, entry.label, ...(entry.aliases ?? [])].join(" ").toLowerCase();
-            if (haystack.includes(needle))
-                push(entry.type);
-        }
-    }
-    // Still nothing: offer the same namespace ("db.*", "aws.*").
-    const namespace = type.includes(".") ? `${type.split(".")[0].toLowerCase()}.` : null;
-    if (namespace) {
-        for (const entry of callman_core_1.DIAGRAM_COMPONENT_CATALOG)
-            if (entry.type.toLowerCase().startsWith(namespace))
-                push(entry.type);
-    }
-    return out;
+// Core's op errors carry MCP's own codes; only the class changes.
+const toToolError = (error) => {
+    if (error instanceof callman_core_1.DiagramOpError)
+        throw new errors_js_1.ToolInputError(error.code, error.message, error.data);
+    throw error;
 };
-exports.suggestComponentTypes = suggestComponentTypes;
-// Containers hold children through `parent`: frames and swimlane pools.
-const isContainerType = (type) => {
-    const def = type ? (0, callman_core_1.getDiagramComponent)(type) : undefined;
-    return Boolean(def?.container || def?.swimlane);
-};
-exports.isContainerType = isContainerType;
-const containerTypes = () => callman_core_1.DIAGRAM_COMPONENT_CATALOG.filter((entry) => entry.container || entry.swimlane).map((entry) => entry.type);
-exports.containerTypes = containerTypes;
-const parentWarning = (id, parentId, parentType) => (0, exports.isContainerType)(parentType)
-    ? null
-    : `Node ${id} sits inside "${parentId}" (${parentType ?? "unknown"}), which is not a container — use ${(0, exports.containerTypes)().join(", ")} to group nodes.`;
-exports.parentWarning = parentWarning;
-// Edge input → the stored edge's visual fields: the semantic's line tuple
-// plus an optional color.
-// line / arrow / line.dashed are palette connectors (0-height), not nodes.
+exports.toToolError = toToolError;
 const assertNotConnector = (type, id) => {
-    if ((0, callman_core_1.getDiagramComponent)(type)?.variant === "line") {
-        throw new errors_js_1.ToolInputError("DIAGRAM_CONNECTOR_NOT_NODE", `"${type}" on ${id} is a connector, not a node — draw it as an edge between two nodes.`);
+    try {
+        (0, callman_core_1.assertNotConnector)(type, id);
+    }
+    catch (error) {
+        (0, exports.toToolError)(error);
     }
 };
 exports.assertNotConnector = assertNotConnector;
-const edgeStyleFor = (semantic, color) => {
-    const base = semantic ? (0, callman_core_1.semanticStyle)(semantic) : undefined;
-    if (!color)
-        return base;
-    return { ...(base ?? {}), stroke: (0, style_js_1.toTokenRef)(color) };
-};
-exports.edgeStyleFor = edgeStyleFor;
 const buildDiagramDocument = (input, options = {}) => {
-    const strict = options.strictTypes !== false;
-    const warnings = [];
-    const nextNodeId = (0, ids_js_1.sequentialIds)("n", input.nodes.map((node) => node.id).filter((id) => Boolean(id)));
-    const nextEdgeId = (0, ids_js_1.sequentialIds)("e", input.edges.map((edge) => edge.id).filter((id) => Boolean(id)));
-    // Ids first so parents/edges can reference nodes declared later.
-    const ids = input.nodes.map((node) => node.id ?? nextNodeId());
-    const duplicates = ids.filter((id, index) => ids.indexOf(id) !== index);
-    if (duplicates.length > 0) {
-        throw new errors_js_1.ToolInputError("DIAGRAM_DUPLICATE_NODE_ID", `Duplicate node ids: ${[...new Set(duplicates)].join(", ")}`);
-    }
-    const idSet = new Set(ids);
-    const unknown = [];
-    const typeOf = new Map();
-    const nodes = input.nodes.map((node, index) => {
-        const id = ids[index];
-        let type = node.type.trim();
-        const known = (0, callman_core_1.getDiagramComponent)(type);
-        if (!known) {
-            const suggestions = (0, exports.suggestComponentTypes)(type);
-            if (strict)
-                unknown.push({ type, suggestions });
-            else {
-                warnings.push(`Unknown component type "${type}" on ${id} → drawn as a rectangle (suggestions: ${suggestions.join(", ") || "none"})`);
-                type = "rect";
-            }
-        }
-        if (known)
-            (0, exports.assertNotConnector)(type, id);
-        const def = (0, callman_core_1.getDiagramComponent)(type);
-        typeOf.set(id, type);
-        if (node.parent && !idSet.has(node.parent)) {
-            throw new errors_js_1.ToolInputError("DIAGRAM_PARENT_NOT_FOUND", `Node ${id} references parent "${node.parent}" which is not in nodes.`);
-        }
-        return {
-            id,
-            type,
-            position: node.position ?? { x: 0, y: 0 },
-            size: node.size ?? def?.defaultSize ?? { width: 140, height: 60 },
-            ...(node.label !== undefined || !known ? { label: node.label ?? node.type } : def?.defaultLabel ? { label: def.defaultLabel } : {}),
-            ...(node.parent ? { parentId: node.parent } : {}),
-            ...(node.style ? { style: (0, style_js_1.applyStyleInput)(undefined, node.style) } : {}),
-            ...(node.rotation ? { rotation: node.rotation } : {}),
-            ...(node.locked ? { locked: true } : {}),
-            ...(node.hidden ? { hidden: true } : {}),
-            ...(node.data ? { data: node.data } : {}),
-        };
-    });
-    for (const node of nodes) {
-        const warning = node.parentId ? (0, exports.parentWarning)(node.id, node.parentId, typeOf.get(node.parentId)) : null;
-        if (warning)
-            warnings.push(warning);
-    }
-    if (unknown.length > 0) {
-        throw new errors_js_1.ToolInputError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown component type(s): ${unknown.map((entry) => entry.type).join(", ")}. Read callman://diagram/components for the catalog, or pass strictTypes:false to draw them as rectangles.`, { unknownTypes: unknown });
+    try {
+        const built = (0, callman_core_1.buildDiagramFromInput)(input, {
+            strictTypes: options.strictTypes !== false,
+            existingId: options.existingId,
+            createdAt: options.createdAt,
+            idStrategy: "slug",
+            ...(options.kind ? { kind: options.kind } : {}),
+        });
+        return { document: built.document, warnings: built.warnings, unpositionedNodeIds: built.unpositionedNodeIds };
     }
-    const edgeIds = new Set();
-    const edges = input.edges.map((edge) => {
-        const id = edge.id ?? nextEdgeId();
-        if (edgeIds.has(id))
-            throw new errors_js_1.ToolInputError("DIAGRAM_DUPLICATE_EDGE_ID", `Duplicate edge id: ${id}`);
-        edgeIds.add(id);
-        for (const endpoint of [edge.source, edge.target]) {
-            if (!idSet.has(endpoint)) {
-                throw new errors_js_1.ToolInputError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge ${id} references "${endpoint}" which is not a node id.`);
-            }
-        }
-        let semantic = edge.semantic;
-        // A fresh edge into a broker reads as a bus line — the studio's own rule.
-        if (!semantic && ((0, callman_core_1.isBusComponentType)(typeOf.get(edge.source)) || (0, callman_core_1.isBusComponentType)(typeOf.get(edge.target)))) {
-            semantic = "bus";
-        }
-        const style = (0, exports.edgeStyleFor)(semantic, edge.color);
-        return {
-            id,
-            source: edge.source,
-            target: edge.target,
-            ...(edge.label ? { label: edge.label } : {}),
-            routing: edge.routing ?? "orthogonal",
-            markerEnd: edge.markerEnd ?? "classicThin",
-            ...(edge.markerStart && edge.markerStart !== "none" ? { markerStart: edge.markerStart } : {}),
-            ...(style && (!(0, callman_core_1.isDefaultEdgeStyle)(style) || semantic === "sync" || edge.color) ? { style } : {}),
-        };
-    });
-    const timestamp = options.createdAt ?? (0, callman_core_1.nowIso)();
-    const document = (0, callman_core_1.normalizeDiagramStyles)({
-        schemaVersion: callman_core_1.SCHEMA_VERSION,
-        id: options.existingId ?? `doc_${Math.random().toString(36).slice(2, 10)}`,
-        meta: { title: input.title.trim(), createdAt: timestamp, updatedAt: (0, callman_core_1.nowIso)() },
-        canvas: { background: input.canvas?.background ?? "dots", gridSize: input.canvas?.gridSize ?? 16 },
-        nodes,
-        edges,
-    });
-    const parsed = (0, callman_core_1.safeParseDiagramDocument)(document);
-    if (!parsed.ok) {
-        throw new errors_js_1.ToolInputError("DIAGRAM_DOCUMENT_INVALID", `The diagram document is invalid: ${parsed.errors.join("; ")}`, { errors: parsed.errors });
+    catch (error) {
+        return (0, exports.toToolError)(error);
     }
-    return {
-        document: parsed.document,
-        warnings,
-        unpositionedNodeIds: input.nodes.filter((node) => !node.position).map((_node, index) => ids[index]),
-    };
 };
 exports.buildDiagramDocument = buildDiagramDocument;

package/dist-cjs/domain/diagram/layout.js

@@ -45,54 +45,21 @@ const loadElk = () => {
     return defaultEngine;
 };
 const layoutDocument = async (doc, options = {}) => {
-    const algorithm = options.algorithm ?? "layered";
-    const direction = options.direction ?? "DOWN";
-    try {
-        const engine = options.engine ?? (await loadElk());
-        const graph = (0, callman_core_1.buildHierarchicalElkGraph)(doc, algorithm, { direction });
-        const result = await engine.layout(graph);
-        const layout = (0, callman_core_1.applyHierarchicalElkResult)(result);
-        return { document: touch((0, callman_core_1.applyDetailedLayout)(doc, layout)), engine: "elk" };
-    }
-    catch (error) {
-        return {
-            document: touch((0, callman_core_1.gridLayout)(doc)),
-            engine: "grid",
-            warning: `Automatic layout fell back to a grid: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
+    const engine = options.engine ?? (await loadElk());
+    const result = await (0, callman_core_1.runLayout)(doc, {
+        algorithm: options.algorithm ?? "layered",
+        direction: options.direction ?? "DOWN",
+        mode: options.nodeIds && options.nodeIds.length > 0 ? "selection" : "full",
+        nodeIds: options.nodeIds,
+    }, engine);
+    const document = result.ops.length > 0 ? (0, callman_core_1.applyDiagramOps)(doc, result.ops, { now: new Date().toISOString() }).doc : doc;
+    return { document, engine: result.engine, ...(result.warning ? { warning: result.warning } : {}) };
 };
 exports.layoutDocument = layoutDocument;
 // Place ONLY the given nodes (new ones from a patch) below the current
 // bounding box, in rows — nothing that already has a position moves.
 const placeNewNodes = (doc, nodeIds, gap = 40) => {
-    const wanted = new Set(nodeIds);
-    if (wanted.size === 0)
-        return doc;
-    const placed = doc.nodes.filter((node) => !wanted.has(node.id) && !node.parentId);
-    const maxY = placed.reduce((max, node) => Math.max(max, node.position.y + node.size.height), 0);
-    const minX = placed.reduce((min, node) => Math.min(min, node.position.x), placed.length > 0 ? Infinity : 0);
-    let cursorX = Number.isFinite(minX) ? minX : 0;
-    let cursorY = placed.length > 0 ? maxY + gap * 2 : 0;
-    let rowHeight = 0;
-    const rowLimit = 1200;
-    const nodes = doc.nodes.map((node) => {
-        if (!wanted.has(node.id))
-            return node;
-        if (cursorX + node.size.width > rowLimit && cursorX > 0) {
-            cursorX = Number.isFinite(minX) ? minX : 0;
-            cursorY += rowHeight + gap;
-            rowHeight = 0;
-        }
-        const positioned = { ...node, position: { x: cursorX, y: cursorY } };
-        cursorX += node.size.width + gap;
-        rowHeight = Math.max(rowHeight, node.size.height);
-        return positioned;
-    });
-    return touch({ ...doc, nodes });
+    const ops = (0, callman_core_1.placeNewNodesOps)(doc, nodeIds, gap);
+    return ops.length > 0 ? (0, callman_core_1.applyDiagramOps)(doc, ops, { now: new Date().toISOString() }).doc : doc;
 };
 exports.placeNewNodes = placeNewNodes;
-const touch = (doc) => ({
-    ...doc,
-    meta: { ...doc.meta, updatedAt: new Date().toISOString() },
-});