@open-mercato/ai-assistant 0.4.9-develop-8c36c096d5 → 0.4.9-develop-be6e1cf49c

package/src/modules/ai_assistant/lib/__tests__/session-memory.test.ts

@@ -0,0 +1,82 @@
+import {
+  incrementToolCallCount,
+  buildMemoryContext,
+  buildSearchLabel,
+  storeSearchResult,
+} from '../session-memory'
+
+describe('session-memory', () => {
+
+  describe('tool call counting', () => {
+    it('increments count per session', () => {
+      const countToken = `count_${Date.now()}`
+      const r1 = incrementToolCallCount(countToken)
+      expect(r1.count).toBe(1)
+      expect(r1.exceeded).toBe(false)
+
+      const r2 = incrementToolCallCount(countToken)
+      expect(r2.count).toBe(2)
+      expect(r2.exceeded).toBe(false)
+    })
+
+    it('enforces hard cap at 10 calls', () => {
+      const capToken = `cap_${Date.now()}`
+      for (let i = 0; i < 10; i++) {
+        const r = incrementToolCallCount(capToken)
+        expect(r.exceeded).toBe(false)
+      }
+      const r11 = incrementToolCallCount(capToken)
+      expect(r11.count).toBe(11)
+      expect(r11.exceeded).toBe(true)
+    })
+  })
+
+  describe('buildMemoryContext', () => {
+    it('returns empty for unknown session', () => {
+      expect(buildMemoryContext('nonexistent_session_ctx')).toBe('')
+    })
+
+    it('returns empty for session with no searches', () => {
+      const ctxToken = `ctx_empty_${Date.now()}`
+      incrementToolCallCount(ctxToken) // creates session
+      expect(buildMemoryContext(ctxToken)).toBe('')
+    })
+
+    it('includes search count and labels', () => {
+      const ctxToken = `ctx_labels_${Date.now()}`
+      storeSearchResult(ctxToken, 'code1', 'r1', 'companies lookup')
+      storeSearchResult(ctxToken, 'code2', 'r2', 'orders lookup')
+      const ctx = buildMemoryContext(ctxToken)
+      expect(ctx).toContain('2 schema searches cached')
+      expect(ctx).toContain('companies lookup')
+      expect(ctx).toContain('orders lookup')
+    })
+  })
+
+  describe('buildSearchLabel', () => {
+    it('extracts findEndpoints helper call', () => {
+      expect(buildSearchLabel('async () => spec.findEndpoints("customer")')).toBe(
+        'findEndpoints("customer")'
+      )
+    })
+
+    it('extracts describeEndpoint helper call', () => {
+      expect(
+        buildSearchLabel(
+          'async () => spec.describeEndpoint("/api/sales/orders", "post")'
+        )
+      ).toBe('describeEndpoint("/api/sales/orders", "post")')
+    })
+
+    it('extracts describeEntity helper call', () => {
+      expect(buildSearchLabel('async () => spec.describeEntity("company")')).toBe(
+        'describeEntity("company")'
+      )
+    })
+
+    it('falls back to code prefix for non-helper calls', () => {
+      const label = buildSearchLabel('async () => Object.keys(spec.paths)')
+      expect(label).toBe('Object.keys(spec.paths)')
+    })
+  })
+})

package/src/modules/ai_assistant/lib/__tests__/truncate.test.ts

