@open-mercato/ui 0.5.1-develop.3036.f02c281f23 → 0.5.1-develop.3045.b4b3320cc2

package/src/ai/__tests__/AiMessageContent.test.ts

@@ -0,0 +1,111 @@
+/**
+ * @jest-environment node
+ */
+
+import { parseAiContentSegments } from '../AiMessageContent'
+
+describe('parseAiContentSegments — fenced cards', () => {
+  it('parses a properly fenced product card', () => {
+    const content = [
+      'Here is the product:',
+      '```open-mercato:product',
+      '{ "id": "abc", "name": "Wireless Headphones", "sku": "WH-001" }',
+      '```',
+    ].join('\n')
+    const segments = parseAiContentSegments(content)
+    expect(segments.some((s) => s.kind === 'record-card')).toBe(true)
+    const card = segments.find((s) => s.kind === 'record-card')
+    expect(card?.kind).toBe('record-card')
+    if (card?.kind === 'record-card' && card.payload.kind === 'product') {
+      expect(card.payload.name).toBe('Wireless Headphones')
+    }
+  })
+})
+
+describe('parseAiContentSegments — fenceless recovery', () => {
+  it('lifts a fenceless single-line product card out of the prose', () => {
+    const content =
+      'Here are the recent products: ' +
+      'open-mercato:product { "id": "c3171e47-9067-424d-8577-6ad25685b69c", "name": "Aurora Wrap Dress", "sku": "AURORA-WRAP", "price": 212, "currency": "USD", "imageUrl": "/api/attachments/image/988b8d93/aurora.png", "href": "/backend/catalog/catalog/products/c3171e47-9067-424d-8577-6ad25685b69c" } ' +
+      'and more.'
+    const segments = parseAiContentSegments(content)
+    const cards = segments.filter((s) => s.kind === 'record-card')
+    expect(cards).toHaveLength(1)
+    if (cards[0].kind === 'record-card' && cards[0].payload.kind === 'product') {
+      expect(cards[0].payload.name).toBe('Aurora Wrap Dress')
+      expect(cards[0].payload.sku).toBe('AURORA-WRAP')
+      expect(cards[0].payload.imageUrl).toBe('/api/attachments/image/988b8d93/aurora.png')
+    }
+    // Surrounding prose is preserved
+    const md = segments.filter((s) => s.kind === 'markdown')
+    expect(md.length).toBeGreaterThanOrEqual(1)
+  })
+
+  it('lifts multiple fenceless cards in a row', () => {
+    const content = [
+      'Products:',
+      'open-mercato:product { "id": "1", "name": "Aurora Wrap Dress" }',
+      'open-mercato:product { "id": "2", "name": "Atlas Runner Sneaker" }',
+      'open-mercato:product { "id": "3", "name": "Restorative Massage" }',
+      'Tell me which one to work on next.',
+    ].join('\n')
+    const segments = parseAiContentSegments(content)
+    const cards = segments.filter((s) => s.kind === 'record-card')
+    expect(cards).toHaveLength(3)
+    const names = cards
+      .map((card) => (card.kind === 'record-card' && card.payload.kind === 'product' ? card.payload.name : null))
+      .filter(Boolean)
+    expect(names).toEqual(['Aurora Wrap Dress', 'Atlas Runner Sneaker', 'Restorative Massage'])
+  })
+
+  it('lifts a fenceless multi-line card spanning newlines', () => {
+    const content =
+      'Here is one:\n' +
+      'open-mercato:product\n' +
+      '{\n' +
+      '  "id": "abc",\n' +
+      '  "name": "Aurora Wrap Dress"\n' +
+      '}\n' +
+      'follow-up text.'
+    const segments = parseAiContentSegments(content)
+    const cards = segments.filter((s) => s.kind === 'record-card')
+    expect(cards).toHaveLength(1)
+  })
+
+  it('falls back to plain markdown when the json is invalid', () => {
+    const content = 'Maybe: open-mercato:product { not json } end'
+    const segments = parseAiContentSegments(content)
+    expect(segments.every((s) => s.kind === 'markdown')).toBe(true)
+  })
+
+  it('falls back to plain markdown for unknown kinds', () => {
+    const content = 'See: open-mercato:bogus { "id": "x", "name": "y" }'
+    const segments = parseAiContentSegments(content)
+    expect(segments.every((s) => s.kind === 'markdown')).toBe(true)
+  })
+
+  it('preserves a properly fenced card when both formats appear', () => {
+    const content = [
+      'Two products:',
+      '```open-mercato:product',
+      '{ "id": "1", "name": "Fenced Product" }',
+      '```',
+      'and: open-mercato:product { "id": "2", "name": "Fenceless Product" }',
+    ].join('\n')
+    const segments = parseAiContentSegments(content)
+    const cards = segments.filter((s) => s.kind === 'record-card')
+    expect(cards).toHaveLength(2)
+    const names = cards
+      .map((card) => (card.kind === 'record-card' && card.payload.kind === 'product' ? card.payload.name : null))
+      .filter(Boolean)
+    expect(names).toEqual(['Fenced Product', 'Fenceless Product'])
+  })
+
+  it('handles nested braces inside the json (e.g. attribute objects)', () => {
+    const content =
+      'Here: open-mercato:product { "id": "1", "name": "X", "attrs": { "color": "rosewood", "size": "M" } } done'
+    const segments = parseAiContentSegments(content)
+    const cards = segments.filter((s) => s.kind === 'record-card')
+    expect(cards).toHaveLength(1)
+  })
+})

