@alumbwe/anvil 1.0.0 → 1.0.1

package/src/utils/__tests__/terminal-io.test.ts

@@ -1,137 +0,0 @@
-import { describe, expect, spyOn, test } from 'bun:test'
-import {
-  closeSync,
-  mkdtempSync,
-  openSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-
-import {
-  reportFatalErrorSync,
-  writeFileDescriptorSync,
-  writeTerminalControlSync,
-} from '../terminal-io'
-
-function captureDescriptorWrite(write: (fd: number) => void): string {
-  const directory = mkdtempSync(join(tmpdir(), 'terminal-fd-'))
-  const outputPath = join(directory, 'stderr')
-
-  try {
-    const fd = openSync(outputPath, 'w')
-    try {
-      write(fd)
-    } finally {
-      closeSync(fd)
-    }
-    return readFileSync(outputPath, 'utf8')
-  } finally {
-    rmSync(directory, { recursive: true, force: true })
-  }
-}
-
-describe('synchronous terminal I/O', () => {
-  test('writes the complete byte sequence before returning', () => {
-    const directory = mkdtempSync(join(tmpdir(), 'terminal-io-'))
-    const outputPath = join(directory, 'tty')
-    const sequence = '\x1b[?1049l\x1b[?25h'
-    writeFileSync(outputPath, '')
-
-    try {
-      expect(writeTerminalControlSync(sequence, outputPath)).toBe(true)
-      expect(readFileSync(outputPath)).toEqual(Buffer.from(sequence))
-    } finally {
-      rmSync(directory, { recursive: true, force: true })
-    }
-  })
-
-  test('returns false when the terminal cannot be opened', () => {
-    expect(writeTerminalControlSync('reset', '/path/that/does/not/exist')).toBe(
-      false,
-    )
-  })
-
-  test('writes complete diagnostic bytes to an existing descriptor', () => {
-    const output = captureDescriptorWrite((fd) => {
-      expect(writeFileDescriptorSync(fd, 'fatal: 💥\n')).toBe(true)
-    })
-
-    expect(output).toBe('fatal: 💥\n')
-  })
-
-  test('reports Error stacks synchronously to the supplied stderr descriptor', () => {
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Fatal startup error', new Error('boom'), fd)
-    })
-
-    expect(output).toStartWith('Fatal startup error: Error: boom\n')
-  })
-
-  test('reports non-Error reasons synchronously', () => {
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Unhandled rejection', 'plain reason', fd)
-    })
-
-    expect(output).toBe('Unhandled rejection: plain reason\n')
-  })
-
-  test('survives rejection reasons that cannot be stringified', () => {
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Unhandled rejection', Object.create(null), fd)
-    })
-
-    expect(output).toBe('Unhandled rejection: <unprintable error>\n')
-  })
-
-  test('survives values whose Error check and string conversion both throw', () => {
-    const { proxy, revoke } = Proxy.revocable(new Error('revoked'), {})
-    revoke()
-
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Unhandled rejection', proxy, fd)
-    })
-
-    expect(output).toBe('Unhandled rejection: <unprintable error>\n')
-  })
-
-  test('falls back to an Error message when its stack cannot be read', () => {
-    const error = new Error('readable message')
-    Object.defineProperty(error, 'stack', {
-      get: () => {
-        throw new Error('broken stack getter')
-      },
-    })
-
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Fatal error', error, fd)
-    })
-
-    expect(output).toBe('Fatal error: readable message\n')
-  })
-
-  test('falls back when an Error stack cannot be stringified', () => {
-    const error = new Error('readable message')
-    Object.defineProperty(error, 'stack', { value: Object.create(null) })
-
-    const output = captureDescriptorWrite((fd) => {
-      reportFatalErrorSync('Fatal error', error, fd)
-    })
-
-    expect(output).toBe('Fatal error: readable message\n')
-  })
-
-  test('falls back to console error when stderr is unavailable', () => {
-    const consoleError = spyOn(console, 'error').mockImplementation(() => {})
-    const error = new Error('closed stderr')
-
-    try {
-      reportFatalErrorSync('Fatal error', error, -1)
-      expect(consoleError).toHaveBeenCalledWith('Fatal error:', error)
-    } finally {
-      consoleError.mockRestore()
-    }
-  })
-})

package/src/utils/__tests__/terminal-protocol-controller.test.ts