@@ -0,0 +1,76 @@
+import { truncateResult } from '../truncate'
+
+describe('truncateResult', () => {
+  it('serializes simple values', () => {
+    expect(truncateResult(42)).toBe('42')
+    expect(truncateResult('hello')).toBe('"hello"')
+    expect(truncateResult(true)).toBe('true')
+    expect(truncateResult(null)).toBe('null')
+  })
+
+  it('returns "undefined" for undefined', () => {
+    expect(truncateResult(undefined)).toBe('undefined')
+  })
+
+  it('serializes objects with pretty printing', () => {
+    const result = truncateResult({ a: 1, b: 2 })
+    expect(JSON.parse(result)).toEqual({ a: 1, b: 2 })
+    expect(result).toContain('\n') // pretty printed
+  })
+
+  it('serializes arrays', () => {
+    const result = truncateResult([1, 2, 3])
+    expect(JSON.parse(result)).toEqual([1, 2, 3])
+  })
+
+  it('truncates large output', () => {
+    const largeArray = Array.from({ length: 10000 }, (_, i) => ({
+      id: `item-${i}`,
+      name: `Item number ${i} with some extra text`,
+    }))
+    const result = truncateResult(largeArray)
+    expect(result.length).toBeLessThanOrEqual(40_100) // ~40K + truncation message
+    expect(result).toContain('truncated')
+  })
+
+  it('respects custom maxChars', () => {
+    const data = { message: 'x'.repeat(200) }
+    const result = truncateResult(data, 100)
+    expect(result.length).toBeLessThanOrEqual(200)
+    expect(result).toContain('truncated')
+  })
+
+  it('does not truncate small output', () => {
+    const data = { name: 'test', count: 42 }
+    const result = truncateResult(data)
+    expect(result).not.toContain('truncated')
+    expect(JSON.parse(result)).toEqual(data)
+  })
+
+  it('handles circular references', () => {
+    const obj: Record<string, unknown> = { name: 'test' }
+    obj.self = obj
+    const result = truncateResult(obj)
+    expect(result).toContain('[Circular]')
+    expect(result).toContain('test')
+  })
+
+  it('handles non-serializable values', () => {
+    const result = truncateResult(BigInt(42))
+    expect(typeof result).toBe('string')
+  })
+
+  it('handles nested objects', () => {
+    const data = {
+      company: {
+        name: 'ACME',
+        address: { city: 'New York', country: 'US' },
+        contacts: [{ name: 'John' }, { name: 'Jane' }],
+      },
+    }
+    const result = truncateResult(data)
+    const parsed = JSON.parse(result)
+    expect(parsed.company.address.city).toBe('New York')
+    expect(parsed.company.contacts).toHaveLength(2)
+  })
+})

package/src/modules/ai_assistant/lib/api-endpoint-index.ts

@@ -54,6 +54,11 @@ export const API_ENDPOINT_ENTITY = API_ENDPOINT_ENTITY_ID
 let endpointsCache: ApiEndpoint[] | null = null
 let endpointsByOperationId: Map<string, ApiEndpoint> | null = null
 
+/**
+ * In-memory cache of the raw OpenAPI spec document (for Code Mode search tool)
+ */
+let rawSpecCache: OpenApiDocument | null = null
+
 /**
  * Get all parsed API endpoints (cached)
  */
@@ -76,6 +81,143 @@ export async function getEndpointByOperationId(operationId: string): Promise<Api
   return endpointsByOperationId?.get(operationId) ?? null
 }
 
