@alumbwe/anvil 1.0.42 → 1.0.50

package/src/commands/__tests__/process-diagnostics.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  collectProcessDiagnostics,
-  formatProcessDiagnostics,
-} from '../process-diagnostics'
-
-import type { ProcessDiagnosticsSnapshot } from '../process-diagnostics'
-
-const snapshot: ProcessDiagnosticsSnapshot = {
-  product: 'Anvil',
-  version: '1.2.3',
-  runtime: 'Bun 1.3.14',
-  platform: 'darwin',
-  architecture: 'arm64',
-  uptimeSeconds: 3_661,
-  cpuUserMicros: 1_500_000,
-  cpuSystemMicros: 500_000,
-  memory: {
-    rss: 100 * 1024 * 1024,
-    heapTotal: 50 * 1024 * 1024,
-    heapUsed: 25 * 1024 * 1024,
-    external: 0,
-    arrayBuffers: 0,
-  },
-  parentPid: 100,
-  cliPid: 200,
-  watchdog: { armed: true, external: false, pid: 250 },
-  activeTools: [{ pid: 300, processGroupId: 300 }],
-}
-
-describe('process diagnostics', () => {
-  test('formats owned process IDs without sensitive command data', () => {
-    const output = formatProcessDiagnostics(snapshot)
-
-    expect(output).toContain('### Anvil process diagnostics')
-    expect(output).toContain('CLI uptime: 01:01:01')
-    expect(output).toContain('parent/wrapper: PID 100')
-    expect(output).toContain('CLI binary: PID 200')
-    expect(output).toContain('terminal watchdog: PID 250')
-    expect(output).toContain('PID 300, PGID 300')
-    expect(output).toContain(
-      'Command lines and environment variables are omitted',
-    )
-  })
-
-  test('collects runtime-local process information', () => {
-    const result = collectProcessDiagnostics()
-
-    expect(result.cliPid).toBe(process.pid)
-    expect(result.parentPid).toBe(process.ppid)
-    expect(result.memory.rss).toBeGreaterThan(0)
-  })
-})

package/src/commands/__tests__/prompt-builders.test.ts

@@ -1,28 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  buildPlanPrompt,
-  buildReviewPrompt,
-  buildReviewPromptFromArgs,
-} from '../prompt-builders'
-
-describe('prompt-builders base prompts', () => {
-  // These used to branch on whether the user had connected a ChatGPT account,
-  // delegating the deep-thinking step to @thinker-gpt if so. That integration
-  // is gone, so there is one branch: the user's selected model does the work.
-  test('/plan runs on the selected model', () => {
-    const prompt = buildPlanPrompt('add OAuth login')
-    expect(prompt).not.toContain('@thinker-gpt')
-    expect(prompt).toContain('think carefully about how to implement')
-    expect(prompt).toContain('add OAuth login')
-  })
-
-  test('/review runs on the selected model', () => {
-    expect(buildReviewPrompt('uncommitted')).not.toContain('@thinker-gpt')
-    expect(buildReviewPrompt('uncommitted')).toContain('carefully review')
-    expect(buildReviewPromptFromArgs('the parser')).not.toContain(
-      '@thinker-gpt',
-    )
-    expect(buildReviewPromptFromArgs('the parser')).toContain('the parser')
-  })
-})

package/src/commands/__tests__/router-input.test.ts

