@open-mercato/core 0.4.5-develop-2e9903a57a → 0.4.5-develop-eeccf7adf4

package/src/modules/inbox_ops/lib/__tests__/extractionPrompt.test.ts

@@ -1,151 +0,0 @@
-/** @jest-environment node */
-
-import {
-  buildExtractionSystemPrompt,
-  buildExtractionUserPrompt,
-  REQUIRED_FEATURES_MAP,
-} from '../extractionPrompt'
-import type { ContactMatchResult } from '../contactMatcher'
-
-describe('buildExtractionSystemPrompt', () => {
-  it('returns a string containing the role instruction', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('email-to-ERP extraction agent')
-    expect(result).toContain('<role>')
-  })
-
-  it('includes contact matches when provided', () => {
-    const contacts: ContactMatchResult[] = [
-      {
-        participant: { name: 'John Doe', email: 'john@example.com', role: 'buyer' },
-        match: { contactId: 'c-001', contactType: 'person', contactName: 'John Doe', confidence: 0.95 },
-      },
-    ]
-    const result = buildExtractionSystemPrompt(contacts, [])
-    expect(result).toContain('Pre-matched contacts from CRM')
-    expect(result).toContain('John Doe')
-    expect(result).toContain('john@example.com')
-    expect(result).toContain('c-001')
-  })
-
-  it('shows "No pre-matched contacts" when contacts list is empty', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('No pre-matched contacts found in CRM')
-  })
-
-  it('includes catalog products when provided', () => {
-    const products = [
-      { id: 'p-001', name: 'Widget A', sku: 'WA-100', price: '29.99' },
-    ]
-    const result = buildExtractionSystemPrompt([], products)
-    expect(result).toContain('Catalog products')
-    expect(result).toContain('Widget A')
-    expect(result).toContain('WA-100')
-  })
-
-  it('shows "No catalog products" when products list is empty', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('No catalog products available for matching')
-  })
-
-  it('includes channel ID when provided', () => {
-    const result = buildExtractionSystemPrompt([], [], 'ch-001')
-    expect(result).toContain('Default sales channel ID: ch-001')
-  })
-
-  it('shows "No default sales channel" when channelId is not provided', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('No default sales channel configured')
-  })
-
-  it('includes safety instructions', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('<safety>')
-    expect(result).toContain('untrusted data')
-  })
-
-  it('includes rules section', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('<rules>')
-    expect(result).toContain('confidence')
-  })
-
-  it('includes required features mapping for all action types', () => {
-    const result = buildExtractionSystemPrompt([], [])
-    expect(result).toContain('<required_features>')
-    expect(result).toContain('create_order')
-    expect(result).toContain('draft_reply')
-  })
-
-  describe('workingLanguage parameter', () => {
-    it('defaults to English when workingLanguage is not provided', () => {
-      const result = buildExtractionSystemPrompt([], [])
-      expect(result).toContain('in English even if')
-    })
-
-    it('uses German when workingLanguage is "de"', () => {
-      const result = buildExtractionSystemPrompt([], [], undefined, 'de')
-      expect(result).toContain('in German even if')
-    })
-
-    it('uses Spanish when workingLanguage is "es"', () => {
-      const result = buildExtractionSystemPrompt([], [], undefined, 'es')
-      expect(result).toContain('in Spanish even if')
-    })
-
-    it('uses Polish when workingLanguage is "pl"', () => {
-      const result = buildExtractionSystemPrompt([], [], undefined, 'pl')
-      expect(result).toContain('in Polish even if')
-    })
-
-    it('falls back to English for unknown language codes', () => {
-      const result = buildExtractionSystemPrompt([], [], undefined, 'xx')
-      expect(result).toContain('in English even if')
-    })
-  })
-})
-
-describe('buildExtractionUserPrompt', () => {
-  it('wraps email content in <email_content> XML delimiters', () => {
-    const content = 'Dear team, please process our order for 100 units.'
-    const result = buildExtractionUserPrompt(content)
-    expect(result).toContain('<email_content>')
-    expect(result).toContain('</email_content>')
-    expect(result).toContain(content)
-  })
-
-  it('includes output requirements', () => {
-    const result = buildExtractionUserPrompt('test content')
-    expect(result).toContain('<output_requirements>')
-    expect(result).toContain('summary')
-    expect(result).toContain('proposedActions')
-  })
-
-  it('includes task instruction', () => {
-    const result = buildExtractionUserPrompt('test')
-    expect(result).toContain('<task>')
-    expect(result).toContain('Extract actionable ERP proposals')
-  })
-})
-
-describe('REQUIRED_FEATURES_MAP', () => {
-  it('maps all 9 action types to required features', () => {
-    const expectedMappings: Record<string, string> = {
-      create_order: 'sales.orders.manage',
-      create_quote: 'sales.quotes.manage',
-      update_order: 'sales.orders.manage',
-      update_shipment: 'sales.shipments.manage',
-      create_contact: 'customers.people.manage',
-      create_product: 'catalog.products.manage',
-      link_contact: 'customers.people.manage',
-      log_activity: 'customers.activities.manage',
-      draft_reply: 'inbox_ops.replies.send',
-    }
-
-    expect(Object.keys(REQUIRED_FEATURES_MAP)).toHaveLength(9)
-
-    for (const [actionType, feature] of Object.entries(expectedMappings)) {
-      expect(REQUIRED_FEATURES_MAP[actionType as keyof typeof REQUIRED_FEATURES_MAP]).toBe(feature)
-    }
-  })
-})

