@alumbwe/anvil 1.0.0

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

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

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

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

@@ -0,0 +1,125 @@
+/**
+ * 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

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