package/src/ai/__tests__/ui-part-registry.test.ts

@@ -0,0 +1,199 @@
+import {
+  RESERVED_AI_UI_PART_IDS,
+  createAiUiPartRegistry,
+  defaultAiUiPartRegistry,
+  listAiUiParts,
+  registerAiUiPart,
+  resetAiUiPartRegistryForTests,
+  resolveAiUiPart,
+  unregisterAiUiPart,
+  type AiUiPartComponent,
+} from '../ui-part-registry'
+import { PendingPhase3Placeholder } from '../ui-parts/pending-phase3-placeholder'
+import { AI_MUTATION_APPROVAL_CARDS } from '../parts/approval-cards-map'
+import { MutationPreviewCard } from '../parts/MutationPreviewCard'
+import { FieldDiffCard } from '../parts/FieldDiffCard'
+import { ConfirmationCard } from '../parts/ConfirmationCard'
+import { MutationResultCard } from '../parts/MutationResultCard'
+
+const NullComponent = (() => null) as unknown as AiUiPartComponent
+
+describe('ai-part-registry', () => {
+  beforeEach(() => {
+    resetAiUiPartRegistryForTests()
+  })
+
+  afterAll(() => {
+    resetAiUiPartRegistryForTests()
+  })
+
+  it('resolves the LIVE mutation-approval cards on the default registry (Step 5.10)', () => {
+    expect(resolveAiUiPart('mutation-preview-card')).toBe(MutationPreviewCard)
+    expect(resolveAiUiPart('field-diff-card')).toBe(FieldDiffCard)
+    expect(resolveAiUiPart('confirmation-card')).toBe(ConfirmationCard)
+    expect(resolveAiUiPart('mutation-result-card')).toBe(MutationResultCard)
+  })
+
+  it('AI_MUTATION_APPROVAL_CARDS includes every reserved Phase 3 slot id', () => {
+    for (const reservedId of RESERVED_AI_UI_PART_IDS) {
+      expect(AI_MUTATION_APPROVAL_CARDS[reservedId]).toBeDefined()
+    }
+  })
+
+  it('round-trips a registered component, overwriting the seeded placeholder', () => {
+    registerAiUiPart('mutation-preview-card', NullComponent)
+    expect(resolveAiUiPart('mutation-preview-card')).toBe(NullComponent)
+  })
+
+  it('unregisterAiUiPart removes a registration (including seeded placeholders)', () => {
+    unregisterAiUiPart('field-diff-card')
+    expect(resolveAiUiPart('field-diff-card')).toBeNull()
+  })
+
+  it('re-registering the same id overwrites the previous entry', () => {
+    const first = (() => null) as unknown as AiUiPartComponent
+    const second = (() => null) as unknown as AiUiPartComponent
+    registerAiUiPart('confirmation-card', first)
+    registerAiUiPart('confirmation-card', second)
+    expect(resolveAiUiPart('confirmation-card')).toBe(second)
+  })
+
+  it('rejects empty component ids', () => {
+    expect(() => registerAiUiPart('', NullComponent)).toThrow()
+  })
+
+  it('ships with the canonical reserved Phase 3 slot ids', () => {
+    expect(RESERVED_AI_UI_PART_IDS).toEqual([
+      'mutation-preview-card',
+      'field-diff-card',
+      'confirmation-card',
+      'mutation-result-card',
+    ])
+  })
+
+  describe('listAiUiParts()', () => {
+    it('returns reserved: true for the four Phase 3 slot ids', () => {
+      const entries = listAiUiParts()
+      const byId = new Map(entries.map((entry) => [entry.componentId, entry]))
+      for (const reserved of RESERVED_AI_UI_PART_IDS) {
+        expect(byId.get(reserved)).toEqual({ componentId: reserved, reserved: true })
+      }
+    })
+
+    it('returns reserved: false for user-registered components', () => {
+      registerAiUiPart('custom-widget', NullComponent)
+      const entries = listAiUiParts()
+      const entry = entries.find((e) => e.componentId === 'custom-widget')
+      expect(entry).toEqual({ componentId: 'custom-widget', reserved: false })
+    })
+  })
+
+  describe('defaultAiUiPartRegistry', () => {
+    it('exposes the legacy helpers over the same underlying store', () => {
+      registerAiUiPart('custom-widget', NullComponent)
+      expect(defaultAiUiPartRegistry.has('custom-widget')).toBe(true)
+      expect(defaultAiUiPartRegistry.resolve('custom-widget')).toBe(NullComponent)
+    })
+
+    it('clear() empties everything and re-seeds the LIVE approval cards on the default registry', () => {
+      registerAiUiPart('custom-widget', NullComponent)
+      defaultAiUiPartRegistry.clear()
+      expect(defaultAiUiPartRegistry.has('custom-widget')).toBe(false)
+      expect(defaultAiUiPartRegistry.resolve('mutation-preview-card')).toBe(
+        MutationPreviewCard,
+      )
+    })
+  })
+
+  describe('createAiUiPartRegistry()', () => {
+    it('seeds reserved placeholders by default (scoped isolation preserved)', () => {
+      const registry = createAiUiPartRegistry()
+      for (const reserved of RESERVED_AI_UI_PART_IDS) {
+        expect(registry.resolve(reserved)).toBe(PendingPhase3Placeholder)
+        expect(registry.has(reserved)).toBe(true)
+      }
+    })
+
+    it('seeds the LIVE approval cards when seedLiveApprovalCards: true', () => {
+      const registry = createAiUiPartRegistry({ seedLiveApprovalCards: true })
+      expect(registry.resolve('mutation-preview-card')).toBe(MutationPreviewCard)
+      expect(registry.resolve('field-diff-card')).toBe(FieldDiffCard)
+      expect(registry.resolve('confirmation-card')).toBe(ConfirmationCard)
+      expect(registry.resolve('mutation-result-card')).toBe(MutationResultCard)
+    })
+
+    it('does NOT seed placeholders when seedReservedPlaceholders is false', () => {
+      const registry = createAiUiPartRegistry({ seedReservedPlaceholders: false })
+      for (const reserved of RESERVED_AI_UI_PART_IDS) {
+        expect(registry.resolve(reserved)).toBeNull()
+        expect(registry.has(reserved)).toBe(false)
+      }
+      expect(registry.list()).toEqual([])
+    })
+
+    it('registrations on a scoped registry do not leak into the default registry', () => {
+      const scoped = createAiUiPartRegistry()
+      scoped.register('scoped-widget', NullComponent)
+      expect(scoped.has('scoped-widget')).toBe(true)
+      expect(defaultAiUiPartRegistry.has('scoped-widget')).toBe(false)
+      expect(resolveAiUiPart('scoped-widget')).toBeNull()
+    })
+
+    it('two scoped registries maintain independent state', () => {
+      const a = createAiUiPartRegistry()
+      const b = createAiUiPartRegistry()
+      const first = (() => null) as unknown as AiUiPartComponent
+      const second = (() => null) as unknown as AiUiPartComponent
+      a.register('mutation-preview-card', first)
+      b.register('mutation-preview-card', second)
+      expect(a.resolve('mutation-preview-card')).toBe(first)
+      expect(b.resolve('mutation-preview-card')).toBe(second)
+    })
+
+    it('register() replaces an existing id on a scoped registry', () => {
+      const registry = createAiUiPartRegistry()
+      const real = (() => null) as unknown as AiUiPartComponent
+      registry.register('mutation-preview-card', real)
+      expect(registry.resolve('mutation-preview-card')).toBe(real)
+    })
+
+    it('unregister() removes an entry on a scoped registry', () => {
+      const registry = createAiUiPartRegistry()
+      registry.unregister('confirmation-card')
+      expect(registry.has('confirmation-card')).toBe(false)
+      expect(registry.resolve('confirmation-card')).toBeNull()
+    })
+
+    it('clear() wipes registrations and re-seeds reserved ids when seeding is enabled', () => {
+      const registry = createAiUiPartRegistry()
+      registry.register('custom', NullComponent)
+      registry.clear()
+      expect(registry.has('custom')).toBe(false)
+      for (const reserved of RESERVED_AI_UI_PART_IDS) {
+        expect(registry.has(reserved)).toBe(true)
+      }
+    })
+
+    it('clear() leaves an un-seeded registry empty', () => {
+      const registry = createAiUiPartRegistry({ seedReservedPlaceholders: false })
+      registry.register('custom', NullComponent)
+      registry.clear()
+      expect(registry.list()).toEqual([])
+    })
+
+    it('list() flags reserved entries correctly on scoped registries', () => {
+      const registry = createAiUiPartRegistry()
+      registry.register('custom-widget', NullComponent)
+      const entries = registry.list()
+      const byId = new Map(entries.map((entry) => [entry.componentId, entry]))
+      expect(byId.get('custom-widget')).toEqual({
+        componentId: 'custom-widget',
+        reserved: false,
+      })
+      expect(byId.get('mutation-preview-card')).toEqual({
+        componentId: 'mutation-preview-card',
+        reserved: true,
+      })
+    })
+  })
+})