@@ -1,298 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { SLASH_COMMANDS } from '../../data/slash-commands'
-import { findCommand, COMMAND_REGISTRY } from '../command-registry'
-import {
-  parseCommand,
-  isSlashCommand,
-  parseCommandInput,
-} from '../router-utils'
-
-describe('router-utils', () => {
-  describe('isSlashCommand', () => {
-    test('returns true for input starting with /', () => {
-      expect(isSlashCommand('/help')).toBe(true)
-      expect(isSlashCommand('/logout')).toBe(true)
-      expect(isSlashCommand('/ref-abc123')).toBe(true)
-      expect(isSlashCommand('/')).toBe(true)
-    })
-
-    test('returns false for input not starting with /', () => {
-      expect(isSlashCommand('help')).toBe(false)
-      expect(isSlashCommand('logout')).toBe(false)
-      expect(isSlashCommand('ref-abc123')).toBe(false)
-      expect(isSlashCommand('')).toBe(false)
-    })
-
-    test('handles whitespace correctly', () => {
-      expect(isSlashCommand('  /help')).toBe(true)
-      expect(isSlashCommand('  help')).toBe(false)
-    })
-  })
-
-  describe('parseCommand', () => {
-    test('extracts command from slashed input', () => {
-      expect(parseCommand('/help')).toBe('help')
-      expect(parseCommand('/logout')).toBe('logout')
-      expect(parseCommand('/usage')).toBe('usage')
-    })
-
-    test('returns empty string for unslashed input (not a slash command)', () => {
-      expect(parseCommand('help')).toBe('')
-      expect(parseCommand('logout')).toBe('')
-      expect(parseCommand('usage')).toBe('')
-      expect(parseCommand('login to my database')).toBe('')
-    })
-
-    test('extracts first word as command when there are arguments', () => {
-      expect(parseCommand('/help me')).toBe('help')
-      expect(parseCommand('/usage stats')).toBe('usage')
-    })
-
-    test('converts command to lowercase', () => {
-      expect(parseCommand('/HELP')).toBe('help')
-      expect(parseCommand('/LOGOUT')).toBe('logout')
-      expect(parseCommand('/UsAgE')).toBe('usage')
-    })
-
-    test('handles empty string', () => {
-      expect(parseCommand('')).toBe('')
-    })
-
-    test('handles whitespace-only input', () => {
-      expect(parseCommand('   ')).toBe('')
-    })
-
-    test('handles only slash', () => {
-      expect(parseCommand('/')).toBe('')
-    })
-
-    test('handles multiple spaces between words', () => {
-      expect(parseCommand('/help   me')).toBe('help')
-    })
-  })
-
-  describe('parseCommandInput', () => {
-    test('returns command info for exact slashless matches', () => {
-      expect(parseCommandInput('init')).toEqual({
-        command: 'init',
-        args: '',
-        implicitCommand: true,
-      })
-      expect(parseCommandInput('new')).toEqual({
-        command: 'new',
-        args: '',
-        implicitCommand: true,
-      })
-    })
-
-    test('is case-insensitive and trims whitespace for slashless matches', () => {
-      expect(parseCommandInput('INIT')).toEqual({
-        command: 'init',
-        args: '',
-        implicitCommand: true,
-      })
-      expect(parseCommandInput('  new  ')).toEqual({
-        command: 'new',
-        args: '',
-        implicitCommand: true,
-      })
-    })
-
-    test('returns null for slashless commands with arguments', () => {
-      expect(parseCommandInput('init something')).toBe(null)
-      expect(parseCommandInput('new my message')).toBe(null)
-    })
-
-    test('returns null for commands not configured for slashless invocation', () => {
-      expect(parseCommandInput('usage')).toBe(null)
-      expect(parseCommandInput('bash')).toBe(null)
-      expect(parseCommandInput('feedback')).toBe(null)
-    })
-
-    test('distinguishes slashed and slashless invocation', () => {
-      expect(parseCommandInput('/init')).toEqual({
-        command: 'init',
-        args: '',
-        implicitCommand: false,
-      })
-    })
-
-    test('does not match aliases for slashless commands', () => {
-      const newCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'new')
-      for (const alias of newCmd?.aliases ?? []) {
-        expect(parseCommandInput(alias)).toBe(null)
-      }
-    })
-
-    test('returns null for empty input', () => {
-      expect(parseCommandInput('')).toBe(null)
-      expect(parseCommandInput('   ')).toBe(null)
-    })
-
-    test('commands with implicitCommand are configured correctly', () => {
-      const initCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'init')
-      const newCmd = SLASH_COMMANDS.find((cmd) => cmd.id === 'new')
-
-      expect(initCmd?.implicitCommand).toBe(true)
-      expect(newCmd?.implicitCommand).toBe(true)
-    })
-
-    test('parseCommandInput matches all implicitCommand commands', () => {
-      const implicitCommands = SLASH_COMMANDS.filter((cmd) => cmd.implicitCommand)
-      for (const cmd of implicitCommands) {
-        expect(parseCommandInput(cmd.id)).toEqual({
-          command: cmd.id.toLowerCase(),
-          args: '',
-          implicitCommand: true,
-        })
-      }
-    })
-  })
-
-  describe('slash commands only work with / prefix', () => {
-    const slashCommands = [
-      'login',
-      'logout',
-      'usage',
-      'credits',
-      'exit',
-      'clear',
-      'new',
-      'init',
-      'bash',
-      'feedback',
-    ]
-
-    for (const cmd of slashCommands) {
-      test(`"/${cmd}" is recognized as slash command`, () => {
-        expect(parseCommand(`/${cmd}`)).toBe(cmd)
-      })
-
-      test(`"${cmd}" without slash is NOT a slash command (sent to agent)`, () => {
-        expect(parseCommand(cmd)).toBe('')
-      })
-    }
-  })
-
-  describe('words that look like commands but are not', () => {
-    const nonCommands = [
-      'login to my account',
-      'I need help with logout functionality',
-      'please help me',
-      'usage of this function',
-      'clear the database',
-    ]
-
-    for (const input of nonCommands) {
-      test(`"${input}" is NOT a slash command`, () => {
-        expect(parseCommand(input)).toBe('')
-      })
-    }
-  })
-
-})
-
-describe('command-registry', () => {
-  describe('findCommand', () => {
-    test('finds command by name', () => {
-      const login = findCommand('login')
-      expect(login).toBeDefined()
-      expect(login?.name).toBe('login')
-
-      const usage = findCommand('usage')
-      expect(usage).toBeDefined()
-      expect(usage?.name).toBe('usage')
-    })
-
-    test('finds command by alias', () => {
-      const credits = findCommand('credits')
-      expect(credits).toBeDefined()
-      expect(credits?.name).toBe('usage')
-
-      const modelDefault = findCommand('model:default')
-      expect(modelDefault).toBeDefined()
-      expect(modelDefault?.name).toBe('mode:default')
-
-      const quit = findCommand('quit')
-      expect(quit).toBeDefined()
-      expect(quit?.name).toBe('exit')
-
-      const signin = findCommand('signin')
-      expect(signin).toBeDefined()
-      expect(signin?.name).toBe('login')
-    })
-
-    test('returns undefined for unknown command', () => {
-      expect(findCommand('unknown')).toBeUndefined()
-      expect(findCommand('notacommand')).toBeUndefined()
-    })
-
-    test('is case insensitive', () => {
-      expect(findCommand('LOGIN')?.name).toBe('login')
-      expect(findCommand('UsAgE')?.name).toBe('usage')
-      expect(findCommand('CREDITS')?.name).toBe('usage')
-    })
-  })
-
-  describe('COMMAND_REGISTRY', () => {
-    test('all commands have unique names', () => {
-      const names = COMMAND_REGISTRY.map((c) => c.name)
-      const uniqueNames = new Set(names)
-      expect(names.length).toBe(uniqueNames.size)
-    })
-
-    test('all aliases are unique across all commands', () => {
-      const allAliases = COMMAND_REGISTRY.flatMap((c) => c.aliases)
-      const uniqueAliases = new Set(allAliases)
-      expect(allAliases.length).toBe(uniqueAliases.size)
-    })
-
-    test('no alias conflicts with command names', () => {
-      const names = new Set(COMMAND_REGISTRY.map((c) => c.name))
-      const allAliases = COMMAND_REGISTRY.flatMap((c) => c.aliases)
-      for (const alias of allAliases) {
-        expect(names.has(alias)).toBe(false)
-      }
-    })
-
-    test('slash command metadata maps to registered commands', () => {
-      const registered = new Set([
-        ...COMMAND_REGISTRY.map((c) => c.name),
-        ...COMMAND_REGISTRY.flatMap((c) => c.aliases),
-      ])
-
-      // Commands with insertText are UI-only shortcuts that insert text into
-      // the input field instead of executing a command.
-      const executableCommands = SLASH_COMMANDS.filter((cmd) => !cmd.insertText)
-
-      for (const slashCommand of executableCommands) {
-        expect(registered.has(slashCommand.id)).toBe(true)
-        for (const alias of slashCommand.aliases ?? []) {
-          expect(registered.has(alias)).toBe(true)
-        }
-      }
-    })
-
-    test('mode commands expose model aliases for slash suggestions', () => {
-      const modeCommands = SLASH_COMMANDS.filter((cmd) =>
-        cmd.id.startsWith('mode:'),
-      )
-      expect(modeCommands.length).toBeGreaterThan(0)
-
-      for (const command of modeCommands) {
-        const modeName = command.id.slice('mode:'.length)
-        expect(command.aliases).toContain(`model:${modeName}`)
-      }
-    })
-
-    test('the ChatGPT connect command is gone from both products', () => {
-      // It was anvil-only while it existed; the integration has since been
-      // removed, so neither the slash menu nor the router knows the name.
-      expect(SLASH_COMMANDS.some((cmd) => cmd.id === 'connect')).toBe(false)
-      expect(findCommand('connect')).toBeUndefined()
-      expect(findCommand('connect:chatgpt')).toBeUndefined()
-      expect(findCommand('chatgpt')).toBeUndefined()
-    })
-  })
-})