+/**
+ * Get the raw OpenAPI spec document (cached).
+ * Uses the same 3-tier loading strategy as parseApiEndpoints():
+ * generated JSON → module registry → HTTP fetch.
+ */
+export async function getRawOpenApiSpec(): Promise<OpenApiDocument | null> {
+  if (rawSpecCache) return rawSpecCache
+  rawSpecCache = await loadRawOpenApiSpec()
+  return rawSpecCache
+}
+
+/**
+ * Set the raw OpenAPI spec cache directly.
+ * Used by servers that want to inject a pre-built spec.
+ */
+export function setRawSpecCache(doc: OpenApiDocument): void {
+  rawSpecCache = doc
+}
+
+/**
+ * Clear the raw OpenAPI spec cache.
+ */
+export function clearRawSpecCache(): void {
+  rawSpecCache = null
+}
+
+/**
+ * Load the rich OpenAPI spec, skipping Tier 1 (static JSON) which lacks requestBody schemas.
+ * Prefers Tier 2 (runtime module registry) which has full Zod-converted schemas.
+ * Falls back to Tier 1 then Tier 3 if needed.
+ */
+export async function loadRichOpenApiSpec(): Promise<OpenApiDocument | null> {
+  if (rawSpecCache) return rawSpecCache
+
+  // Tier 2 first: Module registry (has full Zod-converted schemas)
+  try {
+    const { getModules } = await import('@open-mercato/shared/lib/modules/registry')
+    const modules: Module[] = getModules()
+    const modulesWithApis = modules.filter((m) => m.apis && m.apis.length > 0)
+
+    if (modulesWithApis.length > 0) {
+      const doc = buildOpenApiDocument(modules, {
+        title: 'Open Mercato API',
+        version: '1.0.0',
+        servers: [{ url: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000' }],
+      })
+      console.error(`[API Index] Rich OpenAPI spec built from ${modulesWithApis.length} modules (Tier 2)`)
+      rawSpecCache = doc
+      return doc
+    }
+  } catch {
+    // Registry not available — fall through
+  }
+
+  // Fall back to standard 3-tier loading (Tier 1 → Tier 3)
+  rawSpecCache = await loadRawOpenApiSpec()
+  return rawSpecCache
+}
+
+/**
+ * Load raw OpenAPI spec using the 3-tier strategy.
+ */
+async function loadRawOpenApiSpec(): Promise<OpenApiDocument | null> {
+  // Tier 1: Generated JSON file
+  try {
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+    const { findAppRoot, findAllApps } = await import('@open-mercato/shared/lib/bootstrap/appResolver')
+
+    let appRoot = findAppRoot()
+    if (!appRoot) {
+      let current = process.cwd()
+      while (current !== path.dirname(current)) {
+        const appsDir = path.join(current, 'apps')
+        if (fs.existsSync(appsDir)) {
+          const apps = findAllApps(current)
+          if (apps.length > 0) {
+            appRoot = apps[0]
+            break
+          }
+        }
+        current = path.dirname(current)
+      }
+    }
+
+    if (appRoot) {
+      const jsonPath = path.join(appRoot.generatedDir, 'openapi.generated.json')
+      if (fs.existsSync(jsonPath)) {
+        const doc = JSON.parse(fs.readFileSync(jsonPath, 'utf-8')) as OpenApiDocument
+        console.error(`[API Index] Raw OpenAPI spec loaded from ${jsonPath}`)
+        return doc
+      }
+    }
+  } catch (error) {
+    console.error('[API Index] Raw spec from JSON failed:', error instanceof Error ? error.message : error)
+  }
+
+  // Tier 2: Module registry
+  try {
+    const { getModules } = await import('@open-mercato/shared/lib/modules/registry')
+    const modules: Module[] = getModules()
+    const modulesWithApis = modules.filter((m) => m.apis && m.apis.length > 0)
+
+    if (modulesWithApis.length > 0) {
+      const doc = buildOpenApiDocument(modules, {
+        title: 'Open Mercato API',
+        version: '1.0.0',
+        servers: [{ url: process.env.NEXT_PUBLIC_APP_URL || 'http://localhost:3000' }],
+      })
+      console.error(`[API Index] Raw OpenAPI spec built from ${modulesWithApis.length} modules`)
+      return doc
+    }
+  } catch {
+    // Registry not available
+  }
+
+  // Tier 3: HTTP fetch
+  const baseUrl =
+    process.env.NEXT_PUBLIC_API_BASE_URL ||
+    process.env.NEXT_PUBLIC_APP_URL ||
+    process.env.APP_URL ||
+    'http://localhost:3000'
+
+  try {
+    const response = await fetch(`${baseUrl}/api/docs/openapi`)
+    if (response.ok) {
+      const doc = (await response.json()) as OpenApiDocument
+      console.error('[API Index] Raw OpenAPI spec fetched via HTTP')
+      return doc
+    }
+  } catch (error) {
+    console.error('[API Index] Raw spec HTTP fetch failed:', error instanceof Error ? error.message : error)
+  }
+
+  return null
+}
+
 /**
  * Parse endpoints from generated OpenAPI JSON file (for CLI context).
  * This is generated by `yarn modules:prepare` or `yarn generate all`.
@@ -484,6 +626,7 @@ function searchEndpointsFallback(
 export function clearEndpointCache(): void {
   endpointsCache = null
   endpointsByOperationId = null
+  rawSpecCache = null
 }
 
 /**