@@ -1,119 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import {
-  installTerminalProtocolController,
-  TerminalProtocolController,
-} from '../terminal-protocol-controller'
-
-function createFixture(options: { writeSucceeds?: boolean } = {}) {
-  const controlWrites: string[] = []
-  const errors: unknown[] = []
-  let inputHandler: ((sequence: string) => boolean) | null = null
-  const renderer = {
-    prependInputHandler(handler: (sequence: string) => boolean) {
-      inputHandler = handler
-    },
-    removeInputHandler(handler: (sequence: string) => boolean) {
-      if (inputHandler === handler) inputHandler = null
-    },
-  }
-  const controller = new TerminalProtocolController(renderer, {
-    writeControl: (sequence) => {
-      controlWrites.push(sequence)
-      return options.writeSucceeds ?? true
-    },
-    onError: (error) => errors.push(error),
-  })
-
-  return {
-    renderer,
-    controller,
-    controlWrites,
-    errors,
-    dispatchInput: (sequence: string) => inputHandler?.(sequence) ?? false,
-    hasInputHandler: () => inputHandler !== null,
-  }
-}
-
-describe('TerminalProtocolController', () => {
-  test('enables focus reporting for the first subscriber and disables it for the last', () => {
-    const fixture = createFixture()
-    const first = fixture.controller.subscribeToFocus({
-      onFocusChange: () => {},
-    })
-    const second = fixture.controller.subscribeToFocus({
-      onFocusChange: () => {},
-    })
-
-    expect(fixture.controlWrites).toEqual(['\x1b[?1004h'])
-    first()
-    expect(fixture.controlWrites).toEqual(['\x1b[?1004h'])
-    second()
-    expect(fixture.controlWrites).toEqual(['\x1b[?1004h', '\x1b[?1004l'])
-  })
-
-  test('parses focus activity without consuming unrelated or focus input', () => {
-    const fixture = createFixture()
-    const focusStates: boolean[] = []
-    let supportDetections = 0
-    fixture.controller.subscribeToFocus({
-      onFocusChange: (focused) => focusStates.push(focused),
-      onSupportDetected: () => supportDetections++,
-    })
-
-    expect(fixture.dispatchInput('\x1b[O')).toBe(false)
-    expect(fixture.dispatchInput('\x1b[I')).toBe(false)
-    expect(fixture.dispatchInput('\x1b[I')).toBe(false)
-    expect(fixture.dispatchInput('\x1b[A')).toBe(false)
-    expect(focusStates).toEqual([false, true])
-    expect(supportDetections).toBe(1)
-  })
-
-  test('replays detected focus state to a late subscriber', () => {
-    const fixture = createFixture()
-    fixture.dispatchInput('\x1b[O')
-    const focusStates: boolean[] = []
-    let supportDetections = 0
-
-    fixture.controller.subscribeToFocus({
-      onFocusChange: (focused) => focusStates.push(focused),
-      onSupportDetected: () => supportDetections++,
-    })
-
-    expect(focusStates).toEqual([false])
-    expect(supportDetections).toBe(1)
-  })
-
-  test('reports control-write failures without breaking subscriptions', () => {
-    const fixture = createFixture({ writeSucceeds: false })
-    const unsubscribe = fixture.controller.subscribeToFocus({
-      onFocusChange: () => {},
-    })
-    unsubscribe()
-
-    expect(fixture.controlWrites).toEqual(['\x1b[?1004h', '\x1b[?1004l'])
-    expect(fixture.errors).toHaveLength(2)
-  })
-
-  test('disposal removes the input handler and makes late cleanup inert', () => {
-    const fixture = createFixture()
-    const unsubscribe = fixture.controller.subscribeToFocus({
-      onFocusChange: () => {},
-    })
-    fixture.controller.dispose()
-    unsubscribe()
-
-    expect(fixture.hasInputHandler()).toBe(false)
-    expect(fixture.controlWrites).toEqual(['\x1b[?1004h'])
-  })
-
-  test('allows only one installed controller at a time', () => {
-    const fixture = createFixture()
-    fixture.controller.dispose()
-    const controller = installTerminalProtocolController(fixture.renderer)
-    expect(() => installTerminalProtocolController(fixture.renderer)).toThrow(
-      'already installed',
-    )
-    controller.dispose()
-  })
-})

package/src/utils/__tests__/text-layout.test.ts

