savant-code 0.0.19 → 0.0.21

package/cli/src/__tests__/release/wrapper-safety.test.ts

@@ -1,177 +0,0 @@
-import { EventEmitter } from 'node:events'
-import {
-  copyFileSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs'
-import { createRequire } from 'node:module'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { describe, expect, test } from 'bun:test'
-
-const repoRoot = fileURLToPath(new URL('../../../../', import.meta.url))
-const require = createRequire(import.meta.url)
-
-const wrappers = [
-  {
-    name: 'savant-code',
-    directory: 'cli/release',
-    expectedConfig: {
-      packageName: 'savant-code',
-      displayName: 'SavantCode',
-      tempDownloadDirName: '.download-temp',
-    },
-  },
-  {
-    name: 'codecane',
-    directory: 'cli/release-staging',
-    expectedConfig: {
-      packageName: 'savant-code-staging',
-      displayName: 'Codecane',
-      includeTreeSitterWasm: false,
-      telemetryProperties: { isStaging: true },
-      tempDownloadDirName: '.download-temp-staging',
-    },
-  },
-  {
-    name: 'savant-free',
-    directory: 'savant-free/cli/release',
-    expectedConfig: {
-      packageName: 'savant-free',
-      displayName: 'SavantFree',
-      telemetryEvent: 'cli.update_savant_free_failed',
-    },
-  },
-]
-
-for (const wrapper of wrappers) {
-  describe(`${wrapper.name} release wrapper`, () => {
-    test('contains only product configuration and package loading', () => {
-      const wrapperModule = require(
-        join(repoRoot, wrapper.directory, 'index.js'),
-      )
-      expect(wrapperModule.config).toMatchObject(wrapper.expectedConfig)
-    })
-
-    test('has package-only lifecycle scripts', () => {
-      const packageJson = JSON.parse(
-        readFileSync(join(repoRoot, wrapper.directory, 'package.json'), 'utf8'),
-      )
-      expect(packageJson.scripts?.preinstall).toBeUndefined()
-      expect(packageJson.scripts?.install).toBeUndefined()
-      expect(packageJson.scripts?.postinstall).toBeUndefined()
-      expect(packageJson.scripts?.preuninstall).toBeUndefined()
-      expect(packageJson.scripts?.prepack).toContain('prepare-package.js')
-      expect(packageJson.scripts?.postpack).toContain('prepare-package.js')
-      expect(packageJson.files).toContain('launcher.js')
-      expect(packageJson.files).toContain('http.js')
-    })
-
-    test('prefers its bundled launcher over a source-path collision', () => {
-      const fixtureRoot = mkdtempSync(
-        join(tmpdir(), `${wrapper.name}-wrapper-`),
-      )
-      const fixtureWrapperDir = join(fixtureRoot, wrapper.directory)
-      const fixtureSourceDir = join(fixtureRoot, 'cli/release-core')
-
-      try {
-        mkdirSync(fixtureWrapperDir, { recursive: true })
-        mkdirSync(fixtureSourceDir, { recursive: true })
-        copyFileSync(
-          join(repoRoot, wrapper.directory, 'index.js'),
-          join(fixtureWrapperDir, 'index.js'),
-        )
-
-        const fakeLauncher = (origin: string) => `
-          module.exports = {
-            createLauncher(config) {
-              return { config, main: async () => {}, origin: '${origin}' }
-            },
-          }
-        `
-        writeFileSync(
-          join(fixtureWrapperDir, 'launcher.js'),
-          fakeLauncher('packaged'),
-        )
-        writeFileSync(
-          join(fixtureSourceDir, 'launcher.js'),
-          fakeLauncher('source'),
-        )
-
-        const wrapperModule = require(join(fixtureWrapperDir, 'index.js'))
-        expect(wrapperModule.origin).toBe('packaged')
-      } finally {
-        rmSync(fixtureRoot, { recursive: true, force: true })
-      }
-    })
-  })
-}
-
-describe('shared release launcher safety', () => {
-  const launcherPath = join(repoRoot, 'cli/release-core/launcher.js')
-  const { createLauncher } = require(launcherPath)
-
-  test('stages an update before stopping the running process', () => {
-    const source = readFileSync(launcherPath, 'utf8')
-    const updateFunction = source.slice(
-      source.indexOf('async function checkForUpdates'),
-    )
-    const stageIndex = updateFunction.indexOf(
-      'const stagedBinary = await stageBinary',
-    )
-    const stopIndex = updateFunction.indexOf(
-      'await stopRunningProcess(runningProcess)',
-    )
-    const installIndex = updateFunction.indexOf(
-      'installStagedBinary(stagedBinary)',
-    )
-
-    expect(stageIndex).toBeGreaterThan(-1)
-    expect(stopIndex).toBeGreaterThan(stageIndex)
-    expect(installIndex).toBeGreaterThan(stopIndex)
-  })
-
-  test('cleans up process-stop listeners and timers', async () => {
-    const { stopRunningProcess } = createLauncher({
-      packageName: 'test',
-      displayName: 'Test',
-    })
-    const runningProcess = new EventEmitter() as EventEmitter & {
-      kill(signal: string): boolean
-    }
-    const signals: string[] = []
-    runningProcess.kill = (signal) => {
-      signals.push(signal)
-      runningProcess.emit('exit', 0, null)
-      return true
-    }
-
-    await stopRunningProcess(runningProcess)
-
-    expect(signals).toEqual(['SIGTERM'])
-    expect(runningProcess.listenerCount('exit')).toBe(0)
-  })
-
-  test('cleans up when stopping the process throws', async () => {
-    const { stopRunningProcess } = createLauncher({
-      packageName: 'test',
-      displayName: 'Test',
-    })
-    const runningProcess = new EventEmitter() as EventEmitter & {
-      kill(signal: string): boolean
-    }
-    runningProcess.kill = () => {
-      throw new Error('kill failed')
-    }
-
-    await expect(stopRunningProcess(runningProcess)).rejects.toThrow(
-      'kill failed',
-    )
-    expect(runningProcess.listenerCount('exit')).toBe(0)
-  })
-})

package/cli/src/__tests__/rerender-perf.integration.test.ts

@@ -1,283 +0,0 @@
-import { spawn } from 'child_process'
-import path from 'path'
-
-import { describe, test, expect, beforeAll } from 'bun:test'
-
-import {
-  isTmuxAvailable,
-  isSDKBuilt,
-  sleep,
-  ensureCliTestEnv,
-  getDefaultCliEnv,
-  parseRerenderLogs,
-  analyzeRerenders,
-  clearCliDebugLog,
-} from './test-utils'
-
-const CLI_PATH = path.join(__dirname, '../index.tsx')
-const DEBUG_LOG_PATH = path.join(__dirname, '../../../debug/cli.jsonl')
-const TIMEOUT_MS = 45000
-const tmuxAvailable = isTmuxAvailable()
-const sdkBuilt = isSDKBuilt()
-
-ensureCliTestEnv()
-
-/**
- * Re-render performance thresholds.
- * These values are based on observed behavior after optimization.
- * If these thresholds are exceeded, it likely indicates a performance regression.
- */
-const RERENDER_THRESHOLDS = {
-  /** Maximum total re-renders across all messages for a simple prompt */
-  maxTotalRerenders: 20,
-
-  /** Maximum re-renders for any single message */
-  maxRerenderPerMessage: 12,
-
-  /**
-   * Props that should NEVER appear in changedProps after memoization fixes.
-   * If these appear, it means callbacks are not properly memoized.
-   */
-  forbiddenChangedProps: [
-    'onOpenFeedback',
-    'onToggleCollapsed',
-    'onBuildFast',
-    'onBuildMax',
-    'onBuildLite',
-    'onCloseFeedback',
-  ],
-
-  /**
-   * Maximum times streamingAgents should appear in changedProps.
-   * After Set stabilization, this should be very low.
-   */
-  maxStreamingAgentChanges: 5,
-}
-
-// Utility to run tmux commands
-function tmux(args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('tmux', args, { stdio: 'pipe' })
-    let stdout = ''
-    let stderr = ''
-
-    proc.stdout?.on('data', (data) => {
-      stdout += data.toString()
-    })
-
-    proc.stderr?.on('data', (data) => {
-      stderr += data.toString()
-    })
-
-    proc.on('close', (code) => {
-      if (code === 0) {
-        resolve(stdout)
-      } else {
-        reject(new Error(`tmux command failed: ${stderr}`))
-      }
-    })
-  })
-}
-
-/**
- * Send input to the CLI using bracketed paste mode.
- * Standard send-keys doesn't work with OpenTUI - see tmux.knowledge.md
- */
-async function sendCliInput(sessionName: string, text: string): Promise<void> {
-  await tmux([
-    'send-keys',
-    '-t',
-    sessionName,
-    '-l',
-    `\x1b[200~${text}\x1b[201~`,
-  ])
-}
-
-describe.skipIf(!tmuxAvailable || !sdkBuilt)(
-  'Re-render Performance Tests',
-  () => {
-    beforeAll(async () => {
-      if (!tmuxAvailable) {
-        console.log('\n⚠️  Skipping re-render perf tests - tmux not installed')
-        console.log(
-          '📦 Install with: brew install tmux (macOS) or sudo apt-get install tmux (Linux)\n',
-        )
-      }
-      if (!sdkBuilt) {
-        console.log('\n⚠️  Skipping re-render perf tests - SDK not built')
-        console.log('🔨 Build SDK: cd sdk && bun run build\n')
-      }
-      if (tmuxAvailable && sdkBuilt) {
-        const envVars = getDefaultCliEnv()
-        const entries = Object.entries(envVars)
-        // Propagate environment into tmux server
-        await Promise.all(
-          entries.map(([key, value]) =>
-            tmux(['set-environment', '-g', key, value]),
-          ),
-        )
-        // Enable performance testing
-        await tmux(['set-environment', '-g', 'SAVANT_CODE_PERF_TEST', 'true'])
-      }
-    })
-
-    test(
-      'MessageBlock re-renders stay within acceptable limits',
-      async () => {
-        const sessionName = 'savant-code-perf-test-' + Date.now()
-
-        // Clear the debug log before test
-        clearCliDebugLog(DEBUG_LOG_PATH)
-
-        try {
-          // Start CLI with perf testing enabled
-          await tmux([
-            'new-session',
-            '-d',
-            '-s',
-            sessionName,
-            '-x',
-            '120',
-            '-y',
-            '30',
-            `SAVANT_CODE_PERF_TEST=true bun run ${CLI_PATH}`,
-          ])
-
-          // Wait for CLI to initialize
-          await sleep(5000)
-
-          // Send a simple prompt that will trigger streaming response
-          await sendCliInput(sessionName, 'what is 2+2')
-          await tmux(['send-keys', '-t', sessionName, 'Enter'])
-
-          // Wait for response to complete (longer wait for API response)
-          await sleep(15000)
-
-          // Parse and analyze the re-render logs
-          const entries = parseRerenderLogs(DEBUG_LOG_PATH)
-          const analysis = analyzeRerenders(entries)
-
-          // Log analysis for debugging
-          console.log('\n📊 Re-render Analysis:')
-          console.log(`   Total re-renders: ${analysis.totalRerenders}`)
-          console.log(`   Max per message: ${analysis.maxRerenderPerMessage}`)
-          console.log(
-            `   Messages tracked: ${analysis.rerendersByMessage.size}`,
-          )
-          if (analysis.propChangeFrequency.size > 0) {
-            console.log('   Prop change frequency:')
-            for (const [prop, count] of analysis.propChangeFrequency) {
-              console.log(`     - ${prop}: ${count}`)
-            }
-          }
-
-          // Assert total re-renders within threshold
-          expect(analysis.totalRerenders).toBeLessThanOrEqual(
-            RERENDER_THRESHOLDS.maxTotalRerenders,
-          )
-
-          // Assert max re-renders per message within threshold
-          expect(analysis.maxRerenderPerMessage).toBeLessThanOrEqual(
-            RERENDER_THRESHOLDS.maxRerenderPerMessage,
-          )
-
-          // Assert forbidden props don't appear (memoization check)
-          for (const forbiddenProp of RERENDER_THRESHOLDS.forbiddenChangedProps) {
-            const count = analysis.propChangeFrequency.get(forbiddenProp) || 0
-            if (count > 0) {
-              console.log(
-                `\n❌ Forbidden prop '${forbiddenProp}' changed ${count} times - callback not memoized!`,
-              )
-            }
-            expect(count).toBe(0)
-          }
-
-          // Assert streamingAgents changes within threshold
-          const streamingAgentChanges =
-            analysis.propChangeFrequency.get('streamingAgents') || 0
-          expect(streamingAgentChanges).toBeLessThanOrEqual(
-            RERENDER_THRESHOLDS.maxStreamingAgentChanges,
-          )
-
-          console.log('\n✅ Re-render performance within acceptable limits')
-        } finally {
-          // Cleanup tmux session
-          try {
-            await tmux(['kill-session', '-t', sessionName])
-          } catch {
-            // Session may have already exited
-          }
-        }
-      },
-      TIMEOUT_MS,
-    )
-
-    test(
-      'Forbidden callback props are properly memoized',
-      async () => {
-        const sessionName = 'savant-code-memo-test-' + Date.now()
-
-        clearCliDebugLog(DEBUG_LOG_PATH)
-
-        try {
-          await tmux([
-            'new-session',
-            '-d',
-            '-s',
-            sessionName,
-            '-x',
-            '120',
-            '-y',
-            '30',
-            `SAVANT_CODE_PERF_TEST=true bun run ${CLI_PATH}`,
-          ])
-
-          await sleep(5000)
-
-          // Send multiple rapid prompts to stress test memoization
-          await sendCliInput(sessionName, 'hi')
-          await tmux(['send-keys', '-t', sessionName, 'Enter'])
-          await sleep(8000)
-
-          const entries = parseRerenderLogs(DEBUG_LOG_PATH)
-          const analysis = analyzeRerenders(entries)
-
-          // Check that none of the callback props appear in changed props
-          const forbiddenPropsFound: string[] = []
-          for (const prop of RERENDER_THRESHOLDS.forbiddenChangedProps) {
-            const count = analysis.propChangeFrequency.get(prop) || 0
-            if (count > 0) {
-              forbiddenPropsFound.push(`${prop} (${count}x)`)
-            }
-          }
-
-          if (forbiddenPropsFound.length > 0) {
-            console.log(
-              `\n❌ Unmemoized callbacks detected: ${forbiddenPropsFound.join(', ')}`,
-            )
-          }
-
-          expect(forbiddenPropsFound).toHaveLength(0)
-        } finally {
-          try {
-            await tmux(['kill-session', '-t', sessionName])
-          } catch {}
-        }
-      },
-      TIMEOUT_MS,
-    )
-  },
-)
-
-// Show helpful message when tests are skipped
-if (!tmuxAvailable) {
-  describe('Re-render Performance - tmux Required', () => {
-    test.skip('Install tmux for performance tests', () => {})
-  })
-}
-
-if (!sdkBuilt) {
-  describe('Re-render Performance - SDK Required', () => {
-    test.skip('Build SDK: cd sdk && bun run build', () => {})
-  })
-}