package/src/components/__tests__/ad-banner.test.tsx

@@ -1,83 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { getAdDisplayLabel, getInlineAdLayout } from '../ad-banner'
-
-describe('ad banner display label', () => {
-  test('uses the display domain when the ad has a URL', () => {
-    expect(
-      getAdDisplayLabel({
-        title: 'Example Sponsor',
-        url: 'https://www.example.com/path',
-      }),
-    ).toEqual({ text: 'example.com', variant: 'domain' })
-  })
-
-  test('uses the ad title when the ad has no URL', () => {
-    expect(
-      getAdDisplayLabel({
-        title: 'Example Sponsor',
-        url: '',
-      }),
-    ).toEqual({ text: 'Example Sponsor', variant: 'title' })
-  })
-})
-
-describe('inline ad layout', () => {
-  const ad = {
-    adText:
-      'Deploy frontends globally with zero config and preview every pull request.',
-    title: 'Vercel',
-    url: 'https://www.vercel.com/products',
-  }
-
-  test('fits the compact copy and sponsor within the card interior', () => {
-    const width = 60
-    const layout = getInlineAdLayout(ad, width)
-    const header = `${layout.title}  Ad`
-    const detail = `${layout.description}  ${layout.label} ↗`
-
-    expect(header.length).toBeLessThanOrEqual(width - 4)
-    expect(detail.length).toBeLessThanOrEqual(width - 4)
-    expect(layout.title).toBe('Vercel')
-    expect(layout.label).toBe('vercel.com')
-    expect(layout.description.endsWith('…')).toBe(true)
-  })
-
-  test('truncates long labels without starving narrow cards', () => {
-    const layout = getInlineAdLayout(
-      {
-        ...ad,
-        url: 'https://www.extraordinarily-long-sponsor-domain.example',
-      },
-      48,
-    )
-
-    expect(layout.label).toBe('extraordinari…')
-    expect(layout.description.length).toBeGreaterThan(0)
-    expect(`${layout.title}  Ad`.length).toBeLessThanOrEqual(44)
-  })
-
-  test('prioritizes copy over the destination on very narrow cards', () => {
-    const width = 47
-    const layout = getInlineAdLayout(ad, width)
-
-    expect(layout.label).toBe('')
-    expect(layout.description.length).toBe(width - 4)
-    expect(layout.description.endsWith('…')).toBe(true)
-  })
-
-  test('uses the full detail row when no destination domain is available', () => {
-    const layout = getInlineAdLayout(
-      {
-        adText: 'A Carbon ad whose tracked destination is intentionally hidden.',
-        title: 'Example Sponsor',
-        url: '',
-      },
-      40,
-    )
-
-    expect(layout.title).toBe('Example Sponsor')
-    expect(layout.label).toBe('')
-    expect(layout.description.length).toBe(36)
-  })
-})

