callman-mcp 0.1.0

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDiagramDocument = exports.suggestComponentTypes = exports.diagramInputSchema = exports.diagramEdgeInputSchema = exports.diagramNodeInputSchema = exports.EDGE_SEMANTICS_INPUT = void 0;
+const callman_core_1 = require("callman-core");
+const zod_1 = require("zod");
+const errors_js_1 = require("../../client/errors.js");
+const ids_js_1 = require("../../lib/ids.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.
+exports.EDGE_SEMANTICS_INPUT = ["sync", "async", "fallback", "bus"];
+exports.diagramNodeInputSchema = zod_1.z.object({
+    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, db.postgres, aws.lambda, flow.process"),
+    label: zod_1.z.string().max(200).optional(),
+    parent: zod_1.z.string().max(64).optional().describe("Id of a container node (net.zone, flow.frame…) this node sits inside"),
+    position: zod_1.z.object({ x: zod_1.z.number(), y: zod_1.z.number() }).optional(),
+    size: zod_1.z.object({ width: zod_1.z.number().positive(), height: zod_1.z.number().positive() }).optional(),
+    style: zod_1.z.record(zod_1.z.unknown()).optional(),
+    data: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.diagramEdgeInputSchema = zod_1.z.object({
+    id: zod_1.z.string().min(1).max(64).optional(),
+    source: zod_1.z.string().min(1).max(64),
+    target: zod_1.z.string().min(1).max(64),
+    label: zod_1.z.string().max(200).optional(),
+    semantic: zod_1.z.enum(exports.EDGE_SEMANTICS_INPUT).optional().describe("sync (default) = request/response, async = event, fallback = retry/optional, bus = message bus"),
+    routing: zod_1.z.enum(["orthogonal", "straight", "curved"]).optional(),
+    markerEnd: zod_1.z.enum(["none", "classic", "classicThin", "open", "block", "diamond", "oval"]).optional(),
+});
+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() }).optional(),
+});
+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;
+};
+exports.suggestComponentTypes = suggestComponentTypes;
+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";
+            }
+        }
+        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: node.style } : {}),
+            ...(node.data ? { data: node.data } : {}),
+        };
+    });
+    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 });
+    }
+    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 = semantic ? (0, callman_core_1.semanticStyle)(semantic) : undefined;
+        return {
+            id,
+            source: edge.source,
+            target: edge.target,
+            ...(edge.label ? { label: edge.label } : {}),
+            routing: edge.routing ?? "orthogonal",
+            markerEnd: edge.markerEnd ?? "classicThin",
+            ...(style && !(0, callman_core_1.isDefaultEdgeStyle)(style) ? { style } : semantic === "sync" ? { 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 });
+    }
+    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

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.placeNewNodes = exports.layoutDocument = void 0;
+const callman_core_1 = require("callman-core");
+let defaultEngine = null;
+const loadElk = () => {
+    defaultEngine ??= Promise.resolve().then(() => __importStar(require("elkjs/lib/elk.bundled.js"))).then((module) => {
+        const ElkCtor = (module.default ?? module);
+        const elk = new ElkCtor();
+        return { layout: (graph) => elk.layout(graph) };
+    });
+    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)}`,
+        };
+    }
+};
+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 });
+};
+exports.placeNewNodes = placeNewNodes;
+const touch = (doc) => ({
+    ...doc,
+    meta: { ...doc.meta, updatedAt: new Date().toISOString() },
+});

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDiagramPatch = exports.diagramPatchOpSchema = void 0;
+const callman_core_1 = require("callman-core");
+const zod_1 = require("zod");
+const errors_js_1 = require("../../client/errors.js");
+const ids_js_1 = require("../../lib/ids.js");
+const build_js_1 = require("./build.js");
+// Incremental edits to a stored diagram — the model sends operations, not a
+// 200-node document. Removing a node drops the edges attached to it.
+exports.diagramPatchOpSchema = zod_1.z.discriminatedUnion("op", [
+    zod_1.z.object({ op: zod_1.z.literal("addNode"), node: build_js_1.diagramNodeInputSchema }),
+    zod_1.z.object({
+        op: zod_1.z.literal("updateNode"),
+        id: zod_1.z.string().min(1),
+        changes: build_js_1.diagramNodeInputSchema.partial().omit({ id: true }),
+    }),
+    zod_1.z.object({ op: zod_1.z.literal("removeNode"), id: zod_1.z.string().min(1) }),
+    zod_1.z.object({ op: zod_1.z.literal("addEdge"), edge: build_js_1.diagramEdgeInputSchema }),
+    zod_1.z.object({
+        op: zod_1.z.literal("updateEdge"),
+        id: zod_1.z.string().min(1),
+        changes: build_js_1.diagramEdgeInputSchema.partial().omit({ id: true }),
+    }),
+    zod_1.z.object({ op: zod_1.z.literal("removeEdge"), id: zod_1.z.string().min(1) }),
+    zod_1.z.object({ op: zod_1.z.literal("setTitle"), title: zod_1.z.string().min(1).max(200) }),
+]);
+const applyDiagramPatch = (doc, ops, options = {}) => {
+    const strict = options.strictTypes !== false;
+    const nodes = new Map(doc.nodes.map((node) => [node.id, { ...node }]));
+    const edges = new Map(doc.edges.map((edge) => [edge.id, { ...edge }]));
+    let title = doc.meta.title;
+    const addedNodeIds = [];
+    const removedNodeIds = [];
+    const removedEdgeIds = [];
+    const warnings = [];
+    const nextNodeId = (0, ids_js_1.sequentialIds)("n", nodes.keys());
+    const nextEdgeId = (0, ids_js_1.sequentialIds)("e", edges.keys());
+    const resolveType = (type, id) => {
+        if ((0, callman_core_1.getDiagramComponent)(type))
+            return type;
+        const suggestions = (0, build_js_1.suggestComponentTypes)(type);
+        if (strict) {
+            throw new errors_js_1.ToolInputError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown component type "${type}" on ${id}.`, {
+                unknownTypes: [{ type, suggestions }],
+            });
+        }
+        warnings.push(`Unknown component type "${type}" on ${id} → rect (suggestions: ${suggestions.join(", ") || "none"})`);
+        return "rect";
+    };
+    for (const op of ops) {
+        switch (op.op) {
+            case "setTitle":
+                title = op.title.trim();
+                break;
+            case "addNode": {
+                const id = op.node.id ?? nextNodeId();
+                if (nodes.has(id))
+                    throw new errors_js_1.ToolInputError("DIAGRAM_DUPLICATE_NODE_ID", `A node with id "${id}" already exists.`);
+                if (op.node.parent && !nodes.has(op.node.parent)) {
+                    throw new errors_js_1.ToolInputError("DIAGRAM_PARENT_NOT_FOUND", `Parent "${op.node.parent}" does not exist.`);
+                }
+                const type = resolveType(op.node.type, id);
+                const def = (0, callman_core_1.getDiagramComponent)(type);
+                nodes.set(id, {
+                    id,
+                    type,
+                    position: op.node.position ?? { x: 0, y: 0 },
+                    size: op.node.size ?? def?.defaultSize ?? { width: 140, height: 60 },
+                    label: op.node.label ?? (type === "rect" && op.node.type !== "rect" ? op.node.type : def?.defaultLabel),
+                    ...(op.node.parent ? { parentId: op.node.parent } : {}),
+                    ...(op.node.style ? { style: op.node.style } : {}),
+                    ...(op.node.data ? { data: op.node.data } : {}),
+                });
+                if (!op.node.position)
+                    addedNodeIds.push(id);
+                break;
+            }
+            case "updateNode": {
+                const node = nodes.get(op.id);
+                if (!node)
+                    throw new errors_js_1.ToolInputError("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`);
+                const changes = op.changes;
+                if (changes.parent !== undefined && changes.parent && !nodes.has(changes.parent)) {
+                    throw new errors_js_1.ToolInputError("DIAGRAM_PARENT_NOT_FOUND", `Parent "${changes.parent}" does not exist.`);
+                }
+                nodes.set(op.id, {
+                    ...node,
+                    ...(changes.type !== undefined ? { type: resolveType(changes.type, op.id) } : {}),
+                    ...(changes.label !== undefined ? { label: changes.label } : {}),
+                    ...(changes.position !== undefined ? { position: changes.position } : {}),
+                    ...(changes.size !== undefined ? { size: changes.size } : {}),
+                    ...(changes.parent !== undefined ? { parentId: changes.parent || undefined } : {}),
+                    ...(changes.style !== undefined ? { style: changes.style } : {}),
+                    ...(changes.data !== undefined ? { data: changes.data } : {}),
+                });
+                break;
+            }
+            case "removeNode": {
+                if (!nodes.delete(op.id))
+                    throw new errors_js_1.ToolInputError("DIAGRAM_NODE_NOT_FOUND", `Node "${op.id}" does not exist.`);
+                removedNodeIds.push(op.id);
+                for (const [edgeId, edge] of [...edges]) {
+                    if (edge.source === op.id || edge.target === op.id) {
+                        edges.delete(edgeId);
+                        removedEdgeIds.push(edgeId);
+                    }
+                }
+                // Children of a removed container become top-level.
+                for (const node of nodes.values())
+                    if (node.parentId === op.id)
+                        delete node.parentId;
+                break;
+            }
+            case "addEdge": {
+                const id = op.edge.id ?? nextEdgeId();
+                if (edges.has(id))
+                    throw new errors_js_1.ToolInputError("DIAGRAM_DUPLICATE_EDGE_ID", `An edge with id "${id}" already exists.`);
+                for (const endpoint of [op.edge.source, op.edge.target]) {
+                    if (!nodes.has(endpoint) && !edges.has(endpoint)) {
+                        throw new errors_js_1.ToolInputError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${endpoint}" does not exist.`);
+                    }
+                }
+                const semantic = op.edge.semantic ??
+                    ((0, callman_core_1.isBusComponentType)(nodes.get(op.edge.source)?.type) || (0, callman_core_1.isBusComponentType)(nodes.get(op.edge.target)?.type) ? "bus" : undefined);
+                edges.set(id, {
+                    id,
+                    source: op.edge.source,
+                    target: op.edge.target,
+                    ...(op.edge.label ? { label: op.edge.label } : {}),
+                    routing: op.edge.routing ?? "orthogonal",
+                    markerEnd: op.edge.markerEnd ?? "classicThin",
+                    ...(semantic ? { style: (0, callman_core_1.semanticStyle)(semantic) } : {}),
+                });
+                break;
+            }
+            case "updateEdge": {
+                const edge = edges.get(op.id);
+                if (!edge)
+                    throw new errors_js_1.ToolInputError("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`);
+                const changes = op.changes;
+                const next = {
+                    ...edge,
+                    ...(changes.source !== undefined ? { source: changes.source } : {}),
+                    ...(changes.target !== undefined ? { target: changes.target } : {}),
+                    ...(changes.label !== undefined ? { label: changes.label } : {}),
+                    ...(changes.routing !== undefined ? { routing: changes.routing } : {}),
+                    ...(changes.markerEnd !== undefined ? { markerEnd: changes.markerEnd } : {}),
+                    ...(changes.semantic !== undefined ? { style: (0, callman_core_1.semanticStyle)(changes.semantic) } : {}),
+                };
+                for (const endpoint of [next.source, next.target]) {
+                    if (endpoint && !nodes.has(endpoint) && !edges.has(endpoint)) {
+                        throw new errors_js_1.ToolInputError("DIAGRAM_EDGE_ENDPOINT_NOT_FOUND", `Edge endpoint "${endpoint}" does not exist.`);
+                    }
+                }
+                edges.set(op.id, next);
+                break;
+            }
+            case "removeEdge": {
+                if (!edges.delete(op.id))
+                    throw new errors_js_1.ToolInputError("DIAGRAM_EDGE_NOT_FOUND", `Edge "${op.id}" does not exist.`);
+                removedEdgeIds.push(op.id);
+                break;
+            }
+        }
+    }
+    const document = (0, callman_core_1.normalizeDiagramStyles)({
+        ...doc,
+        meta: { ...doc.meta, title, updatedAt: new Date().toISOString() },
+        nodes: [...nodes.values()],
+        edges: [...edges.values()],
+    });
+    const parsed = (0, callman_core_1.safeParseDiagramDocument)(document);
+    if (!parsed.ok) {
+        throw new errors_js_1.ToolInputError("DIAGRAM_DOCUMENT_INVALID", `The patched document is invalid: ${parsed.errors.join("; ")}`, { errors: parsed.errors });
+    }
+    return { document: parsed.document, addedNodeIds, removedNodeIds, removedEdgeIds, warnings };
+};
+exports.applyDiagramPatch = applyDiagramPatch;

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagramFullView = exports.diagramGraphView = exports.diagramListView = void 0;
+const callman_core_1 = require("callman-core");
+const truncate_js_1 = require("../../lib/truncate.js");
+// Compact views of a stored diagram: the list row, the graph (what is
+// connected to what, with the edge meaning read back from its style) and
+// the full document behind a size gate.
+const diagramListView = (diagram) => {
+    const parsed = (0, callman_core_1.safeParseDiagramDocument)(diagram.document);
+    return {
+        id: diagram.id,
+        name: diagram.name,
+        canEdit: diagram.canEdit,
+        owner: diagram.owner?.email ?? diagram.owner?.displayName ?? null,
+        sharedWorkspaceIds: diagram.sharedWorkspaceIds ?? [],
+        editorCount: (diagram.editorIds ?? []).length,
+        nodeCount: parsed.ok ? parsed.document.nodes.length : null,
+        edgeCount: parsed.ok ? parsed.document.edges.length : null,
+        updatedAt: diagram.updatedAt ?? null,
+    };
+};
+exports.diagramListView = diagramListView;
+const diagramGraphView = (doc) => ({
+    title: doc.meta.title,
+    nodes: doc.nodes.map((node) => ({
+        id: node.id,
+        type: node.type,
+        label: node.label ?? null,
+        ...(node.parentId ? { parent: node.parentId } : {}),
+    })),
+    edges: doc.edges.map((edge) => ({
+        id: edge.id,
+        source: edge.source ?? null,
+        target: edge.target ?? null,
+        label: edge.label ?? null,
+        semantic: (0, callman_core_1.semanticFromStyle)(edge.style),
+    })),
+});
+exports.diagramGraphView = diagramGraphView;
+const diagramFullView = (doc) => {
+    const size = (0, truncate_js_1.byteLength)(doc);
+    if (size <= truncate_js_1.LIMITS.DIAGRAM_FULL)
+        return { document: doc, truncated: false, bytes: size };
+    return {
+        document: null,
+        truncated: true,
+        bytes: size,
+        note: `The document is ${size} bytes (limit ${truncate_js_1.LIMITS.DIAGRAM_FULL}). Use view:"graph" or patch_diagram for edits.`,
+    };
+};
+exports.diagramFullView = diagramFullView;

package/dist-cjs/domain/importDetect.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentPayload = exports.SERVER_DOCUMENT_FORMATS = exports.detectImport = exports.parseYaml = void 0;
+const callman_core_1 = require("callman-core");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const errors_js_1 = require("../client/errors.js");
+// Format detection for `import_content` — core's detector (the same one the
+// desktop's drop-to-import uses) with js-yaml supplied for OpenAPI / Insomnia
+// v5 YAML documents.
+const parseYaml = (text) => js_yaml_1.default.load(text);
+exports.parseYaml = parseYaml;
+const detectImport = (fileName, content) => (0, callman_core_1.detectImportFormat)(fileName ?? "", content, { parseYaml: exports.parseYaml });
+exports.detectImport = detectImport;
+// Formats the server parses from a whole document (sent as-is).
+exports.SERVER_DOCUMENT_FORMATS = new Set(["postman", "openapi", "insomnia", "bruno", "internal"]);
+// The document as the server's parser wants it: JSON documents parsed, YAML
+// documents (OpenAPI / Bruno) forwarded as text — the backend accepts both.
+const documentPayload = (format, content) => {
+    const trimmed = content.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(content);
+        }
+        catch {
+            throw new errors_js_1.ToolInputError("IMPORT_INVALID_JSON", "The content looks like JSON but does not parse.");
+        }
+    }
+    if (format === "openapi" || format === "bruno")
+        return content;
+    try {
+        return js_yaml_1.default.load(content);
+    }
+    catch {
+        throw new errors_js_1.ToolInputError("IMPORT_INVALID_DOCUMENT", "The content is neither valid JSON nor valid YAML.");
+    }
+};
+exports.documentPayload = documentPayload;