@alumbwe/anvil 1.0.0

package/src/utils/__tests__/lazy-response-ads.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test } from 'bun:test'
+
+import {
+  createLazyResponseAdQueue,
+  getResponseAdForSlot,
+  MAX_RESPONSE_AD_POOL_SIZE,
+  requestLazyResponseAds,
+  responseAdDisplayCount,
+} from '../lazy-response-ads'
+
+type TestAd = { impUrl: string; clickUrl?: string }
+
+describe('requestLazyResponseAds', () => {
+  test('fetches only when slots become eligible and caps the pool at four', async () => {
+    const queue = createLazyResponseAdQueue<TestAd>()
+    const shown: TestAd[] = []
+    let fetchCount = 0
+    const fetchOne = async () => ({ impUrl: `imp-${++fetchCount}` })
+
+    expect(fetchCount).toBe(0)
+    expect(
+      requestLazyResponseAds({
+        queue,
+        messageId: 'ai-1',
+        count: 0,
+        fetchOne,
+        onAd: (ad) => shown.push(ad),
+      }),
+    ).toBeNull()
+    expect(fetchCount).toBe(0)
+
+    await requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 1,
+      fetchOne,
+      onAd: (ad) => shown.push(ad),
+    })
+    expect(fetchCount).toBe(1)
+
+    await requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 10,
+      fetchOne,
+      onAd: (ad) => shown.push(ad),
+    })
+    expect(fetchCount).toBe(MAX_RESPONSE_AD_POOL_SIZE)
+    expect(shown).toHaveLength(MAX_RESPONSE_AD_POOL_SIZE)
+
+    await requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 100,
+      fetchOne,
+      onAd: (ad) => shown.push(ad),
+    })
+    expect(fetchCount).toBe(MAX_RESPONSE_AD_POOL_SIZE)
+  })
+
+  test('does not retry no-fill or duplicate results for the same slots', async () => {
+    const queue = createLazyResponseAdQueue<TestAd>()
+    const shown: TestAd[] = []
+    const results: Array<TestAd | null> = [
+      null,
+      { impUrl: 'same' },
+      { impUrl: 'same' },
+    ]
+    let fetchCount = 0
+
+    await requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 3,
+      fetchOne: async () => results[fetchCount++] ?? null,
+      onAd: (ad) => shown.push(ad),
+    })
+
+    expect(fetchCount).toBe(3)
+    expect(shown).toEqual([{ impUrl: 'same' }])
+
+    await requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 3,
+      fetchOne: async () => {
+        fetchCount++
+        return { impUrl: 'new' }
+      },
+      onAd: (ad) => shown.push(ad),
+    })
+    expect(fetchCount).toBe(3)
+  })
+
+  test('extends an in-flight queue when more slots become eligible', async () => {
+    const queue = createLazyResponseAdQueue<TestAd>()
+    const shown: TestAd[] = []
+    let fetchCount = 0
+    let releaseFirst!: () => void
+    const firstFetchBlocked = new Promise<void>((resolve) => {
+      releaseFirst = resolve
+    })
+    const fetchOne = async () => {
+      const current = ++fetchCount
+      if (current === 1) await firstFetchBlocked
+      return { impUrl: `imp-${current}` }
+    }
+
+    const firstTask = requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 1,
+      fetchOne,
+      onAd: (ad) => shown.push(ad),
+    })
+    const extendedTask = requestLazyResponseAds({
+      queue,
+      messageId: 'ai-1',
+      count: 3,
+      fetchOne,
+      onAd: (ad) => shown.push(ad),
+    })
+
+    expect(extendedTask).toBe(firstTask)
+    releaseFirst()
+    await extendedTask
+    expect(fetchCount).toBe(3)
+    expect(shown.map((ad) => ad.impUrl)).toEqual(['imp-1', 'imp-2', 'imp-3'])
+  })
+})
+
+describe('repeated response ad pool', () => {
+  const ads: TestAd[] = Array.from(
+    { length: MAX_RESPONSE_AD_POOL_SIZE },
+    (_, i) => ({
+      impUrl: `imp-${i + 1}`,
+      clickUrl: `https://click.example/${i + 1}`,
+    }),
+  )
+
+  test('waits for the distinct pool, then fills every eligible slot', () => {
+    expect(responseAdDisplayCount({ eligibleCount: 10, poolSize: 0 })).toBe(0)
+    expect(responseAdDisplayCount({ eligibleCount: 10, poolSize: 3 })).toBe(3)
+    expect(responseAdDisplayCount({ eligibleCount: 10, poolSize: 4 })).toBe(10)
+  })
+
+  test('repeats the same four ad objects and click URLs in order', () => {
+    const sequence = Array.from({ length: 10 }, (_, slot) =>
+      getResponseAdForSlot(ads, slot),
+    )
+
+    expect(sequence.map((ad) => ad?.impUrl)).toEqual([
+      'imp-1',
+      'imp-2',
+      'imp-3',
+      'imp-4',
+      'imp-1',
+      'imp-2',
+      'imp-3',
+      'imp-4',
+      'imp-1',
+      'imp-2',
+    ])
+    expect(sequence[0]).toBe(sequence[4])
+    expect(sequence[0]?.clickUrl).toBe(sequence[4]?.clickUrl)
+  })
+})

