@pascal-app/core 1.0.3 → 1.0.4

package/dist/agent-operations/__fixtures__/room-cases.js

@@ -0,0 +1,338 @@
+import { createZone, cutFloorOpening, divideZone, structureChangeBatch } from '../../commands/structure/index.js';
+import { reconcileSceneStructure } from '../../lib/structure-reconcile.js';
+import { BuildingNode, ItemNode, LevelNode } from '../../schema/index.js';
+import { applySceneChanges } from '../apply-changes.js';
+function kitchenScene({ divided, hatch, lamp } = {}) {
+    const names = {
+        wall: ['wall_south', 'wall_east', 'wall_north', 'wall_west'],
+        zone: ['zone_kitchen', 'zone_pantry'],
+        ceiling: ['ceiling_kitchen', 'ceiling_pantry'],
+        separator: ['separator_a', 'separator_b'],
+        'floor-opening': ['floor-opening_hatch'],
+    };
+    const mintId = (kind) => names[kind]?.shift() ?? `${kind}_fixture`;
+    const building = BuildingNode.parse({ id: 'building_rooms', children: ['level_rooms'] });
+    const level = LevelNode.parse({ id: 'level_rooms', parentId: building.id, level: 0, height: 3 });
+    let nodes = { [building.id]: building, [level.id]: level };
+    const apply = (plan) => {
+        nodes = applySceneChanges(nodes, structureChangeBatch(plan.changes));
+        nodes = { ...reconcileSceneStructure({ nodes, mintId }).nodes };
+    };
+    apply(createZone(nodes, {
+        levelId: level.id,
+        name: 'Kitchen',
+        polygon: [
+            [0, 0],
+            [8, 0],
+            [8, 4],
+            [0, 4],
+        ],
+        enclose: true,
+        mintId,
+    }));
+    if (divided)
+        apply(divideZone(nodes, {
+            zoneId: 'zone_kitchen',
+            path: [
+                [3, 0],
+                [3, 1],
+                [8, 1],
+            ],
+            mintId,
+        }));
+    if (hatch)
+        apply(cutFloorOpening(nodes, {
+            zoneId: 'zone_kitchen',
+            rect: { x: 1, z: 2, width: 1, depth: 1 },
+            mintId,
+        }));
+    if (lamp) {
+        const item = ItemNode.parse({
+            id: 'item_lamp',
+            parentId: 'ceiling_kitchen',
+            position: [4, -0.1, 2],
+            asset: {
+                id: 'lamp',
+                category: 'lighting',
+                name: 'Lamp',
+                thumbnail: '/items/lamp/thumbnail.webp',
+                src: '/items/lamp/model.glb',
+                dimensions: [1, 1, 1],
+                attachTo: 'ceiling',
+            },
+        });
+        nodes = applySceneChanges(nodes, { create: [{ node: item, parentId: 'ceiling_kitchen' }] });
+    }
+    return { nodes, rootNodeIds: [building.id] };
+}
+/** The kitchen's floor plate: the reconciler names it from its footprint. */
+const plateId = Object.values(kitchenScene().nodes).find((node) => node.type === 'slab' && node.plateRole === 'base').id;
+/** The scene holds this many nodes of each type: rooms and separators the call minted. */
+const holds = (expected) => (_result, nodes) => Object.entries(expected).flatMap(([type, count]) => {
+    const found = Object.values(nodes).filter((node) => node.type === type).length;
+    return found === count ? [] : [`${count} ${type} expected, ${found} found`];
+});
+export const ROOM_CASES = [
+    {
+        name: 'divides an open plan with a path; the seed side keeps its id',
+        tool: 'divide_zone',
+        scene: kitchenScene,
+        input: {
+            zoneId: 'zone_kitchen',
+            path: [
+                [3, 0],
+                [3, 1],
+                [8, 1],
+            ],
+        },
+        expect: {
+            result: { changes: 2 },
+            after: {
+                zone_kitchen: {
+                    polygon: [
+                        [0, 0],
+                        [3, 0],
+                        [3, 1],
+                        [8, 1],
+                        [8, 4],
+                        [0, 4],
+                    ],
+                },
+            },
+            check: (result, nodes) => [
+                ...holds({ zone: 2, separator: 2, ceiling: 2 })(result, nodes),
+                ...(result.zoneIds?.length === 2 &&
+                    result.zoneIds.includes('zone_kitchen')
+                    ? []
+                    : ['zoneIds lists both rooms']),
+                ...(result.separatorIds?.length === 2
+                    ? []
+                    : ['separatorIds lists both separators']),
+            ],
+        },
+    },
+    {
+        name: 'an island too small to be a room is a conflict, and nothing changes',
+        tool: 'divide_zone',
+        scene: kitchenScene,
+        input: {
+            zoneId: 'zone_kitchen',
+            closed: true,
+            path: [
+                [3, 1],
+                [3.2, 1],
+                [3.2, 1.2],
+                [3, 1.2],
+            ],
+        },
+        expect: {
+            result: { changes: 0, separatorIds: [] },
+            contains: { conflicts: [{ code: 'small-island' }] },
+            check: holds({ zone: 1, separator: 0 }),
+        },
+    },
+    {
+        name: 'a room that does not exist is refused',
+        tool: 'divide_zone',
+        scene: kitchenScene,
+        input: {
+            zoneId: 'zone_missing',
+            path: [
+                [3, 0],
+                [3, 4],
+            ],
+        },
+        expect: { refusal: 'structure_refused', mentions: ['zone_missing'] },
+    },
+    {
+        name: 'merges two rooms by removing the separators between them',
+        tool: 'merge_zones',
+        scene: () => kitchenScene({ divided: true }),
+        input: { zoneIds: ['zone_kitchen', 'zone_pantry'] },
+        expect: {
+            result: { changes: 2 },
+            absent: ['separator_a', 'separator_b'],
+            check: holds({ zone: 1, ceiling: 1 }),
+        },
+    },
+    {
+        name: 'deletes a room with the walls only it uses',
+        tool: 'delete_zone',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', contents: 'keep' },
+        expect: {
+            result: { payload: { zoneId: 'zone_kitchen', mode: 'delete', contents: 'keep' } },
+            absent: ['zone_kitchen', 'wall_south', 'wall_east', 'wall_north', 'wall_west'],
+            check: holds({ zone: 0, ceiling: 0 }),
+        },
+    },
+    {
+        name: 'a room Divide made merges back into its neighbour',
+        tool: 'delete_zone',
+        scene: () => kitchenScene({ divided: true }),
+        input: { zoneId: 'zone_pantry', contents: 'delete' },
+        expect: {
+            result: {
+                payload: { zoneId: 'zone_pantry', mode: 'merge', mergedIntoZoneId: 'zone_kitchen' },
+            },
+            present: ['zone_kitchen', 'wall_south'],
+            absent: ['zone_pantry', 'separator_a', 'separator_b'],
+            check: holds({ zone: 1 }),
+        },
+    },
+    {
+        name: 'renames a room and sets its floor finish',
+        tool: 'set_zone_intent',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', patch: { name: 'Studio', floor: { finish: 'wood' } } },
+        expect: {
+            result: { changes: 1 },
+            after: { zone_kitchen: { name: 'Studio', floor: { finish: 'wood' } } },
+        },
+    },
+    {
+        name: 'a floor key no room has is a conflict that says what to choose',
+        tool: 'set_zone_intent',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', patch: { floor: { footprint: 'missing-floor' } } },
+        expect: {
+            result: { changes: 0 },
+            contains: { conflicts: [{ code: 'room-floor-footprint' }] },
+            mentions: ['Choose an existing floor key'],
+            after: { zone_kitchen: { name: 'Kitchen' } },
+        },
+    },
+    {
+        name: 'moves a room with its walls',
+        tool: 'move_zone',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', translate: [10, 0] },
+        expect: {
+            result: { zoneId: 'zone_kitchen', idMap: { zone_kitchen: ['zone_kitchen'] } },
+            after: { zone_kitchen: { seed: [14, 2] }, wall_south: { start: [10, 0], end: [18, 0] } },
+            check: holds({ zone: 1, wall: 4 }),
+        },
+    },
+    {
+        name: 'duplicates a room, its ceiling lamp hung on the copy’s ceiling',
+        tool: 'duplicate_zone',
+        scene: () => kitchenScene({ lamp: true }),
+        input: { zoneId: 'zone_kitchen', translate: [10, 0] },
+        expect: {
+            result: {},
+            after: { zone_kitchen: { seed: [4, 2] }, item_lamp: { parentId: 'ceiling_kitchen' } },
+            check: (result, nodes) => {
+                const copy = nodes[result.idMap.item_lamp?.[0] ?? ''];
+                const ceiling = copy?.parentId ? nodes[copy.parentId] : undefined;
+                return [
+                    ...holds({ zone: 2, wall: 8, ceiling: 2, item: 2 })(result, nodes),
+                    ...(ceiling?.type === 'ceiling' && ceiling.zoneId === result.zoneId
+                        ? []
+                        : ['the copied lamp hangs on the copy’s ceiling']),
+                ];
+            },
+        },
+    },
+    {
+        name: 'turns a room a quarter about its centre, snapped to the grid',
+        tool: 'rotate_zone',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', quarterTurns: 1 },
+        expect: {
+            result: { zoneId: 'zone_kitchen' },
+            after: { wall_south: { start: [2, 6], end: [2, -2] } },
+            check: holds({ zone: 1, wall: 4 }),
+        },
+    },
+    {
+        name: 'puts the outside faces of a level on their reference lines',
+        tool: 'lock_outside_faces',
+        scene: kitchenScene,
+        input: { levelId: 'level_rooms' },
+        expect: {
+            result: {},
+            after: {
+                wall_south: { justification: 'a' },
+                wall_east: { justification: 'a' },
+                wall_north: { justification: 'a' },
+                wall_west: { justification: 'a' },
+            },
+        },
+    },
+    {
+        name: 'a level and rooms together are refused',
+        tool: 'lock_outside_faces',
+        scene: kitchenScene,
+        input: { levelId: 'level_rooms', zoneIds: ['zone_kitchen'] },
+        expect: { refusal: 'target_required', mentions: ['levelId or zoneIds'] },
+    },
+    {
+        name: 'cuts a floor opening in a room',
+        tool: 'cut_floor_opening',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', rect: { x: 2, z: 2, width: 1, depth: 1 } },
+        expect: {
+            result: { hints: [] },
+            check: (result, nodes) => [
+                ...holds({ 'floor-opening': 1 })(result, nodes),
+                ...(nodes[result.openingIds?.[0] ?? '']?.type === 'floor-opening'
+                    ? []
+                    : ['openingIds names the opening']),
+            ],
+        },
+    },
+    {
+        name: 'removes a floor opening',
+        tool: 'remove_floor_opening',
+        scene: () => kitchenScene({ hatch: true }),
+        input: { id: 'floor-opening_hatch' },
+        expect: {
+            result: { openingId: 'floor-opening_hatch' },
+            absent: ['floor-opening_hatch'],
+            check: holds({ 'floor-opening': 0 }),
+        },
+    },
+    {
+        name: 'raises a ground floor on a foundation',
+        tool: 'set_floor_foundation',
+        scene: kitchenScene,
+        input: { slabId: plateId, patch: { foundationHeight: 0.5 } },
+        expect: { result: {}, after: { [plateId]: { foundation: { type: 'solid' } } } },
+    },
+    {
+        name: 'a plate that does not exist is refused',
+        tool: 'set_floor_foundation',
+        scene: kitchenScene,
+        input: { slabId: 'slab_missing', patch: { foundationHeight: 0.5 } },
+        expect: { refusal: 'structure_refused', mentions: ['slab_missing'] },
+    },
+    {
+        name: 'thickens the slab a room stands on',
+        tool: 'set_room_floor_construction',
+        scene: kitchenScene,
+        input: { zoneId: 'zone_kitchen', patch: { thickness: 0.3 } },
+        expect: { result: {}, after: { [plateId]: { thickness: 0.3 } } },
+    },
+    {
+        name: 'sets a footprint reference datum',
+        tool: 'rebase_floor_reference',
+        scene: kitchenScene,
+        input: { slabId: plateId, referenceFloorElevation: 0.2 },
+        expect: { result: {}, after: { [plateId]: { referenceFloorElevation: 0.2 } } },
+    },
+    {
+        name: 'adds a mezzanine over part of a room',
+        tool: 'create_mezzanine',
+        scene: kitchenScene,
+        input: {
+            hostZoneId: 'zone_kitchen',
+            polygon: [
+                [0, 0],
+                [3, 0],
+                [3, 4],
+                [0, 4],
+            ],
+        },
+        expect: { result: {}, check: holds({ zone: 2 }) },
+    },
+];

