@alumbwe/anvil 1.0.0 → 1.0.1

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

@@ -1,167 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,421 +0,0 @@
-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')
-  })
-})