package/src/utils/__tests__/log-shipper.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, test } from 'bun:test'
+
+import { ensureCliTestEnv } from '../../__tests__/test-utils'
+
+import type { LogRecordInput } from '@anvil/common/schemas/logs'
+
+ensureCliTestEnv()
+
+const { createClientLogFlusher } = await import('../log-shipper')
+
+describe('client log draining', () => {
+  test('waits for an active request and drains every buffered batch', async () => {
+    let releaseFirstRequest: (() => void) | undefined
+    let markFirstRequestStarted: (() => void) | undefined
+    const firstRequestStarted = new Promise<void>((resolve) => {
+      markFirstRequestStarted = resolve
+    })
+    const firstRequestGate = new Promise<void>((resolve) => {
+      releaseFirstRequest = resolve
+    })
+    const pending: LogRecordInput[] = Array.from(
+      { length: 101 },
+      (_, index) => ({ level: 'info', message: `record-${index}` }),
+    )
+    const batchSizes: number[] = []
+    const flusher = createClientLogFlusher({
+      takeBatch: () => pending.splice(0, 50),
+      hasPending: () => pending.length > 0,
+      sendBatch: async (batch) => {
+        batchSizes.push(batch.length)
+        if (batchSizes.length === 1) {
+          markFirstRequestStarted?.()
+          await firstRequestGate
+        }
+      },
+    })
+
+    void flusher.flush()
+    await firstRequestStarted
+
+    let drainFinished = false
+    const drainPromise = flusher.drain().then(() => {
+      drainFinished = true
+    })
+    await Promise.resolve()
+    expect(drainFinished).toBe(false)
+
+    releaseFirstRequest?.()
+    await drainPromise
+
+    expect(batchSizes).toEqual([50, 50, 1])
+  })
+})

package/src/utils/__tests__/markdown-renderer.test.tsx