package/dist/agent-operations/__fixtures__/search-assets-cases.d.ts

@@ -0,0 +1,5 @@
+import type { AssetInput } from '../../schema/index.js';
+import type { AgentToolCase } from './cases.js';
+export declare const LIBRARY: AssetInput[];
+export declare const SEARCH_ASSETS_CASES: AgentToolCase[];
+//# sourceMappingURL=search-assets-cases.d.ts.map

package/dist/agent-operations/__fixtures__/search-assets-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-assets-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/search-assets-cases.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAc,MAAM,SAAS,CAAA;AA2BxD,eAAO,MAAM,OAAO,EAAE,UAAU,EAM/B,CAAA;AAKD,eAAO,MAAM,mBAAmB,EAAE,aAAa,EA+G9C,CAAA"}

package/dist/agent-operations/__fixtures__/search-assets-cases.js

@@ -0,0 +1,137 @@
+/**
+ * `search_assets`: the host's item library, several queries in one call. The chat searched its
+ * library in batches; the MCP searched one query, on id and tags too, with a category filter, and
+ * mixed in design presets placed with place_design, a tool the chat lacks. One search now: batched,
+ * id and tags matched, category per query, library items only, and a miss points to add_object.
+ */
+const item = (id, name, category, tags, dimensions, attachTo) => ({
+    id,
+    name,
+    category,
+    tags,
+    thumbnail: `/items/${id}/thumbnail.webp`,
+    src: `/items/${id}/model.glb`,
+    ...(dimensions ? { dimensions } : {}),
+    ...(attachTo ? { attachTo } : {}),
+});
+export const LIBRARY = [
+    item('sofa', 'Sofa', 'furniture', ['seating', 'living'], [2.5, 0.8, 1.5]),
+    item('dining-chair', 'Dining Chair', 'furniture', ['seating', 'dining'], [0.5, 1, 0.5]),
+    item('garden-chair', 'Garden Chair', 'outdoor', ['seating', 'garden'], [0.6, 0.9, 0.6]),
+    item('palm', 'Palm', 'outdoor', ['tree', 'plant', 'garden'], [1.5, 3, 1.5]),
+    item('picture', 'Picture', 'decor', ['art'], undefined, 'wall-side'),
+];
+const noScene = () => ({ nodes: {}, rootNodeIds: [] });
+const library = { activeLevelId: null, catalog: LIBRARY };
+export const SEARCH_ASSETS_CASES = [
+    {
+        name: 'one group per query, in order, on the name, category or tags',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'sofa' }, { query: 'plant' }] },
+        context: library,
+        expect: {
+            result: {
+                total: 2,
+                groups: [
+                    {
+                        query: 'sofa',
+                        total: 1,
+                        results: [
+                            {
+                                id: 'sofa',
+                                name: 'Sofa',
+                                category: 'furniture',
+                                dimensions: [2.5, 0.8, 1.5],
+                                attachTo: null,
+                            },
+                        ],
+                    },
+                    { query: 'plant', total: 1, results: [{ id: 'palm', category: 'outdoor' }] },
+                ],
+            },
+        },
+    },
+    {
+        name: 'every word of a query must match',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'dining chair' }, { query: 'Garden  SEATING' }] },
+        context: library,
+        expect: {
+            result: {
+                groups: [
+                    { total: 1, results: [{ id: 'dining-chair' }] },
+                    { total: 1, results: [{ id: 'garden-chair' }] },
+                ],
+            },
+        },
+    },
+    {
+        name: 'an id finds its item',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'dining-chair' }] },
+        context: library,
+        expect: { result: { groups: [{ total: 1, results: [{ id: 'dining-chair' }] }] } },
+    },
+    {
+        name: 'a category narrows a query',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'chair', category: 'outdoor' }] },
+        context: library,
+        expect: { result: { total: 1, groups: [{ total: 1, results: [{ id: 'garden-chair' }] }] } },
+    },
+    {
+        name: 'a wall item says where it mounts, and an item without dimensions reads 1 m a side',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'art' }] },
+        context: library,
+        expect: {
+            result: {
+                groups: [
+                    { results: [{ id: 'picture', attachTo: 'wall-side', dimensions: [1, 1, 1] }] },
+                ],
+            },
+        },
+    },
+    {
+        name: 'a fixture the library lacks points to add_object, not to a design of its own',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'wall light' }] },
+        context: library,
+        expect: {
+            result: {
+                total: 0,
+                groups: [{ query: 'wall light', total: 0, results: [] }],
+                hint: 'Nothing in the library matches "wall light". Build what it lacks with add_object.',
+            },
+        },
+    },
+    {
+        name: 'the hint names only the queries that found nothing',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'sofa' }, { query: 'gazebo' }, { query: 'sconce' }] },
+        context: library,
+        expect: {
+            result: {
+                total: 1,
+                groups: [{ total: 1 }, { query: 'gazebo', total: 0 }, { query: 'sconce', total: 0 }],
+                hint: 'Nothing in the library matches "gazebo", "sconce". Build what it lacks with add_object.',
+            },
+        },
+    },
+    {
+        // The MCP always has one (its built-in list when the host passes none).
+        name: 'a host without a catalog is refused rather than answered with nothing',
+        tool: 'search_assets',
+        scene: noScene,
+        input: { queries: [{ query: 'sofa' }] },
+        surfaces: ['core', 'chat'],
+        expect: { refusal: 'no_catalog' },
+    },
+];

package/dist/agent-operations/__fixtures__/structure-cases.d.ts

@@ -0,0 +1,6 @@
+import type { AgentToolCase, SceneGraph } from './cases.js';
+export declare function storeysScene(): SceneGraph;
+export declare const ADD_WALL_CASES: AgentToolCase[];
+export declare const ADD_LEVEL_CASES: AgentToolCase[];
+export declare const CREATE_STAIR_CASES: AgentToolCase[];
+//# sourceMappingURL=structure-cases.d.ts.map

package/dist/agent-operations/__fixtures__/structure-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structure-cases.d.ts","sourceRoot":"","sources":["../../../src/agent-operations/__fixtures__/structure-cases.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AA2BxD,wBAAgB,YAAY,IAAI,UAAU,CAkDzC;AAiBD,eAAO,MAAM,cAAc,EAAE,aAAa,EAkEzC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EA+F1C,CAAA;AAiFD,eAAO,MAAM,kBAAkB,EAAE,aAAa,EAiS7C,CAAA"}