package/src/components/__tests__/anvil-landing-heading-row.test.tsx

@@ -1,91 +0,0 @@
-import { afterEach, beforeAll, describe, expect, test } from 'bun:test'
-import { createTestRenderer } from '@opentui/core/testing'
-import { createRoot, flushSync } from '@opentui/react'
-import React from 'react'
-
-import { LandingHeadingRow } from '../anvil-landing-screen'
-import { initializeThemeStore } from '../../hooks/use-theme'
-import { getAnvilStreakLine } from '../../utils/anvil-streak-line'
-
-let cleanupRenderer: (() => void) | undefined
-
-beforeAll(() => {
-  initializeThemeStore()
-})
-
-afterEach(() => {
-  cleanupRenderer?.()
-  cleanupRenderer = undefined
-})
-
-/**
- * Mirrors the landing screen's containers around the heading row: a
- * shrink-to-fit column inside a centered, maxWidth-capped column. That shape
- * is what broke the row — with nothing wider on screen the column collapses
- * to the row's own width, leaving space-between no space to hand out.
- */
-const mountHeadingRow = async (streak: number, contentMaxWidth: number) => {
-  const setup = await createTestRenderer({ width: contentMaxWidth + 4, height: 6 })
-  const root = createRoot(setup.renderer)
-  cleanupRenderer = () => {
-    flushSync(() => root.unmount())
-    setup.renderer.destroy()
-  }
-  flushSync(() =>
-    root.render(
-      <box style={{ flexDirection: 'column', alignItems: 'center', maxWidth: contentMaxWidth }}>
-        <box style={{ flexDirection: 'column', alignItems: 'flex-start', gap: 0 }}>
-          <LandingHeadingRow
-            streakLine={getAnvilStreakLine(streak)}
-            marginBottom={1}
-          />
-        </box>
-      </box>,
-    ),
-  )
-  await setup.renderOnce()
-  return setup
-}
-
-const renderHeadingRow = async (streak: number, contentMaxWidth: number) =>
-  (await mountHeadingRow(streak, contentMaxWidth)).captureCharFrame()
-
-describe('LandingHeadingRow', () => {
-  test('keeps the streak clear of the heading when nothing wider is on screen', async () => {
-    const frame = await renderHeadingRow(18, 60)
-    const line = frame
-      .split('\n')
-      .find((row) => row.includes('Start coding for free'))!
-
-    // The bug: "Start coding for free18 day streak".
-    expect(line).not.toContain('free18')
-    expect(line).toMatch(/Start coding for free {3,}18 day streak/)
-  })
-
-  test('draws the progress dots as filled/hollow circles', async () => {
-    const frame = await renderHeadingRow(18, 60)
-
-    expect(frame).toContain('●●●●●●●+')
-  })
-
-  test('leaves the row bare for a user with no streak yet', async () => {
-    const frame = await renderHeadingRow(0, 60)
-
-    expect(frame).toContain('Start coding for free')
-    expect(frame).not.toContain('day streak')
-  })
-
-  // The landing screen only hands over a streak that fits, but a resize lays
-  // the current tree out against the new width before React re-renders, so the
-  // row does get measured too narrow for a frame. As a space-between flex row
-  // that overflow segfaulted the native renderer — it has to survive as text.
-  test('survives being laid out narrower than its content', async () => {
-    const setup = await mountHeadingRow(18, 60)
-
-    for (const width of [34, 20, 12]) {
-      setup.resize(width, 6)
-      await setup.renderOnce()
-      expect(setup.captureCharFrame()).toContain('Start')
-    }
-  })
-})