@@ -0,0 +1,421 @@
+import { TextAttributes } from '@opentui/core'
+import { describe, expect, test } from 'bun:test'
+import React from 'react'
+
+import { renderMarkdown, renderStreamingMarkdown } from '../markdown-renderer'
+
+type El = React.ReactElement<Record<string, unknown>>
+
+const flattenNodes = (input: unknown): React.ReactNode[] => {
+  const result: React.ReactNode[] = []
+
+  const visit = (value: unknown): void => {
+    if (value === null || value === undefined || typeof value === 'boolean') {
+      return
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach(visit)
+      return
+    }
+
+    if (React.isValidElement(value) && value.type === React.Fragment) {
+      visit((value as El).props.children)
+      return
+    }
+
+    result.push(value as React.ReactNode)
+  }
+
+  visit(input)
+  return result
+}
+
+const flattenChildren = (value: unknown): React.ReactNode[] =>
+  flattenNodes(value)
+
+describe('markdown renderer', () => {
+  test('renders bold and italic emphasis', () => {
+    const output = renderMarkdown('Hello **bold** and *italic*!')
+    const nodes = flattenNodes(output)
+
+    expect(nodes[0]).toBe('Hello ')
+
+    const bold = nodes[1] as El
+    expect(bold.props.attributes).toBe(TextAttributes.BOLD)
+    expect(flattenChildren(bold.props.children)).toEqual(['bold'])
+
+    expect(nodes[2]).toBe(' and ')
+
+    const italic = nodes[3] as El
+    expect(italic.props.attributes).toBe(TextAttributes.ITALIC)
+    expect(flattenChildren(italic.props.children)).toEqual(['italic'])
+
+    expect(nodes[4]).toBe('!')
+  })
+
+  test('renders inline code with palette colors', () => {
+    const output = renderMarkdown('Use `ls` to list files.')
+    const nodes = flattenNodes(output)
+
+    expect(nodes[0]).toBe('Use ')
+
+    const inlineCode = nodes[1] as El
+    expect(inlineCode.props.fg).toBe('#86efac')
+    expect(inlineCode.props.bg).toBe('#0d1117')
+    expect(flattenChildren(inlineCode.props.children)).toEqual([' ls '])
+
+    expect(nodes[2]).toBe(' to list files.')
+  })
+
+  test('renders headings with color and bold attribute', () => {
+    const output = renderMarkdown('# Heading One')
+    const nodes = flattenNodes(output)
+
+    const heading = nodes[0] as El
+    expect(heading.props.attributes).toBe(TextAttributes.BOLD)
+    expect(heading.props.fg).toBe('magenta')
+    expect(flattenChildren(heading.props.children)).toEqual(['Heading One'])
+  })
+
+  test('renders inline emphasis inside headings without extra spacing', () => {
+    const output = renderMarkdown(
+      '# Other**.github/** - GitHub workflows and config',
+    )
+    const nodes = flattenNodes(output)
+
+    const heading = nodes[0] as El
+    const contents = flattenChildren(heading.props.children)
+
+    expect(contents[0]).toBe('Other')
+
+    const strong = contents[1] as El
+    expect(strong.props.attributes).toBe(TextAttributes.BOLD)
+    expect(flattenChildren(strong.props.children)).toEqual(['.github/'])
+
+    expect(contents[2]).toBe(' - GitHub workflows and config')
+  })
+
+  test('renders blockquotes with prefix', () => {
+    const output = renderMarkdown('> note')
+    const nodes = flattenNodes(output)
+
+    const prefixSpan = nodes[0] as El
+    expect(prefixSpan.props.fg).toBe('gray')
+    expect(flattenChildren(prefixSpan.props.children)).toEqual(['> '])
+
+    const textSpan = nodes[1] as El
+    expect(textSpan.props.fg).toBe('gray')
+    expect(flattenChildren(textSpan.props.children)).toEqual(['note'])
+  })
+
+  test('renders lists with bullet markers', () => {
+    const output = renderMarkdown('- first\n- second')
+    const nodes = flattenNodes(output)
+
+    const bulletSpans = nodes.filter(
+      (node): node is El =>
+        React.isValidElement(node) &&
+        node.type === 'span' &&
+        flattenChildren((node as El).props.children).join('') === '- ',
+    )
+
+    expect(bulletSpans).toHaveLength(2)
+    bulletSpans.forEach((span) => expect(span.props.fg).toBe('white'))
+
+    const textNodes = nodes
+      .filter((node): node is string => typeof node === 'string')
+      .map((value) => value.trim())
+      .filter(Boolean)
+    expect(textNodes).toContain('first')
+    expect(textNodes).toContain('second')
+  })
+
+  test('renders markdown without closing code fence while streaming', () => {
+    const content = '**done**\n```js\nconsole.log('
+    const output = renderStreamingMarkdown(content)
+    const nodes = flattenNodes(output)
+
+    const boldNode = nodes.find(
+      (node): node is El =>
+        React.isValidElement(node) &&
+        (node as El).props !== undefined &&
+        (node as El).props.attributes === TextAttributes.BOLD,
+    )
+
+    expect(boldNode).toBeDefined()
+    expect(flattenChildren(boldNode!.props.children)).toEqual(['done'])
+    expect(nodes[nodes.length - 1]).toBe('```js\nconsole.log(')
+  })
+
+  test('renders strikethrough text with GFM', () => {
+    const output = renderMarkdown('This is ~~deleted~~ text')
+    const nodes = flattenNodes(output)
+
+    expect(nodes[0]).toBe('This is ')
+
+    const strikethrough = nodes[1] as El
+    expect(strikethrough.props.attributes).toBe(TextAttributes.DIM)
+    expect(flattenChildren(strikethrough.props.children)).toEqual(['deleted'])
+
+    expect(nodes[2]).toBe(' text')
+  })
+
+  test('renders task lists with GFM', () => {
+    const output = renderMarkdown('- [ ] Todo\n- [x] Done')
+    const nodes = flattenNodes(output)
+
+    const checkboxSpans = nodes.filter(
+      (node): node is El =>
+        React.isValidElement(node) &&
+        node.type === 'span' &&
+        (flattenChildren((node as El).props.children).join('') === '[ ] ' ||
+          flattenChildren((node as El).props.children).join('') === '[x] '),
+    )
+
+    expect(checkboxSpans).toHaveLength(2)
+  })
+
+  test('renders tables with GFM', () => {
+    const markdown = `| Name | Age |
+| ---- | --- |
+| John | 30  |
+| Jane | 25  |`
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    // Check that table structure is rendered with box-drawing characters
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    expect(textContent).toContain('Name')
+    expect(textContent).toContain('Age')
+    expect(textContent).toContain('John')
+    expect(textContent).toContain('Jane')
+    expect(textContent).toContain('30')
+    expect(textContent).toContain('25')
+    // Table uses box-drawing characters for borders
+    expect(textContent).toContain('│')
+    expect(textContent).toContain('─')
+  })
+
+  test('renders code fence followed by text with quotes correctly', () => {
+    const markdown = `\`\`\`bash
+# Start using it
+anvil "add a new feature to handle user authentication"
+\`\`\``
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    // Get the text content from all nodes
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // Should contain the complete command text
+    expect(textContent).toContain('# Start using it')
+    expect(textContent).toContain(
+      'anvil "add a new feature to handle user authentication"',
+    )
+
+    // Should NOT have quotes concatenated with backticks
+    expect(textContent).not.toContain('it"')
+    expect(textContent).not.toContain('```"')
+  })
+
+  test('renders inline code followed by quotes correctly', () => {
+    const markdown = 'Use `anvil "fix bug"` to fix bugs.'
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    expect(nodes[0]).toBe('Use ')
+
+    const inlineCode = nodes[1] as El
+    expect(inlineCode.props.fg).toBe('#86efac')
+    const inlineContent = flattenChildren(inlineCode.props.children).join('')
+    expect(inlineContent).toContain('anvil "fix bug"')
+
+    expect(nodes[2]).toBe(' to fix bugs.')
+
+    // Verify quotes are inside the inline code, not concatenated after
+    expect(inlineContent).toMatch(/anvil\s+"fix bug"/)
+  })
+
+  test('renders multiple code blocks with text between them', () => {
+    const markdown = `First block:
+
+\`\`\`js
+console.log("hello")
+\`\`\`
+
+Middle text with "quotes"
+
+\`\`\`js
+console.log("world")
+\`\`\``
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // All content should be present
+    expect(textContent).toContain('First block:')
+    expect(textContent).toContain('console.log("hello")')
+    expect(textContent).toContain('Middle text with "quotes"')
+    expect(textContent).toContain('console.log("world")')
+
+    // Verify no quote concatenation issues
+    expect(textContent).not.toContain('```"')
+    expect(textContent).not.toContain('"```')
+  })
+
+  test('renders code fence with command and quotes on same line', () => {
+    const markdown = `\`\`\`bash
+anvil "implement feature" --verbose
+\`\`\``
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // Should preserve the complete command with quotes
+    expect(textContent).toContain('anvil "implement feature" --verbose')
+    expect(textContent).not.toContain('```"')
+  })
+
+  test('renders inline code with special characters correctly', () => {
+    const markdown = 'Run `git commit -m "fix: bug"` to commit.'
+    const output = renderMarkdown(markdown)
+    const nodes = flattenNodes(output)
+
+    const inlineCode = nodes[1] as El
+    const inlineContent = flattenChildren(inlineCode.props.children).join('')
+
+    // Should preserve quotes and special characters within inline code
+    expect(inlineContent).toContain('git commit -m "fix: bug"')
+    expect(nodes[2]).toBe(' to commit.')
+  })
+
+  test('wraps table columns when content exceeds available width', () => {
+    // Table with very long content that should be wrapped
+    const markdown = `| ID | This is a very long column header that should wrap |
+| -- | -------------------------------------------------- |
+| 1  | This cell has extremely long content that definitely exceeds the width |`
+    
+    // Use a narrow codeBlockWidth to force wrapping
+    const output = renderMarkdown(markdown, { codeBlockWidth: 50 })
+    const nodes = flattenNodes(output)
+
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // Should NOT contain ellipsis - content wraps instead of truncating
+    expect(textContent).not.toContain('…')
+    // The short column content should be present
+    expect(textContent).toContain('ID')
+    expect(textContent).toContain('1')
+    // Box-drawing characters should still be present
+    expect(textContent).toContain('│')
+    expect(textContent).toContain('─')
+    // The full content should be present across wrapped lines
+    expect(textContent).toContain('long')
+    expect(textContent).toContain('header')
+    expect(textContent).toContain('wrap')
+    expect(textContent).toContain('extremely')
+    expect(textContent).toContain('exceeds')
+  })
+
+  test('does not wrap table columns when content fits available width', () => {
+    const markdown = `| Name | Age |
+| ---- | --- |
+| John | 30  |`
+    
+    // Use a wide codeBlockWidth so no wrapping is needed
+    const output = renderMarkdown(markdown, { codeBlockWidth: 80 })
+    const nodes = flattenNodes(output)
+
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // All content should be present in full
+    expect(textContent).toContain('Name')
+    expect(textContent).toContain('Age')
+    expect(textContent).toContain('John')
+    expect(textContent).toContain('30')
+  })
+
+  test('wraps and shows full content when table is too wide', () => {
+    // Three columns of roughly equal width
+    const markdown = `| Column One | Column Two | Column Three |
+| ---------- | ---------- | ------------ |
+| Value1     | Value2     | Value3       |`
+    
+    // Very narrow width to force significant wrapping
+    const output = renderMarkdown(markdown, { codeBlockWidth: 30 })
+    const nodes = flattenNodes(output)
+
+    const textContent = nodes
+      .map((node) => {
+        if (typeof node === 'string') return node
+        if (React.isValidElement(node)) {
+          return flattenChildren((node as El).props.children).join('')
+        }
+        return ''
+      })
+      .join('')
+
+    // Table structure should still be present
+    expect(textContent).toContain('│')
+    expect(textContent).toContain('┌')
+    expect(textContent).toContain('└')
+    // Full content should still be visible (wrapped, not truncated)
+    expect(textContent).not.toContain('…')
+    // All values should be present
+    expect(textContent).toContain('Value1')
+    expect(textContent).toContain('Value2')
+    expect(textContent).toContain('Value3')
+  })
+})