@pascal-app/mcp 0.2.0

package/dist/tools/create-wall.js

@@ -0,0 +1,50 @@
+import { WallNode } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema, Vec2Schema } from './schemas';
+export const createWallInput = {
+    levelId: NodeIdSchema,
+    start: Vec2Schema,
+    end: Vec2Schema,
+    thickness: z.number().positive().optional(),
+    height: z.number().positive().optional(),
+};
+export const createWallOutput = {
+    wallId: z.string(),
+};
+export function registerCreateWall(server, bridge) {
+    server.registerTool('create_wall', {
+        title: 'Create wall',
+        description: 'Create a new wall on the given level between two 2D points. Thickness and height default to the core library defaults when omitted.',
+        inputSchema: createWallInput,
+        outputSchema: createWallOutput,
+    }, async ({ levelId, start, end, thickness, height }) => {
+        const parent = bridge.getNode(levelId);
+        if (!parent) {
+            throwMcpError(ErrorCode.InvalidParams, `Level not found: ${levelId}`);
+        }
+        if (parent.type !== 'level') {
+            throwMcpError(ErrorCode.InvalidParams, `Node ${levelId} is a ${parent.type}, expected level`);
+        }
+        if (typeof parent.metadata === 'object' &&
+            parent.metadata !== null &&
+            'role' in parent.metadata &&
+            parent.metadata.role === 'roof') {
+            throwMcpError(ErrorCode.InvalidParams, `Roof support level ${levelId} is not an occupied story; create walls on an occupied level instead`);
+        }
+        const wall = WallNode.parse({
+            start: start,
+            end: end,
+            ...(thickness !== undefined ? { thickness } : {}),
+            ...(height !== undefined ? { height } : {}),
+        });
+        const id = bridge.createNode(wall, levelId);
+        await publishLiveSceneSnapshot(bridge, 'create_wall');
+        const payload = { wallId: id };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/cut-opening.d.ts

@@ -0,0 +1,18 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const cutOpeningInput: {
+    wallId: z.ZodString;
+    type: z.ZodEnum<{
+        window: "window";
+        door: "door";
+    }>;
+    position: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+};
+export declare const cutOpeningOutput: {
+    openingId: z.ZodString;
+};
+export declare function registerCutOpening(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=cut-opening.d.ts.map

package/dist/tools/cut-opening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cut-opening.d.ts","sourceRoot":"","sources":["../../src/tools/cut-opening.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyDnF"}

package/dist/tools/cut-opening.js

@@ -0,0 +1,57 @@
+import { DoorNode, WindowNode } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { wallLength, wallLocalXFromT } from './geometry';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema } from './schemas';
+export const cutOpeningInput = {
+    wallId: NodeIdSchema,
+    type: z.enum(['door', 'window']),
+    position: z.number().min(0).max(1),
+    width: z.number().positive(),
+    height: z.number().positive(),
+};
+export const cutOpeningOutput = {
+    openingId: z.string(),
+};
+export function registerCutOpening(server, bridge) {
+    server.registerTool('cut_opening', {
+        title: 'Cut opening',
+        description: 'Cut a door or window opening into an existing wall. position is a parametric 0..1 offset along the wall centreline.',
+        inputSchema: cutOpeningInput,
+        outputSchema: cutOpeningOutput,
+    }, async ({ wallId, type, position, width, height }) => {
+        const wall = bridge.getNode(wallId);
+        if (!wall) {
+            throwMcpError(ErrorCode.InvalidParams, `Wall not found: ${wallId}`);
+        }
+        if (wall.type !== 'wall') {
+            throwMcpError(ErrorCode.InvalidParams, `Node ${wallId} is a ${wall.type}, expected wall`);
+        }
+        const length = wallLength(wall);
+        if (length < width) {
+            throwMcpError(ErrorCode.InvalidParams, `Wall ${wallId} is ${length.toFixed(2)}m long, too short for a ${width.toFixed(2)}m opening`);
+        }
+        // `position` is public MCP ergonomics: 0..1 along the wall. Door/window
+        // nodes store wall-local meters in position[0], so convert before writing.
+        const base = {
+            wallId,
+            width,
+            height,
+            position: [wallLocalXFromT(wall, position, width), height / 2, 0],
+        };
+        const opening = type === 'door'
+            ? DoorNode.parse(base)
+            : WindowNode.parse({
+                ...base,
+                position: [base.position[0], 0.9 + height / 2, 0],
+            });
+        const id = bridge.createNode(opening, wallId);
+        await publishLiveSceneSnapshot(bridge, 'cut_opening');
+        const payload = { openingId: id };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/delete-node.d.ts

@@ -0,0 +1,12 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const deleteNodeInput: {
+    id: z.ZodString;
+    cascade: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const deleteNodeOutput: {
+    deletedIds: z.ZodArray<z.ZodString>;
+};
+export declare function registerDeleteNode(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=delete-node.d.ts.map

package/dist/tools/delete-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-node.d.ts","sourceRoot":"","sources":["../../src/tools/delete-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA6BnF"}

package/dist/tools/delete-node.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema } from './schemas';
+export const deleteNodeInput = {
+    id: NodeIdSchema,
+    cascade: z.boolean().optional(),
+};
+export const deleteNodeOutput = {
+    deletedIds: z.array(z.string()),
+};
+export function registerDeleteNode(server, bridge) {
+    server.registerTool('delete_node', {
+        title: 'Delete node',
+        description: 'Delete a node. If it has children, pass `cascade: true` to delete descendants recursively.',
+        inputSchema: deleteNodeInput,
+        outputSchema: deleteNodeOutput,
+    }, async ({ id, cascade }) => {
+        const node = bridge.getNode(id);
+        if (!node) {
+            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${id}`);
+        }
+        try {
+            const removed = bridge.deleteNode(id, cascade ?? false);
+            await publishLiveSceneSnapshot(bridge, 'delete_node');
+            const payload = { deletedIds: removed };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(payload) }],
+                structuredContent: payload,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throwMcpError(ErrorCode.InvalidRequest, msg);
+        }
+    });
+}

package/dist/tools/describe-node.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const describeNodeInput: {
+    id: z.ZodString;
+};
+export declare const describeNodeOutput: {
+    id: z.ZodString;
+    type: z.ZodString;
+    parentId: z.ZodNullable<z.ZodString>;
+    ancestryIds: z.ZodArray<z.ZodString>;
+    childrenIds: z.ZodArray<z.ZodString>;
+    properties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    description: z.ZodString;
+};
+export declare function registerDescribeNode(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=describe-node.d.ts.map

package/dist/tools/describe-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describe-node.d.ts","sourceRoot":"","sources":["../../src/tools/describe-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAExE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,iBAAiB;;CAE7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AA0CD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAwCrF"}

package/dist/tools/describe-node.js

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { NodeIdSchema } from './schemas';
+export const describeNodeInput = {
+    id: NodeIdSchema,
+};
+export const describeNodeOutput = {
+    id: z.string(),
+    type: z.string(),
+    parentId: z.string().nullable(),
+    ancestryIds: z.array(z.string()),
+    childrenIds: z.array(z.string()),
+    properties: z.record(z.string(), z.unknown()),
+    description: z.string(),
+};
+/**
+ * Build a short, human-readable one-liner describing the node.
+ * Covers the common shapes; falls back to a generic sentence otherwise.
+ */
+function describe(node) {
+    switch (node.type) {
+        case 'wall': {
+            const [x1, z1] = node.start;
+            const [x2, z2] = node.end;
+            const t = node.thickness ?? 0.1;
+            const h = node.height ?? 2.5;
+            return `Wall from (${x1},${z1}) to (${x2},${z2}), thickness ${t.toFixed(2)}m, height ${h.toFixed(2)}m`;
+        }
+        case 'level':
+            return `Level ${node.level}`;
+        case 'building': {
+            const [x, y, z] = node.position;
+            return `Building at (${x},${y},${z})`;
+        }
+        case 'site':
+            return `Site with ${node.polygon?.points.length ?? 0}-sided property line`;
+        case 'zone':
+            return `Zone "${node.name}" with ${node.polygon.length} vertices`;
+        case 'slab':
+            return `Slab with ${node.polygon.length} vertices`;
+        case 'ceiling':
+            return `Ceiling with ${node.polygon.length} vertices, height ${node.height.toFixed(2)}m`;
+        case 'door':
+            return `Door (${node.width.toFixed(2)}m x ${node.height.toFixed(2)}m)`;
+        case 'window':
+            return `Window (${node.width.toFixed(2)}m x ${node.height.toFixed(2)}m)`;
+        case 'item': {
+            const [x, y, z] = node.position;
+            return `Item "${node.asset.name}" at (${x},${y},${z})`;
+        }
+        default:
+            return `${node.type} node`;
+    }
+}
+export function registerDescribeNode(server, bridge) {
+    server.registerTool('describe_node', {
+        title: 'Describe node',
+        description: 'Return a structured summary of a node including its ancestry, children IDs, key properties, and a short human description.',
+        inputSchema: describeNodeInput,
+        outputSchema: describeNodeOutput,
+    }, async ({ id }) => {
+        const node = bridge.getNode(id);
+        if (!node) {
+            throwMcpError(ErrorCode.InvalidParams, `Node not found: ${id}`);
+        }
+        // Ancestry minus self.
+        const ancestry = bridge.getAncestry(id);
+        const ancestryIds = ancestry.slice(1).map((n) => n.id);
+        const children = bridge.getChildren(id);
+        const childrenIds = children.map((n) => n.id);
+        const n = node;
+        const payload = {
+            id: n.id,
+            type: n.type,
+            parentId: (n.parentId ?? null),
+            ancestryIds,
+            childrenIds,
+            properties: n,
+            description: describe(n),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/duplicate-level.d.ts

@@ -0,0 +1,12 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const duplicateLevelInput: {
+    levelId: z.ZodString;
+};
+export declare const duplicateLevelOutput: {
+    newLevelId: z.ZodString;
+    newNodeIds: z.ZodArray<z.ZodString>;
+};
+export declare function registerDuplicateLevel(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=duplicate-level.d.ts.map

package/dist/tools/duplicate-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-level.d.ts","sourceRoot":"","sources":["../../src/tools/duplicate-level.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD,eAAO,MAAM,mBAAmB;;CAE/B,CAAA;AAED,eAAO,MAAM,oBAAoB;;;CAGhC,CAAA;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsDvF"}

package/dist/tools/duplicate-level.js

@@ -0,0 +1,56 @@
+import { cloneLevelSubtree } from '@pascal-app/core/clone-scene-graph';
+import { z } from 'zod';
+import { ErrorCode, throwMcpError } from './errors';
+import { publishLiveSceneSnapshot } from './live-sync';
+import { NodeIdSchema } from './schemas';
+export const duplicateLevelInput = {
+    levelId: NodeIdSchema,
+};
+export const duplicateLevelOutput = {
+    newLevelId: z.string(),
+    newNodeIds: z.array(z.string()),
+};
+export function registerDuplicateLevel(server, bridge) {
+    server.registerTool('duplicate_level', {
+        title: 'Duplicate level',
+        description: 'Clone a level and all its descendants into a new subtree attached to the same building.',
+        inputSchema: duplicateLevelInput,
+        outputSchema: duplicateLevelOutput,
+    }, async ({ levelId }) => {
+        const node = bridge.getNode(levelId);
+        if (!node) {
+            throwMcpError(ErrorCode.InvalidParams, `Level not found: ${levelId}`);
+        }
+        if (node.type !== 'level') {
+            throwMcpError(ErrorCode.InvalidParams, `Node ${levelId} is a ${node.type}, expected level`);
+        }
+        // cloneLevelSubtree(nodes, levelId) — returns { clonedNodes, newLevelId, idMap }.
+        const { clonedNodes, newLevelId } = cloneLevelSubtree(bridge.getNodes(), levelId);
+        const buildingId = node.parentId ?? undefined;
+        // Flatten cloned subtree into create patches. The level node itself
+        // attaches to the original building; descendants attach to their
+        // already-remapped parent (encoded in `parentId`).
+        const patches = clonedNodes.map((n) => {
+            const isRoot = n.id === newLevelId;
+            const parentIdForBridge = isRoot
+                ? buildingId
+                : (n.parentId ?? undefined);
+            const createOp = {
+                op: 'create',
+                node: n,
+                ...(parentIdForBridge !== undefined ? { parentId: parentIdForBridge } : {}),
+            };
+            return createOp;
+        });
+        const result = bridge.applyPatch(patches);
+        await publishLiveSceneSnapshot(bridge, 'duplicate_level');
+        const payload = {
+            newLevelId: newLevelId,
+            newNodeIds: result.createdIds,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/errors.d.ts

@@ -0,0 +1,20 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Throw a structured MCP error. The SDK translates `McpError` into a
+ * JSON-RPC error response automatically.
+ */
+export declare function throwMcpError(code: ErrorCode, message: string, data?: unknown): never;
+/**
+ * Return a non-throwing tool error payload — used for structured failures that
+ * we want the client to see inline in `content` rather than as a protocol
+ * error. Sets `isError: true` so SDK clients treat it as a failure.
+ */
+export declare function toolError(message: string, data?: Record<string, unknown>): {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError: true;
+};
+export { ErrorCode, McpError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/tools/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/tools/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAExE;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAErF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,EAAE,IAAI,CAAA;CACd,CAUA;AAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/errors.js

@@ -0,0 +1,25 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Throw a structured MCP error. The SDK translates `McpError` into a
+ * JSON-RPC error response automatically.
+ */
+export function throwMcpError(code, message, data) {
+    throw new McpError(code, message, data);
+}
+/**
+ * Return a non-throwing tool error payload — used for structured failures that
+ * we want the client to see inline in `content` rather than as a protocol
+ * error. Sets `isError: true` so SDK clients treat it as a failure.
+ */
+export function toolError(message, data) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({ error: message, ...(data ?? {}) }),
+            },
+        ],
+        isError: true,
+    };
+}
+export { ErrorCode, McpError };

package/dist/tools/export-glb.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const exportGlbInput: {};
+export declare const exportGlbOutput: {
+    status: z.ZodLiteral<"not_implemented">;
+    reason: z.ZodString;
+};
+export declare function registerExportGlb(server: McpServer, _bridge: SceneOperations): void;
+//# sourceMappingURL=export-glb.d.ts.map

package/dist/tools/export-glb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-glb.d.ts","sourceRoot":"","sources":["../../src/tools/export-glb.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,cAAc,IAAK,CAAA;AAEhC,eAAO,MAAM,eAAe;;;CAG3B,CAAA;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAsBnF"}

package/dist/tools/export-glb.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const exportGlbInput = {};
+export const exportGlbOutput = {
+    status: z.literal('not_implemented'),
+    reason: z.string(),
+};
+export function registerExportGlb(server, _bridge) {
+    server.registerTool('export_glb', {
+        title: 'Export GLB',
+        description: 'GLB export is not available in headless mode — it requires the Three.js renderer, which is browser-only. Returns a structured `not_implemented` response.',
+        inputSchema: exportGlbInput,
+        outputSchema: exportGlbOutput,
+    }, async () => {
+        const payload = {
+            status: 'not_implemented',
+            reason: 'GLB export requires the Three.js renderer, which is browser-only',
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+            isError: false,
+        };
+    });
+}

package/dist/tools/export-json.d.ts

@@ -0,0 +1,11 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const exportJsonInput: {
+    pretty: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const exportJsonOutput: {
+    json: z.ZodString;
+};
+export declare function registerExportJson(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=export-json.d.ts.map

package/dist/tools/export-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-json.d.ts","sourceRoot":"","sources":["../../src/tools/export-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;CAE5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAoBnF"}

package/dist/tools/export-json.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export const exportJsonInput = {
+    pretty: z.boolean().optional(),
+};
+export const exportJsonOutput = {
+    json: z.string(),
+};
+export function registerExportJson(server, bridge) {
+    server.registerTool('export_json', {
+        title: 'Export JSON',
+        description: 'Return the scene as a serialized JSON string. Pass `pretty: true` to indent with 2 spaces.',
+        inputSchema: exportJsonInput,
+        outputSchema: exportJsonOutput,
+    }, async ({ pretty }) => {
+        const scene = bridge.exportJSON();
+        const json = JSON.stringify(scene, null, pretty ? 2 : 0);
+        const payload = { json };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

package/dist/tools/find-nodes.d.ts

@@ -0,0 +1,32 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import type { SceneOperations } from '../operations';
+export declare const findNodesInput: {
+    type: z.ZodOptional<z.ZodEnum<{
+        site: "site";
+        building: "building";
+        item: "item";
+        level: "level";
+        wall: "wall";
+        fence: "fence";
+        zone: "zone";
+        slab: "slab";
+        stair: "stair";
+        ceiling: "ceiling";
+        roof: "roof";
+        "roof-segment": "roof-segment";
+        "stair-segment": "stair-segment";
+        scan: "scan";
+        guide: "guide";
+        window: "window";
+        door: "door";
+    }>>;
+    parentId: z.ZodOptional<z.ZodString>;
+    levelId: z.ZodOptional<z.ZodString>;
+    zoneId: z.ZodOptional<z.ZodString>;
+};
+export declare const findNodesOutput: {
+    nodes: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+};
+export declare function registerFindNodes(server: McpServer, bridge: SceneOperations): void;
+//# sourceMappingURL=find-nodes.d.ts.map

package/dist/tools/find-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-nodes.d.ts","sourceRoot":"","sources":["../../src/tools/find-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAuBpD,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAK1B,CAAA;AAED,eAAO,MAAM,eAAe;;CAE3B,CAAA;AAkCD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuDlF"}

package/dist/tools/find-nodes.js

@@ -0,0 +1,105 @@
+import { pointInPolygon } from '@pascal-app/core/spatial-grid';
+import { z } from 'zod';
+import { NodeIdSchema } from './schemas';
+const ALL_NODE_TYPES = [
+    'site',
+    'building',
+    'level',
+    'wall',
+    'fence',
+    'zone',
+    'slab',
+    'ceiling',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+    'item',
+    'door',
+    'window',
+    'scan',
+    'guide',
+];
+export const findNodesInput = {
+    type: z.enum(ALL_NODE_TYPES).optional(),
+    parentId: NodeIdSchema.optional(),
+    levelId: NodeIdSchema.optional(),
+    zoneId: NodeIdSchema.optional(),
+};
+export const findNodesOutput = {
+    nodes: z.array(z.record(z.string(), z.unknown())),
+};
+/** Compute a representative 2D point (x, z) for zone-filtering. */
+function getPointForZoneFilter(node) {
+    if (node.type === 'wall' || node.type === 'fence') {
+        const [x1, z1] = node.start;
+        const [x2, z2] = node.end;
+        return [(x1 + x2) / 2, (z1 + z2) / 2];
+    }
+    if (node.type === 'item' ||
+        node.type === 'door' ||
+        node.type === 'window' ||
+        node.type === 'building' ||
+        node.type === 'stair' ||
+        node.type === 'roof') {
+        const [x, , z] = node.position;
+        return [x, z];
+    }
+    if (node.type === 'slab' || node.type === 'ceiling' || node.type === 'zone') {
+        const poly = node.polygon;
+        if (!poly || poly.length === 0)
+            return null;
+        let cx = 0;
+        let cz = 0;
+        for (const [x, z] of poly) {
+            cx += x;
+            cz += z;
+        }
+        return [cx / poly.length, cz / poly.length];
+    }
+    return null;
+}
+export function registerFindNodes(server, bridge) {
+    server.registerTool('find_nodes', {
+        title: 'Find nodes',
+        description: 'Find nodes matching any combination of type, parentId, levelId, or zoneId filters.',
+        inputSchema: findNodesInput,
+        outputSchema: findNodesOutput,
+    }, async (args) => {
+        const { type, parentId, levelId, zoneId } = args;
+        // Delegate type/parent/level filtering to the bridge.
+        const baseFilter = {};
+        if (type !== undefined)
+            baseFilter.type = type;
+        if (parentId !== undefined)
+            baseFilter.parentId = parentId;
+        if (levelId !== undefined)
+            baseFilter.levelId = levelId;
+        let results = bridge.findNodes(baseFilter);
+        // Zone-polygon filter: point-in-polygon on a representative 2D point.
+        if (zoneId) {
+            const zone = bridge.getNode(zoneId);
+            if (!zone || zone.type !== 'zone') {
+                // Unknown zoneId → return empty list rather than throw; matches
+                // typical "filter" semantics.
+                results = [];
+            }
+            else {
+                const poly = zone.polygon;
+                results = results.filter((n) => {
+                    const pt = getPointForZoneFilter(n);
+                    if (!pt)
+                        return false;
+                    return pointInPolygon(pt[0], pt[1], poly);
+                });
+            }
+        }
+        const payload = {
+            nodes: results,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}