@@ -1,82 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { computeInputLayoutMetrics } from '../text-layout'
-
-describe('computeInputLayoutMetrics', () => {
-  test('single-line content keeps height at 1 without gutter', () => {
-    const metrics = computeInputLayoutMetrics({
-      layoutContent: 'hello world',
-      cursorProbe: 'hello world',
-      cols: 40,
-      maxHeight: 5,
-    })
-
-    expect(metrics.heightLines).toBe(1)
-    expect(metrics.gutterEnabled).toBe(false)
-  })
-
-  test('counts leading indentation toward wrapped line width', () => {
-    const metrics = computeInputLayoutMetrics({
-      layoutContent: '    indent',
-      cursorProbe: '    indent',
-      cols: 8,
-      maxHeight: 2,
-    })
-
-    expect(metrics.heightLines).toBe(2)
-    expect(metrics.gutterEnabled).toBe(false)
-  })
-
-  test('adds gutter when two lines and cursor on second line', () => {
-    const layoutContent = 'first line\nsecond line'
-    const cursorProbe = 'first line\nsecond line'
-
-    const metrics = computeInputLayoutMetrics({
-      layoutContent,
-      cursorProbe,
-      cols: 40,
-      maxHeight: 5,
-    })
-
-    expect(metrics.heightLines).toBe(3)
-    expect(metrics.gutterEnabled).toBe(true)
-  })
-
-  test('omits gutter when maxHeight would be exceeded', () => {
-    const metrics = computeInputLayoutMetrics({
-      layoutContent: 'a long first line\nand a second line',
-      cursorProbe: 'a long first line\nand a second line',
-      cols: 80,
-      maxHeight: 2,
-    })
-
-    expect(metrics.heightLines).toBe(2)
-    expect(metrics.gutterEnabled).toBe(false)
-  })
-
-  test('respects a minimum height constraint', () => {
-    const metrics = computeInputLayoutMetrics({
-      layoutContent: 'short',
-      cursorProbe: 'short',
-      cols: 40,
-      maxHeight: 5,
-      minHeight: 3,
-    })
-
-    expect(metrics.heightLines).toBe(3)
-    expect(metrics.gutterEnabled).toBe(false)
-  })
-
-  test('caps the minimum height at the max height', () => {
-    const metrics = computeInputLayoutMetrics({
-      layoutContent: 'tiny',
-      cursorProbe: 'tiny',
-      cols: 40,
-      maxHeight: 2,
-      minHeight: 5,
-    })
-
-    expect(metrics.heightLines).toBe(2)
-    expect(metrics.gutterEnabled).toBe(false)
-  })
-})

package/src/utils/__tests__/theme-platform-detection.test.ts