package/src/modules/inbox_ops/lib/__tests__/priceValidator.test.ts

@@ -1,259 +0,0 @@
-/** @jest-environment node */
-
-import { validatePrices } from '../priceValidator'
-
-const mockFindWithDecryption = jest.fn()
-
-jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
-  findWithDecryption: (...args: unknown[]) => mockFindWithDecryption(...args),
-}))
-
-const mockEm = {} as any
-const MockPriceClass = class {} as any
-
-const scope = {
-  tenantId: 'tenant-1',
-  organizationId: 'org-1',
-}
-
-const deps = { catalogProductPriceClass: MockPriceClass }
-
-describe('validatePrices', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-    delete process.env.INBOX_OPS_PRICE_MISMATCH_THRESHOLD
-  })
-
-  it('returns empty array for non-order actions', async () => {
-    const result = await validatePrices(mockEm, [
-      { actionType: 'create_contact', payload: {}, index: 0 },
-      { actionType: 'log_activity', payload: {}, index: 1 },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-    expect(mockFindWithDecryption).not.toHaveBeenCalled()
-  })
-
-  it('detects warning-level price mismatch (5-20%)', async () => {
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { unitPriceNet: '100.00', currencyCode: 'EUR' },
-    ])
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '110', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].type).toBe('price_mismatch')
-    expect(result[0].severity).toBe('warning')
-    expect(result[0].expectedValue).toBe('100.00')
-    expect(result[0].foundValue).toBe('110')
-    expect(result[0].actionIndex).toBe(0)
-  })
-
-  it('detects error-level price mismatch (>20%)', async () => {
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { unitPriceNet: '100.00', currencyCode: 'EUR' },
-    ])
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_quote',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '150', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].severity).toBe('error')
-  })
-
-  it('detects currency mismatch between order and catalog', async () => {
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { unitPriceNet: '100.00', currencyCode: 'USD' },
-    ])
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '100', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].type).toBe('currency_mismatch')
-    expect(result[0].severity).toBe('warning')
-    expect(result[0].expectedValue).toBe('USD')
-    expect(result[0].foundValue).toBe('EUR')
-  })
-
-  it('skips line items without productId', async () => {
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          lineItems: [
-            { productName: 'Unknown item', unitPrice: '50', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-    expect(mockFindWithDecryption).not.toHaveBeenCalled()
-  })
-
-  it('skips line items without unitPrice', async () => {
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-    expect(mockFindWithDecryption).not.toHaveBeenCalled()
-  })
-
-  it('skips when catalog price is not found', async () => {
-    mockFindWithDecryption.mockResolvedValueOnce([])
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '50', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-  })
-
-  it('passes when price is within threshold', async () => {
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { unitPriceNet: '100.00', currencyCode: 'EUR' },
-    ])
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '102', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-  })
-
-  it('uses custom threshold from environment variable', async () => {
-    process.env.INBOX_OPS_PRICE_MISMATCH_THRESHOLD = '0.10'
-
-    mockFindWithDecryption.mockResolvedValueOnce([
-      { unitPriceNet: '100.00', currencyCode: 'EUR' },
-    ])
-
-    // 8% diff - under 10% custom threshold
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '108', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-  })
-
-  it('handles multiple line items and multiple actions', async () => {
-    mockFindWithDecryption
-      .mockResolvedValueOnce([{ unitPriceNet: '10', currencyCode: 'EUR' }])   // prod-1: 10 vs 10 = ok
-      .mockResolvedValueOnce([{ unitPriceNet: '50', currencyCode: 'EUR' }])   // prod-2: 50 vs 100 = 100% diff
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          currencyCode: 'EUR',
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '10', quantity: '5' },
-            { productName: 'Widget B', productId: 'prod-2', unitPrice: '100', quantity: '2' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toHaveLength(1)
-    expect(result[0].description).toContain('Widget B')
-  })
-
-  it('handles lookup errors gracefully', async () => {
-    mockFindWithDecryption.mockRejectedValueOnce(new Error('DB error'))
-
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: {
-          lineItems: [
-            { productName: 'Widget A', productId: 'prod-1', unitPrice: '50', quantity: '1' },
-          ],
-        },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-  })
-
-  it('handles empty lineItems array', async () => {
-    const result = await validatePrices(mockEm, [
-      {
-        actionType: 'create_order',
-        payload: { lineItems: [] },
-        index: 0,
-      },
-    ], scope, deps)
-
-    expect(result).toEqual([])
-  })
-})