package/cli/src/__tests__/terminal-reset-sequences.test.ts

@@ -1,36 +0,0 @@
-import { readFileSync } from 'fs'
-import { join } from 'path'
-
-import { describe, expect, test } from 'bun:test'
-
-import { TERMINAL_RESET_SEQUENCES } from '../utils/terminal-reset-sequences'
-
-/**
- * The npm wrapper release scripts are standalone published JS that can't
- * import the TS constant, so each carries its own copy of the reset
- * sequences (split into EXIT_ALTERNATE_SCREEN_SEQUENCE +
- * SAFE_TERMINAL_RESET_SEQUENCES). This guard turns silent drift into a test
- * failure: every sequence in the TS constant must appear in the standalone
- * launcher source bundled into each release package.
- */
-const REPO_ROOT = join(import.meta.dir, '..', '..', '..')
-
-const WRAPPER_PATHS = ['cli/release-core/launcher.js']
-
-/** Split the runtime constant into per-sequence source literals ('\x1b…'). */
-function sequenceSourceLiterals(): string[] {
-  return TERMINAL_RESET_SEQUENCES.split('\x1b')
-    .filter(Boolean)
-    .map((rest) => `'\\x1b${rest}'`)
-}
-
-describe('terminal reset sequence copies stay in sync', () => {
-  for (const wrapperPath of WRAPPER_PATHS) {
-    test(wrapperPath, () => {
-      const source = readFileSync(join(REPO_ROOT, wrapperPath), 'utf8')
-      for (const literal of sequenceSourceLiterals()) {
-        expect(source).toContain(literal)
-      }
-    })
-  }
-})