@@ -1,125 +0,0 @@
-/**
- * detectPlatformTheme() is the last-resort theme guess, reached after the
- * VS Code / JetBrains resolvers and (on POSIX) the OSC 11 background-color
- * query.
- *
- * On Windows it used to shell out to PowerShell twice — once for
- * (Get-Host).UI.RawUI.BackgroundColor and once to read HKCU
- * Themes\Personalize. Together those produced a "Suspicious PowerShell command
- * line" detection and a `cmd /d /s /c REG.exe QUERY` child in Windows
- * Defender's process tree on real user machines. The Windows branch is gone;
- * these tests hold that line, because the failure mode is invisible locally —
- * the code still "works", it just gets the CLI quarantined.
- *
- * Note OSC 11 does NOT currently back-fill Windows: index.tsx skips it when
- * platform === 'win32'. So on Windows this really is the end of the line and
- * 'dark' is the answer. See the comment in detectPlatformTheme.
- */
-import { afterEach, describe, expect, test } from 'bun:test'
-
-import { ensureCliTestEnv } from '../../__tests__/test-utils'
-import { detectPlatformTheme } from '../theme-system'
-
-// Without this, a throw anywhere in theme-system's import chain makes this
-// whole FILE vanish from the run instead of failing — which would silently
-// disable the very regression these tests exist to catch.
-ensureCliTestEnv()
-
-let originalPlatform: PropertyDescriptor | undefined
-const originalSpawnSync = Bun.spawnSync
-const originalWhich = Bun.which
-
-/**
- * Record every subprocess detectPlatformTheme tries to start.
- *
- * Bun.which is stubbed too: runSystemCommand resolves the binary before
- * spawning, so on a mac runner `gsettings` would resolve to null and the linux
- * branch would never reach spawnSync — the test would then pass whether or not
- * the code tried to run anything.
- */
-function captureSpawns(stdout = ''): string[][] {
-  const calls: string[][] = []
-  // Resolves to the bare name so assertions read as the command we wrote.
-  ;(Bun as { which: unknown }).which = ((binary: string) =>
-    binary) as typeof Bun.which
-  ;(Bun as { spawnSync: unknown }).spawnSync = ((options: unknown) => {
-    const cmd = (options as { cmd?: string[] })?.cmd ?? []
-    calls.push(cmd)
-    // Only the fields runSystemCommand reads; cast through unknown because the
-    // real SyncSubprocess carries pid/resourceUsage/success we don't need.
-    return { exitCode: 0, stdout, stderr: '' } as unknown
-  }) as unknown as typeof Bun.spawnSync
-  return calls
-}
-
-function setPlatform(platform: NodeJS.Platform) {
-  originalPlatform ??= Object.getOwnPropertyDescriptor(process, 'platform')
-  Object.defineProperty(process, 'platform', {
-    value: platform,
-    configurable: true,
-  })
-}
-
-afterEach(() => {
-  ;(Bun as { spawnSync: unknown }).spawnSync = originalSpawnSync
-  ;(Bun as { which: unknown }).which = originalWhich
-  if (originalPlatform) {
-    Object.defineProperty(process, 'platform', originalPlatform)
-    originalPlatform = undefined
-  }
-})
-
-describe('detectPlatformTheme on windows', () => {
-  test('starts no subprocess at all', () => {
-    setPlatform('win32')
-    const calls = captureSpawns()
-
-    detectPlatformTheme()
-
-    expect(calls).toEqual([])
-  })
-
-  test('falls back to dark', () => {
-    setPlatform('win32')
-    captureSpawns()
-
-    // Matches what the old registry read returned for a default Windows
-    // Terminal profile, so this is not a behavior change for most users.
-    expect(detectPlatformTheme()).toBe('dark')
-  })
-})
-
-describe('detectPlatformTheme on other platforms', () => {
-  test('still asks macOS for AppleInterfaceStyle', () => {
-    setPlatform('darwin')
-    const calls = captureSpawns('Dark')
-
-    expect(detectPlatformTheme()).toBe('dark')
-    expect(calls[0]).toEqual([
-      'defaults',
-      'read',
-      '-g',
-      'AppleInterfaceStyle',
-    ])
-  })
-
-  test('treats a missing macOS AppleInterfaceStyle as light', () => {
-    setPlatform('darwin')
-    captureSpawns('')
-
-    expect(detectPlatformTheme()).toBe('light')
-  })
-
-  test('still asks GNOME for its color-scheme', () => {
-    setPlatform('linux')
-    const calls = captureSpawns("'prefer-dark'")
-
-    expect(detectPlatformTheme()).toBe('dark')
-    expect(calls[0]).toEqual([
-      'gsettings',
-      'get',
-      'org.gnome.desktop.interface',
-      'color-scheme',
-    ])
-  })
-})

package/src/utils/__tests__/think-tag-parser.test.ts