package/src/modules/inbox_ops/lib/__tests__/translationProvider.test.ts

@@ -1,99 +0,0 @@
-/** @jest-environment node */
-
-const mockGenerateObject = jest.fn()
-jest.mock('ai', () => ({
-  generateObject: (...args: unknown[]) => mockGenerateObject(...args),
-}))
-
-jest.mock('@open-mercato/shared/lib/ai/opencode-provider', () => ({
-  resolveFirstConfiguredOpenCodeProvider: jest.fn(() => 'openai'),
-  resolveOpenCodeModel: jest.fn(() => ({ modelId: 'gpt-4o', modelWithProvider: 'openai:gpt-4o' })),
-  resolveOpenCodeProviderApiKey: jest.fn(() => 'test-key'),
-  resolveOpenCodeProviderId: jest.fn((id: string) => id || 'openai'),
-}))
-
-jest.mock('@open-mercato/core/modules/inbox_ops/lib/llmProvider', () => ({
-  createStructuredModel: jest.fn(async () => 'mock-model'),
-  resolveExtractionProviderId: jest.fn(() => 'openai'),
-  withTimeout: jest.fn(async (promise: Promise<unknown>) => promise),
-}))
-
-import { translateProposalContent } from '../translationProvider'
-
-describe('translateProposalContent', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('calls generateObject with correct translation prompt', async () => {
-    mockGenerateObject.mockResolvedValueOnce({
-      object: {
-        summary: 'Kunde möchte 10 Widgets bestellen',
-        actions: { 'action-1': 'Bestellung erstellen' },
-      },
-    })
-
-    const result = await translateProposalContent({
-      summary: 'Customer wants to order 10 widgets',
-      actionDescriptions: { 'action-1': 'Create order' },
-      sourceLanguage: 'en',
-      targetLocale: 'de',
-    })
-
-    expect(mockGenerateObject).toHaveBeenCalledWith(
-      expect.objectContaining({
-        model: 'mock-model',
-        system: expect.stringContaining('English'),
-        prompt: expect.stringContaining('Customer wants to order 10 widgets'),
-        temperature: 0,
-      }),
-    )
-    expect(mockGenerateObject.mock.calls[0][0].system).toContain('German')
-
-    expect(result.summary).toBe('Kunde möchte 10 Widgets bestellen')
-    expect(result.actions['action-1']).toBe('Bestellung erstellen')
-  })
-
-  it('preserves action ID mapping in the response', async () => {
-    const actionDescriptions = {
-      'id-aaa': 'Create contact for John',
-      'id-bbb': 'Create order for widgets',
-      'id-ccc': 'Log activity',
-    }
-
-    mockGenerateObject.mockResolvedValueOnce({
-      object: {
-        summary: 'Resumen traducido',
-        actions: {
-          'id-aaa': 'Crear contacto para John',
-          'id-bbb': 'Crear pedido de widgets',
-          'id-ccc': 'Registrar actividad',
-        },
-      },
-    })
-
-    const result = await translateProposalContent({
-      summary: 'Translated summary',
-      actionDescriptions,
-      sourceLanguage: 'en',
-      targetLocale: 'es',
-    })
-
-    expect(Object.keys(result.actions)).toEqual(['id-aaa', 'id-bbb', 'id-ccc'])
-    expect(result.actions['id-aaa']).toBe('Crear contacto para John')
-  })
-
-  it('throws when API key is missing', async () => {
-    const { resolveOpenCodeProviderApiKey } = require('@open-mercato/shared/lib/ai/opencode-provider')
-    resolveOpenCodeProviderApiKey.mockReturnValueOnce(null)
-
-    await expect(
-      translateProposalContent({
-        summary: 'Test',
-        actionDescriptions: {},
-        sourceLanguage: 'en',
-        targetLocale: 'de',
-      }),
-    ).rejects.toThrow('Missing API key')
-  })
-})