package/cli/src/__tests__/terminal-watchdog.test.ts

@@ -1,114 +0,0 @@
-import { spawn } from 'child_process'
-import { mkdtempSync, readdirSync, readFileSync, rmSync } from 'fs'
-import { tmpdir } from 'os'
-import { join } from 'path'
-
-import { afterAll, describe, expect, test } from 'bun:test'
-
-import { TERMINAL_RESET_SEQUENCES } from '../utils/terminal-reset-sequences'
-
-import type { ChildProcess } from 'child_process'
-
-const FIXTURE = join(import.meta.dir, 'helpers', 'terminal-watchdog-fixture.ts')
-
-const tempDir = mkdtempSync(join(tmpdir(), 'terminal-watchdog-'))
-
-afterAll(() => {
-  rmSync(tempDir, { recursive: true, force: true })
-})
-
-function spawnFixture(mode: 'hang' | 'clean', ttyPath: string): ChildProcess {
-  return spawn(process.execPath, [FIXTURE, mode, ttyPath], {
-    stdio: ['ignore', 'pipe', 'inherit'],
-  })
-}
-
-/** Resolve once the fixture prints "ready" (watchdog armed). */
-function waitForReady(child: ChildProcess): Promise<void> {
-  return new Promise((resolve, reject) => {
-    let out = ''
-    child.stdout!.on('data', (chunk: Buffer) => {
-      out += chunk.toString()
-      if (out.includes('ready')) resolve()
-    })
-    child.on('exit', () => resolve()) // "clean" mode exits after arming
-    child.on('error', reject)
-  })
-}
-
-function waitForExit(child: ChildProcess): Promise<void> {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null || child.signalCode !== null) return resolve()
-    child.on('exit', () => resolve())
-  })
-}
-
-function readTty(ttyPath: string): string {
-  try {
-    return readFileSync(ttyPath, 'utf8')
-  } catch {
-    return ''
-  }
-}
-
-/**
- * Disarm files the fixture left in the temp dir (Windows watchdog only;
- * POSIX never creates one). Named savant-code-watchdog-disarm-<pid>-<random>.
- */
-function findDisarmFiles(pid: number | undefined): string[] {
-  return readdirSync(tmpdir()).filter((name) =>
-    name.startsWith(`savant-code-watchdog-disarm-${pid}-`),
-  )
-}
-
-async function pollForContent(
-  ttyPath: string,
-  timeoutMs: number,
-): Promise<string> {
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    const content = readTty(ttyPath)
-    if (content) return content
-    await new Promise((r) => setTimeout(r, 50))
-  }
-  return readTty(ttyPath)
-}
-
-// POSIX uses a detached sh blocking on pipe EOF; Windows uses a PowerShell
-// grandchild (outside Bun's kill-on-close job object) blocking on
-// Wait-Process. Both then write the reset sequences to the injected ttyPath.
-describe('terminal watchdog', () => {
-  test('writes reset sequences to the tty when the process dies uncleanly', async () => {
-    const ttyPath = join(tempDir, 'unclean.out')
-    const child = spawnFixture('hang', ttyPath)
-    await waitForReady(child)
-
-    child.kill('SIGKILL')
-    await waitForExit(child)
-
-    // Wait-Process wakeup + write can take a few seconds under CI load.
-    const written = await pollForContent(ttyPath, 15_000)
-    expect(written).toBe(TERMINAL_RESET_SEQUENCES)
-  }, 60_000)
-
-  test('stays silent when the process shuts down cleanly', async () => {
-    const ttyPath = join(tempDir, 'clean.out')
-    const child = spawnFixture('clean', ttyPath)
-    await waitForExit(child)
-
-    // Give a disarmed-too-late watchdog time to (incorrectly) fire. Windows
-    // gets longer since the watchdog wakes asynchronously via Wait-Process.
-    await new Promise((r) =>
-      setTimeout(r, process.platform === 'win32' ? 3_000 : 500),
-    )
-    expect(readTty(ttyPath)).toBe('')
-
-    // The watchdog consumes (deletes) the disarm file when it wakes, so
-    // clean exits must not litter the temp dir.
-    const deadline = Date.now() + 10_000
-    while (Date.now() < deadline && findDisarmFiles(child.pid).length > 0) {
-      await new Promise((r) => setTimeout(r, 100))
-    }
-    expect(findDisarmFiles(child.pid)).toEqual([])
-  }, 60_000)
-})