@@ -1,159 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import {
-  parseThinkTags,
-  getPartialTagLength,
-  THINK_OPEN_TAG,
-  THINK_CLOSE_TAG,
-} from '../think-tag-parser'
-
-describe('parseThinkTags', () => {
-  test('returns empty array for empty string', () => {
-    expect(parseThinkTags('')).toEqual([])
-  })
-
-  test('returns single text segment for text without tags', () => {
-    expect(parseThinkTags('Hello world')).toEqual([
-      { type: 'text', content: 'Hello world' },
-    ])
-  })
-
-  test('parses single think tag', () => {
-    expect(parseThinkTags('<think>My thoughts</think>')).toEqual([
-      { type: 'thinking', content: 'My thoughts' },
-    ])
-  })
-
-  test('parses think tag with surrounding text', () => {
-    expect(parseThinkTags('Before <think>thinking</think> after')).toEqual([
-      { type: 'text', content: 'Before ' },
-      { type: 'thinking', content: 'thinking' },
-      { type: 'text', content: ' after' },
-    ])
-  })
-
-  test('parses multiple think tags', () => {
-    expect(
-      parseThinkTags(
-        'Start <think>first</think> middle <think>second</think> end',
-      ),
-    ).toEqual([
-      { type: 'text', content: 'Start ' },
-      { type: 'thinking', content: 'first' },
-      { type: 'text', content: ' middle ' },
-      { type: 'thinking', content: 'second' },
-      { type: 'text', content: ' end' },
-    ])
-  })
-
-  test('handles unclosed think tag at end', () => {
-    expect(parseThinkTags('Before <think>unclosed thinking')).toEqual([
-      { type: 'text', content: 'Before ' },
-      { type: 'thinking', content: 'unclosed thinking' },
-    ])
-  })
-
-  test('handles think tag at start', () => {
-    expect(parseThinkTags('<think>thoughts</think> after')).toEqual([
-      { type: 'thinking', content: 'thoughts' },
-      { type: 'text', content: ' after' },
-    ])
-  })
-
-  test('handles think tag at end', () => {
-    expect(parseThinkTags('before <think>thoughts</think>')).toEqual([
-      { type: 'text', content: 'before ' },
-      { type: 'thinking', content: 'thoughts' },
-    ])
-  })
-
-  test('handles empty think tag', () => {
-    expect(parseThinkTags('before <think></think> after')).toEqual([
-      { type: 'text', content: 'before ' },
-      { type: 'text', content: ' after' },
-    ])
-  })
-
-  test('handles multiline content in think tag', () => {
-    const input = 'Before\n<think>Line 1\nLine 2\nLine 3</think>\nAfter'
-    expect(parseThinkTags(input)).toEqual([
-      { type: 'text', content: 'Before\n' },
-      { type: 'thinking', content: 'Line 1\nLine 2\nLine 3' },
-      { type: 'text', content: '\nAfter' },
-    ])
-  })
-
-  test('handles consecutive think tags', () => {
-    expect(parseThinkTags('<think>first</think><think>second</think>')).toEqual(
-      [
-        { type: 'thinking', content: 'first' },
-        { type: 'thinking', content: 'second' },
-      ],
-    )
-  })
-
-  test('preserves whitespace inside think tags', () => {
-    expect(parseThinkTags('<think>  spaced content  </think>')).toEqual([
-      { type: 'thinking', content: '  spaced content  ' },
-    ])
-  })
-
-  test('handles only opening tag', () => {
-    expect(parseThinkTags('<think>started thinking')).toEqual([
-      { type: 'thinking', content: 'started thinking' },
-    ])
-  })
-})
-
-describe('getPartialTagLength', () => {
-  test('returns 0 for text without partial tags', () => {
-    expect(getPartialTagLength('hello world')).toBe(0)
-    expect(getPartialTagLength('some text')).toBe(0)
-    expect(getPartialTagLength('')).toBe(0)
-  })
-
-  test('detects partial opening tag prefixes', () => {
-    expect(getPartialTagLength('text<')).toBe(1)
-    expect(getPartialTagLength('text<t')).toBe(2)
-    expect(getPartialTagLength('text<th')).toBe(3)
-    expect(getPartialTagLength('text<thi')).toBe(4)
-    expect(getPartialTagLength('text<thin')).toBe(5)
-    expect(getPartialTagLength('text<think')).toBe(6)
-  })
-
-  test('detects partial closing tag prefixes', () => {
-    expect(getPartialTagLength('text</')).toBe(2)
-    expect(getPartialTagLength('text</t')).toBe(3)
-    expect(getPartialTagLength('text</th')).toBe(4)
-    expect(getPartialTagLength('text</thi')).toBe(5)
-    expect(getPartialTagLength('text</thin')).toBe(6)
-    expect(getPartialTagLength('text</think')).toBe(7)
-  })
-
-  test('returns 0 for complete tags', () => {
-    expect(getPartialTagLength('text<think>')).toBe(0)
-    expect(getPartialTagLength('text</think>')).toBe(0)
-  })
-
-  test('returns 0 for non-tag < character', () => {
-    expect(getPartialTagLength('text<x')).toBe(0)
-    expect(getPartialTagLength('text<a')).toBe(0)
-    expect(getPartialTagLength('text</x')).toBe(0)
-  })
-
-  test('handles just the partial tag character', () => {
-    expect(getPartialTagLength('<')).toBe(1)
-    expect(getPartialTagLength('<t')).toBe(2)
-    expect(getPartialTagLength('</')).toBe(2)
-  })
-})
-
-describe('tag constants', () => {
-  test('THINK_OPEN_TAG is correct', () => {
-    expect(THINK_OPEN_TAG).toBe('<think>')
-  })
-
-  test('THINK_CLOSE_TAG is correct', () => {
-    expect(THINK_CLOSE_TAG).toBe('</think>')
-  })
-})