package/src/ai/__tests__/ui-part-slots.test.ts

@@ -0,0 +1,43 @@
+import {
+  RESERVED_AI_UI_PART_IDS,
+  isReservedAiUiPartId,
+} from '../ui-part-slots'
+
+describe('ui-part-slots', () => {
+  it('exposes exactly four reserved Phase 3 slot ids', () => {
+    expect(RESERVED_AI_UI_PART_IDS).toHaveLength(4)
+  })
+
+  it('matches the spec §9 / Step 5.10 contract verbatim and in order', () => {
+    expect(RESERVED_AI_UI_PART_IDS).toEqual([
+      'mutation-preview-card',
+      'field-diff-card',
+      'confirmation-card',
+      'mutation-result-card',
+    ])
+  })
+
+  it('is a readonly tuple — attempting to mutate it is a compile-time error', () => {
+    // Runtime assertion — defence-in-depth against accidental spreading or
+    // push() operations in consumer code. The tuple is `as const` so this
+    // mostly guards against typed-but-cast code paths.
+    const sealedLength = RESERVED_AI_UI_PART_IDS.length
+    const mutable = RESERVED_AI_UI_PART_IDS as unknown as string[]
+    expect(() => mutable.push('bogus')).toThrow()
+    expect(RESERVED_AI_UI_PART_IDS.length).toBe(sealedLength)
+  })
+
+  describe('isReservedAiUiPartId()', () => {
+    it('returns true for every reserved id', () => {
+      for (const reserved of RESERVED_AI_UI_PART_IDS) {
+        expect(isReservedAiUiPartId(reserved)).toBe(true)
+      }
+    })
+
+    it('returns false for non-reserved ids', () => {
+      expect(isReservedAiUiPartId('custom-widget')).toBe(false)
+      expect(isReservedAiUiPartId('')).toBe(false)
+      expect(isReservedAiUiPartId('mutation-preview-card-variant')).toBe(false)
+    })
+  })
+})

