@sealab/mcp-server 1.0.2 → 1.0.3

package/src/tools/ai-drawing-session-review-renderer.test.ts

@@ -0,0 +1,516 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { PNG } from 'pngjs';
+import { afterEach, describe, expect, it } from 'vitest';
+import {
+  renderAiDrawingSessionReview,
+  type AiDrawingSessionReviewIssueCode,
+} from './ai-drawing-session-review-renderer';
+
+const sessionId = '11111111-1111-4111-8111-111111111111';
+const cartItemId = '22222222-2222-4222-8222-222222222222';
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const tempDir of tempDirs.splice(0)) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+describe('AI drawing session review renderer', () => {
+  it('renders a simple local PNG background with one placement box and label', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({
+          centerX: 60,
+          centerY: 45,
+          width: 40,
+          height: 20,
+          basisImageWidthPx: 120,
+          basisImageHeightPx: 90,
+        })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    const canvas = manifest.canvases[0];
+    expect(canvas).toMatchObject({
+      canvasType: 'plan',
+      imageWidth: 120,
+      imageHeight: 90,
+      renderedPlacementCount: 1,
+      sourceBoundaryReviewTasks: [
+        expect.objectContaining({
+          canvasType: 'plan',
+          positionName: 'BASE_01',
+          placementCategory: 'plan_footprint',
+          sourceImageAuthority: true,
+          checklist: expect.arrayContaining([
+            expect.stringContaining('full source plan image'),
+            expect.stringContaining('actual cabinet/appliance footprint linework'),
+          ]),
+        }),
+      ],
+      issues: [
+        expect.objectContaining({
+          code: 'source_boundary_review_required',
+          severity: 'error',
+          canvasType: 'plan',
+          positionName: 'BASE_01',
+        }),
+      ],
+    });
+    expect(canvas.outputImagePath).toBeTruthy();
+    expect(fs.existsSync(canvas.outputImagePath!)).toBe(true);
+    expect(canvas).not.toHaveProperty('placementReviewCrops');
+    expect(fs.existsSync(path.join(tempDir, 'placement-review-crops'))).toBe(false);
+
+    const rendered = PNG.sync.read(fs.readFileSync(canvas.outputImagePath!));
+    expect(rendered.width).toBe(120);
+    expect(rendered.height).toBe(90);
+    expect(pixelAt(rendered, 40, 35)).toMatchObject({ r: expect.any(Number), g: expect.any(Number), b: expect.any(Number) });
+    expect(pixelAt(rendered, 40, 35)).not.toEqual(pixelAt(rendered, 10, 10));
+  });
+
+  it('reports placement outside image bounds while still rendering it', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({ centerX: 95, centerY: 40, width: 30, height: 20 })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('placement_outside_image_bounds');
+    expect(manifest.canvases[0].renderedPlacementCount).toBe(1);
+  });
+
+  it('reports invalid dimensions and skips the invalid placement', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({ width: 0 })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('invalid_placement_dimensions');
+    expect(manifest.canvases[0].renderedPlacementCount).toBe(0);
+  });
+
+  it('reports missing basis image dimensions but renders when geometry is otherwise valid', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({ basisImageWidthPx: undefined, basisImageHeightPx: undefined })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('missing_or_invalid_basis_image_dimensions');
+    expect(manifest.canvases[0].renderedPlacementCount).toBe(1);
+  });
+
+  it('reports placement without matching cart item', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({ aiCartItemId: '33333333-3333-4333-8333-333333333333', positionName: 'UNKNOWN' })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('placement_without_matching_cart_item');
+  });
+
+  it('reports cart item without placement', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        cartItems: [
+          cartItem(),
+          cartItem({
+            id: '33333333-3333-4333-8333-333333333333',
+            positionName: 'UNPLACED',
+          }),
+        ],
+        placements: [placement()],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('cart_item_without_placement');
+  });
+
+  it('reports duplicate positionName on the same canvas', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [
+          placement({ centerX: 40, positionName: 'BASE_01' }),
+          placement({ centerX: 80, positionName: 'BASE_01' }),
+        ],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('duplicate_position_name_on_canvas');
+    expect(manifest.canvases[0].renderedPlacementCount).toBe(2);
+  });
+
+  it('reports overlapping placement rectangles on the same canvas', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        cartItems: [
+          cartItem({ id: cartItemId, positionName: 'BASE_01' }),
+          cartItem({ id: '33333333-3333-4333-8333-333333333333', positionName: 'BASE_02' }),
+        ],
+        placements: [
+          placement({ centerX: 50, width: 40, positionName: 'BASE_01', aiCartItemId: cartItemId }),
+          placement({
+            centerX: 65,
+            width: 40,
+            positionName: 'BASE_02',
+            aiCartItemId: '33333333-3333-4333-8333-333333333333',
+          }),
+        ],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('placement_overlap');
+    expect(manifest.issues.find((issue) => issue.code === 'placement_overlap')).toMatchObject({
+      canvasType: 'plan',
+      positionName: 'BASE_01',
+      relatedPositionName: 'BASE_02',
+    });
+  });
+
+  it('does not classify base cabinets as plinths just because evidence mentions excluded plinths', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'east.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('east', backgroundPath)],
+        cartItems: [
+          cartItem({
+            serialNumber: 'BC_1D1DR_L_1762',
+            positionName: 'CEB1',
+            displayName: 'Base cabinet with plinth excluded',
+            originalItemPayload: JSON.stringify({
+              __aiDrawingClassificationEvidence: {
+                sourceElevationObject: { objectType: 'base_cabinet' },
+                baseCabinetBodyHeightEvidence: {
+                  plinthDecision: 'separate_plinth_item_created',
+                  excludedElements: ['toekick_plinth', 'countertop'],
+                  evidence: 'Plinth/toekick excluded from base cabinet body.',
+                },
+              },
+            }),
+          }),
+        ],
+        placements: [placement({
+          canvasType: 'east',
+          positionName: 'CEB1',
+        })],
+      }),
+      { outputDir: tempDir, canvases: ['east'] }
+    );
+
+    expect(issueCodes(manifest)).not.toContain('placement_category_conflict');
+    expect(issueCodes(manifest)).toContain('source_boundary_review_required');
+    expect(manifest.canvases[0].sourceBoundaryReviewTasks).toEqual([
+      expect.objectContaining({
+        canvasType: 'east',
+        positionName: 'CEB1',
+        placementCategory: 'base_cabinet_body',
+        sourceImageAuthority: true,
+        checklist: expect.arrayContaining([
+          expect.stringContaining('Verify against the full source image'),
+          expect.stringContaining('visible transition from cabinet/front/carcass body to the separate toekick/plinth band'),
+          expect.stringContaining('exclude any visible countertop'),
+        ]),
+      }),
+    ]);
+    const rendered = PNG.sync.read(fs.readFileSync(manifest.canvases[0].outputImagePath!));
+    const topEdgePixel = pixelAt(rendered, 60, 34);
+    expect(topEdgePixel.b).toBeGreaterThan(topEdgePixel.r);
+  });
+
+  it('requires source-image boundary review for UC_E_B base cabinet labels from drawings', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'east.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('east', backgroundPath)],
+        cartItems: [
+          cartItem({
+            serialNumber: 'UC_E_B30S',
+            positionName: 'UC_E_B30S',
+            displayName: 'UC_E_B30S',
+          }),
+        ],
+        placements: [placement({
+          canvasType: 'east',
+          positionName: 'UC_E_B30S',
+        })],
+      }),
+      { outputDir: tempDir, canvases: ['east'] }
+    );
+
+    expect(manifest.canvases[0].sourceBoundaryReviewTasks).toEqual([
+      expect.objectContaining({
+        positionName: 'UC_E_B30S',
+        placementCategory: 'base_cabinet_body',
+        sourceImageAuthority: true,
+      }),
+    ]);
+    expect(issueCodes(manifest)).toContain('source_boundary_review_required');
+  });
+
+  it('classifies explicit plinth catalog placements as plinths', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'east.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('east', backgroundPath)],
+        cartItems: [
+          cartItem({
+            serialNumber: 'LP_PL_1571',
+            positionName: 'CEPL',
+            displayName: 'Continuous plinth/toekick',
+          }),
+        ],
+        placements: [placement({
+          canvasType: 'east',
+          positionName: 'CEPL',
+        })],
+      }),
+      { outputDir: tempDir, canvases: ['east'] }
+    );
+
+    expect(manifest.canvases[0].sourceBoundaryReviewTasks).toEqual([
+      expect.objectContaining({
+        canvasType: 'east',
+        positionName: 'CEPL',
+        placementCategory: 'plinth_toekick',
+        sourceImageAuthority: true,
+        checklist: expect.arrayContaining([
+          expect.stringContaining('not against the blue base cabinet bbox'),
+          expect.stringContaining('actual visible toekick/plinth band'),
+          expect.stringContaining('must not extend below the visible floor/Z0 line'),
+        ]),
+      }),
+    ]);
+    expect(issueCodes(manifest)).toContain('source_boundary_review_required');
+    const rendered = PNG.sync.read(fs.readFileSync(manifest.canvases[0].outputImagePath!));
+    const topEdgePixel = pixelAt(rendered, 60, 34);
+    expect(topEdgePixel.r).toBeGreaterThan(topEdgePixel.b);
+  });
+
+  it('treats canvases with cart items but no placements as incomplete', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'east.png', 120, 90);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('east', backgroundPath)],
+        placements: [],
+        cartItems: [cartItem({ positionName: 'CEB1' })],
+      }),
+      { outputDir: tempDir, canvases: ['east'] }
+    );
+
+    const issue = manifest.issues.find((candidate) => candidate.code === 'canvas_with_no_placements');
+    expect(issue).toMatchObject({
+      severity: 'error',
+      canvasType: 'east',
+    });
+    expect(issue?.message).toContain('not complete');
+  });
+
+  it('reports unsupported non-local image references without crashing', () => {
+    const tempDir = createTempDir();
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('north', 'https://example.test/north.png')],
+        placements: [placement({ canvasType: 'north' })],
+      }),
+      { outputDir: tempDir, canvases: ['north'] }
+    );
+
+    expect(issueCodes(manifest)).toContain('unsupported_background_image_reference');
+    expect(manifest.canvases[0].outputImagePath).toBeUndefined();
+    expect(manifest.canvases[0].renderedPlacementCount).toBe(0);
+  });
+
+  it('preserves IMAGE_PIXELS center and width/height rectangle conversion', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement({ centerX: 50, centerY: 40, width: 20, height: 10 })],
+      }),
+      { outputDir: tempDir, canvases: ['plan'] }
+    );
+
+    const rendered = PNG.sync.read(fs.readFileSync(manifest.canvases[0].outputImagePath!));
+    const leftEdgePixel = pixelAt(rendered, 40, 40);
+    const topEdgePixel = pixelAt(rendered, 50, 35);
+    const outsidePixel = pixelAt(rendered, 35, 30);
+
+    expect(leftEdgePixel).not.toEqual(outsidePixel);
+    expect(topEdgePixel).not.toEqual(outsidePixel);
+  });
+
+  it('writes a JSON manifest when requested', () => {
+    const tempDir = createTempDir();
+    const backgroundPath = writeBackgroundPng(tempDir, 'plan.png', 100, 80);
+
+    const manifest = renderAiDrawingSessionReview(
+      baseState({
+        canvasImages: [backgroundImage('plan', backgroundPath)],
+        placements: [placement()],
+      }),
+      { outputDir: tempDir, canvases: ['plan'], writeJsonManifest: true }
+    );
+
+    expect(manifest.manifestPath).toBeTruthy();
+    expect(fs.existsSync(manifest.manifestPath!)).toBe(true);
+    const parsed = JSON.parse(fs.readFileSync(manifest.manifestPath!, 'utf8'));
+    expect(parsed.canvases[0]).toMatchObject({
+      canvasType: 'plan',
+      renderedPlacementCount: 1,
+      sourceBoundaryReviewTasks: [
+        expect.objectContaining({
+          placementCategory: 'plan_footprint',
+          sourceImageAuthority: true,
+        }),
+      ],
+    });
+    expect(parsed.canvases[0].outputImagePath).toBe(manifest.canvases[0].outputImagePath);
+    expect(parsed.visualReviewStatus).toBe('requires_native_vision');
+    expect(parsed.visualInspectionRequired).toBe(true);
+    expect(parsed.completionBlockedUntil).toContain('source_boundary_review_required');
+    expect(parsed.canvases[0]).not.toHaveProperty('placementReviewCrops');
+  });
+});
+
+function baseState(input: {
+  canvasImages?: unknown[];
+  placements?: unknown[];
+  cartItems?: unknown[];
+}) {
+  return {
+    session: { id: sessionId },
+    activeCart: {
+      id: '44444444-4444-4444-8444-444444444444',
+      items: input.cartItems ?? [cartItem()],
+    },
+    activeCanvases: ['plan', 'north'],
+    canvasImages: input.canvasImages ?? [],
+    canvasCabinetPlacements: input.placements ?? [],
+  };
+}
+
+function cartItem(overrides: Record<string, unknown> = {}) {
+  return {
+    id: cartItemId,
+    positionName: 'BASE_01',
+    serialNumber: 'B30',
+    ...overrides,
+  };
+}
+
+function placement(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 'placement-1',
+    aiCartItemId: cartItemId,
+    canvasType: 'plan',
+    positionName: 'BASE_01',
+    centerX: 50,
+    centerY: 40,
+    width: 30,
+    height: 20,
+    rotation: 0,
+    placementSpace: 'IMAGE_PIXELS',
+    basisImageWidthPx: 100,
+    basisImageHeightPx: 80,
+    ...overrides,
+  };
+}
+
+function backgroundImage(canvasType: string, s3Key: string) {
+  return {
+    canvasType,
+    imageType: 'background',
+    s3Key,
+  };
+}
+
+function createTempDir(): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-session-review-'));
+  tempDirs.push(tempDir);
+  return tempDir;
+}
+
+function writeBackgroundPng(tempDir: string, fileName: string, width: number, height: number): string {
+  const png = new PNG({ width, height });
+  for (let index = 0; index < png.data.length; index += 4) {
+    png.data[index] = 242;
+    png.data[index + 1] = 244;
+    png.data[index + 2] = 247;
+    png.data[index + 3] = 255;
+  }
+  const imagePath = path.join(tempDir, fileName);
+  fs.writeFileSync(imagePath, PNG.sync.write(png));
+  return imagePath;
+}
+
+function pixelAt(png: PNG, x: number, y: number): { r: number; g: number; b: number; a: number } {
+  const offset = (y * png.width + x) * 4;
+  return {
+    r: png.data[offset],
+    g: png.data[offset + 1],
+    b: png.data[offset + 2],
+    a: png.data[offset + 3],
+  };
+}
+
+function issueCodes(manifest: { issues: Array<{ code: AiDrawingSessionReviewIssueCode }> }): AiDrawingSessionReviewIssueCode[] {
+  return manifest.issues.map((issue) => issue.code);
+}