package/src/ai/__tests__/upload-adapter.test.ts

@@ -0,0 +1,213 @@
+/**
+ * @jest-environment jsdom
+ */
+
+import {
+  uploadAttachmentsForChat,
+  type UploadAttachmentsForChatOptions,
+} from '../upload-adapter'
+
+function makeFile(name: string, content = 'hello', type = 'text/plain'): File {
+  return new File([content], name, { type })
+}
+
+function jsonResponse(status: number, body: unknown): Response {
+  const payload = typeof body === 'string' ? body : JSON.stringify(body)
+  return new Response(payload, {
+    status,
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+describe('uploadAttachmentsForChat', () => {
+  it('returns empty result for empty file list without calling fetch', async () => {
+    const fetchImpl = jest.fn()
+    const result = await uploadAttachmentsForChat([], {
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+    })
+    expect(result.items).toEqual([])
+    expect(result.failed).toEqual([])
+    expect(fetchImpl).not.toHaveBeenCalled()
+  })
+
+  it('uploads multiple files, preserves order, and uses defaults', async () => {
+    let counter = 0
+    const seenUrls: string[] = []
+    const fetchImpl = jest.fn(async (input: RequestInfo | URL) => {
+      seenUrls.push(String(input))
+      const id = `att_${counter++}`
+      return jsonResponse(200, {
+        ok: true,
+        item: { id, fileName: `f-${counter}.txt`, fileSize: 5, mimeType: 'text/plain' },
+      })
+    }) as unknown as typeof fetch
+
+    const files = [makeFile('a.txt'), makeFile('b.txt'), makeFile('c.txt')]
+    const result = await uploadAttachmentsForChat(files, {
+      fetchImpl,
+    })
+
+    expect(seenUrls).toHaveLength(3)
+    expect(seenUrls.every((u) => u === '/api/attachments')).toBe(true)
+    expect(result.items).toHaveLength(3)
+    expect(result.failed).toEqual([])
+    // Items preserve input order via index-aware parsing.
+    expect(result.items.map((item) => item.attachmentId)).toEqual(['att_0', 'att_1', 'att_2'])
+  })
+
+  it('captures server rejections in failed[] with a normalized reason', async () => {
+    const fetchImpl = jest.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      const form = init?.body as FormData
+      const file = form.get('file') as File
+      if (file.name === 'big.bin') {
+        return jsonResponse(413, { error: 'Attachment exceeds the maximum upload size.' })
+      }
+      if (file.name === 'bad.exe') {
+        return jsonResponse(400, { error: 'File type not allowed' })
+      }
+      return jsonResponse(200, {
+        ok: true,
+        item: { id: 'att_ok', fileName: file.name, fileSize: file.size, mimeType: file.type },
+      })
+    }) as unknown as typeof fetch
+
+    const files = [makeFile('ok.txt'), makeFile('big.bin'), makeFile('bad.exe')]
+    const result = await uploadAttachmentsForChat(files, { fetchImpl })
+
+    expect(result.items.map((item) => item.fileName)).toEqual(['ok.txt'])
+    expect(result.failed).toEqual([
+      expect.objectContaining({ fileName: 'big.bin', reason: 'size_exceeded' }),
+      expect.objectContaining({ fileName: 'bad.exe', reason: 'mime_rejected' }),
+    ])
+  })
+
+  it('maps network errors to reason=network', async () => {
+    const fetchImpl = jest.fn(async () => {
+      throw new Error('socket closed')
+    }) as unknown as typeof fetch
+
+    const result = await uploadAttachmentsForChat([makeFile('a.txt')], { fetchImpl })
+    expect(result.items).toEqual([])
+    expect(result.failed).toEqual([
+      expect.objectContaining({ fileName: 'a.txt', reason: 'network' }),
+    ])
+  })
+
+  it('honours AbortSignal by flagging remaining files as aborted', async () => {
+    const controller = new AbortController()
+    let started = 0
+    const fetchImpl = jest.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      started += 1
+      if (started === 1) {
+        controller.abort()
+        const error = new Error('aborted') as Error & { name: string }
+        error.name = 'AbortError'
+        throw error
+      }
+      // Should not reach here for the remaining files.
+      return jsonResponse(200, {
+        ok: true,
+        item: {
+          id: 'att',
+          fileName: 'ignored',
+          fileSize: 1,
+          mimeType: 'text/plain',
+        },
+      })
+    }) as unknown as typeof fetch
+
+    const files = [makeFile('first.txt'), makeFile('second.txt'), makeFile('third.txt')]
+    const result = await uploadAttachmentsForChat(files, {
+      fetchImpl,
+      signal: controller.signal,
+      concurrency: 1,
+    })
+
+    expect(result.items).toEqual([])
+    expect(result.failed.every((failure) => failure.reason === 'aborted')).toBe(true)
+    expect(result.failed.map((failure) => failure.fileName)).toEqual(
+      expect.arrayContaining(['first.txt', 'second.txt', 'third.txt']),
+    )
+  })
+
+  it('caps in-flight uploads at concurrency (default 3)', async () => {
+    let inFlight = 0
+    let peak = 0
+    const fetchImpl = jest.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      inFlight += 1
+      if (inFlight > peak) peak = inFlight
+      await new Promise((resolve) => setTimeout(resolve, 5))
+      inFlight -= 1
+      const form = init?.body as FormData
+      const file = form.get('file') as File
+      return jsonResponse(200, {
+        ok: true,
+        item: {
+          id: `att_${file.name}`,
+          fileName: file.name,
+          fileSize: file.size,
+          mimeType: 'text/plain',
+        },
+      })
+    }) as unknown as typeof fetch
+
+    const files = Array.from({ length: 8 }, (_, index) => makeFile(`f-${index}.txt`))
+    const result = await uploadAttachmentsForChat(files, { fetchImpl })
+
+    expect(result.items).toHaveLength(8)
+    expect(peak).toBeLessThanOrEqual(3)
+  })
+
+  it('forwards entityType, recordId, and partitionCode to the multipart payload', async () => {
+    const captured: FormData[] = []
+    const fetchImpl = jest.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      captured.push(init?.body as FormData)
+      return jsonResponse(200, {
+        ok: true,
+        item: {
+          id: 'att_fwd',
+          fileName: 'x.txt',
+          fileSize: 5,
+          mimeType: 'text/plain',
+        },
+      })
+    }) as unknown as typeof fetch
+
+    const options: UploadAttachmentsForChatOptions = {
+      fetchImpl,
+      entityType: 'ai-chat-draft',
+      recordId: 'chat-abc-123',
+      partitionCode: 'attachments',
+    }
+
+    await uploadAttachmentsForChat([makeFile('x.txt')], options)
+    const form = captured[0]
+    expect(form.get('entityId')).toBe('ai-chat-draft')
+    expect(form.get('recordId')).toBe('chat-abc-123')
+    expect(form.get('partitionCode')).toBe('attachments')
+  })
+
+  it('falls back to a generated recordId when none is supplied and shares it across the batch', async () => {
+    const seenRecordIds = new Set<string>()
+    const fetchImpl = jest.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+      const form = init?.body as FormData
+      seenRecordIds.add(String(form.get('recordId')))
+      const file = form.get('file') as File
+      return jsonResponse(200, {
+        ok: true,
+        item: {
+          id: `att_${file.name}`,
+          fileName: file.name,
+          fileSize: file.size,
+          mimeType: 'text/plain',
+        },
+      })
+    }) as unknown as typeof fetch
+
+    await uploadAttachmentsForChat([makeFile('a.txt'), makeFile('b.txt')], { fetchImpl })
+    expect(seenRecordIds.size).toBe(1)
+    const onlyId = [...seenRecordIds][0]
+    expect(typeof onlyId).toBe('string')
+    expect((onlyId as string).length).toBeGreaterThan(0)
+  })
+})