savant-code 0.0.19 → 0.0.21

package/cli/src/login/utils.ts

@@ -1,183 +0,0 @@
-/**
- * Utility functions for the login screen component
- */
-
-/**
- * Calculates the relative luminance of a hex color to determine if it's light or dark mode
- */
-export function isLightModeColor(hexColor: string): boolean {
-  if (!hexColor) return false
-
-  const hex = hexColor.replace('#', '')
-  if (hex.length < 6) {
-    return false
-  }
-
-  const r = parseInt(hex.substring(0, 2), 16)
-  const g = parseInt(hex.substring(2, 4), 16)
-  const b = parseInt(hex.substring(4, 6), 16)
-
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
-  return luminance > 0.5
-}
-
-/**
- * Formats a URL for display by wrapping it at logical breakpoints
- */
-export function formatUrl(url: string, maxWidth?: number): string[] {
-  if (!maxWidth || maxWidth <= 0 || url.length <= maxWidth) {
-    return [url]
-  }
-
-  const lines: string[] = []
-  let remaining = url
-
-  while (remaining.length > 0) {
-    if (remaining.length <= maxWidth) {
-      lines.push(remaining)
-      break
-    }
-
-    // Try to break at a logical point (after /, ?, &, =)
-    let breakPoint = maxWidth
-    for (let i = maxWidth - 1; i > maxWidth - 20 && i > 0; i--) {
-      if (['/', '?', '&', '='].includes(remaining[i])) {
-        breakPoint = i + 1
-        break
-      }
-    }
-
-    lines.push(remaining.substring(0, breakPoint))
-    remaining = remaining.substring(breakPoint)
-  }
-
-  return lines
-}
-
-/**
- * Determines the color for a character based on its position relative to the sheen
- * Block characters use blockColor, shadow/border characters animate to accent green
- * @param accentColor - The accent color to use for the sheen effect (typically theme.primary)
- * @param blockColor - The color for solid block characters (white for dark mode, black for light mode)
- * @param isReversing - Whether the sheen is in the reverse (unfill) phase
- */
-export function getSheenColor(
-  char: string,
-  charIndex: number,
-  sheenPosition: number,
-  logoColor: string,
-  shadowChars: Set<string>,
-  accentColor: string = '#18faf9', // Neon cyan — updated from acid green
-  blockColor: string = '#020617', // Near-black — updated from white
-  isReversing: boolean = false,
-): string {
-  // Block characters use the specified block color
-  if (char === '█') {
-    return blockColor
-  }
-
-  // Only apply sheen to shadow/border characters
-  if (!shadowChars.has(char)) {
-    return logoColor
-  }
-
-  if (isReversing) {
-    // Reverse phase: characters behind the sheen return to logoColor
-    if (charIndex <= sheenPosition) {
-      return logoColor
-    }
-    // Characters ahead of the sheen stay accent color
-    return accentColor
-  } else {
-    // Forward phase: characters at or behind the sheen get the accent color
-    if (charIndex <= sheenPosition) {
-      return accentColor
-    }
-    // Characters ahead of the sheen remain original color
-    return logoColor
-  }
-}
-
-/**
- * Parses the logo string into individual lines
- */
-export function parseLogoLines(logo: string): string[] {
-  return logo.split('\n').filter((line) => line.length > 0)
-}
-
-/**
- * Calculates responsive layout dimensions based on terminal size
- */
-export function calculateResponsiveLayout(
-  terminalWidth: number,
-  terminalHeight: number,
-) {
-  // Responsive breakpoints based on terminal height
-  const isVerySmall = terminalHeight < 15 // Minimal UI
-  const isSmall = terminalHeight >= 15 && terminalHeight < 20 // Compact UI
-  const isMedium = terminalHeight >= 20 && terminalHeight < 30 // Standard UI
-  const isLarge = terminalHeight >= 30 // Spacious UI
-
-  // Responsive breakpoints based on terminal width
-  const isNarrow = terminalWidth < 60
-
-  // Dynamic spacing based on terminal size - compressed to prevent scrolling
-  const containerPadding = isVerySmall ? 0 : 1
-  const headerMarginTop = 0
-  const headerMarginBottom = isVerySmall ? 0 : 1
-  const sectionMarginBottom = isVerySmall ? 0 : 1
-  const contentMaxWidth = Math.max(
-    10,
-    Math.min(terminalWidth - (containerPadding * 2 + 4), 80),
-  )
-
-  const maxUrlWidth = Math.min(terminalWidth - 10, 100)
-
-  return {
-    isVerySmall,
-    isSmall,
-    isMedium,
-    isLarge,
-    isNarrow,
-    containerPadding,
-    headerMarginTop,
-    headerMarginBottom,
-    sectionMarginBottom,
-    contentMaxWidth,
-    maxUrlWidth,
-  }
-}
-
-/**
- * Calculates modal height based on terminal size and whether credentials are invalid
- */
-export function calculateModalDimensions(
-  terminalHeight: number,
-  hasInvalidCredentials: boolean,
-  defaultHeight = 24,
-  verticalMargin = 2,
-  maxBaseHeight = 22,
-  warningBannerHeight = 3,
-) {
-  // Calculate available terminal height
-  const availableHeight = terminalHeight || defaultHeight
-
-  // Calculate base modal height (terminal height minus margins, capped at max)
-  const baseModalHeight = Math.min(
-    availableHeight - verticalMargin,
-    maxBaseHeight,
-  )
-
-  // Add warning banner height if credentials are invalid
-  const totalContentHeight =
-    baseModalHeight + (hasInvalidCredentials ? warningBannerHeight : 0)
-
-  // Final modal height cannot exceed available terminal height
-  const modalHeight = Math.min(totalContentHeight, availableHeight)
-
-  return {
-    modalHeight,
-    baseModalHeight,
-    availableHeight,
-  }
-}

package/cli/src/native/ripgrep.ts

@@ -1,82 +0,0 @@
-import path from 'path'
-
-import { getBundledRgPath } from '@savant-code/sdk'
-import { spawnSync } from 'bun'
-
-import { getCliEnv } from '../utils/env'
-import { logger } from '../utils/logger'
-
-const getRipgrepPath = async (): Promise<string> => {
-  const env = getCliEnv()
-  // In dev mode, use the SDK's bundled ripgrep binary
-  if (!env.SAVANT_CODE_IS_BINARY) {
-    return getBundledRgPath()
-  }
-
-  // Compiled mode - self-extract the embedded binary to the same directory as the current binary
-  const binaryDir = path.dirname(process.execPath)
-  const rgFileName = process.platform === 'win32' ? 'rg.exe' : 'rg'
-  const outPath = path.join(binaryDir, rgFileName)
-
-  // Check if already extracted
-  const outPathExists = await Bun.file(outPath).exists()
-  if (outPathExists) {
-    return outPath
-  }
-
-  // Extract the embedded binary
-  try {
-    // Use require() with literal paths to ensure the binary gets bundled into the compiled CLI
-    // This is necessary for Bun's binary compilation to include the ripgrep binary
-    let embeddedRgPath: string
-
-    if (process.platform === 'darwin' && process.arch === 'arm64') {
-      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/arm64-darwin/rg')
-    } else if (process.platform === 'darwin' && process.arch === 'x64') {
-      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-darwin/rg')
-    } else if (process.platform === 'linux' && process.arch === 'arm64') {
-      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/arm64-linux/rg')
-    } else if (process.platform === 'linux' && process.arch === 'x64') {
-      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-linux/rg')
-    } else if (process.platform === 'win32' && process.arch === 'x64') {
-      embeddedRgPath = require('../../../sdk/dist/vendor/ripgrep/x64-win32/rg.exe')
-    } else {
-      throw new Error(
-        `Unsupported platform: ${process.platform}-${process.arch}`,
-      )
-    }
-
-    // Copy SDK's bundled binary to binary directory for portability
-    const embeddedBuffer = await Bun.file(embeddedRgPath).arrayBuffer()
-    await Bun.write(outPath, embeddedBuffer)
-
-    // Make executable on Unix systems
-    if (process.platform !== 'win32') {
-      spawnSync(['chmod', '+x', outPath])
-    }
-
-    return outPath
-  } catch (error) {
-    logger.error({ error }, 'Failed to extract ripgrep binary')
-    // Fallback to SDK's bundled ripgrep if extraction fails
-    return getBundledRgPath()
-  }
-}
-
-// Cache the promise to avoid multiple extractions
-let rgPathPromise: Promise<string> | null = null
-
-export const getRgPath = (): Promise<string> => {
-  if (!rgPathPromise) {
-    rgPathPromise = getRipgrepPath()
-  }
-  return rgPathPromise
-}
-
-/**
- * Reset the cached ripgrep path promise.
- * Used primarily for testing to force re-extraction.
- */
-export const resetRgPathCache = (): void => {
-  rgPathPromise = null
-}

package/cli/src/polyfills/bun-strip-ansi.ts

@@ -1,12 +0,0 @@
-import { stripAnsi } from '@savant-code/common/util/string'
-
-// Bun 1.2 removed Bun.stripANSI; provide a fallback for libraries that still call it.
-const bunGlobal = globalThis as typeof globalThis & {
-  Bun?: {
-    stripANSI?: (input: string) => string
-  }
-}
-
-if (bunGlobal.Bun && typeof bunGlobal.Bun.stripANSI !== 'function') {
-  bunGlobal.Bun.stripANSI = stripAnsi
-}

package/cli/src/pre-init/load-dev-env.ts

@@ -1,98 +0,0 @@
-// Loads environment values before `common/src/env.ts` parses the schema.
-//
-// Two modes:
-// 1. Release binary: a sibling `env.json` (written next to the compiled
-//    binary at build time) provides the canonical env values. This is
-//    required because Bun's `--define` replacement is unreliable for env
-//    vars once workspace packages are pre-built to dist and minified.
-// 2. Local dev: `bun dev` runs with `--cwd ..`, which disables Bun's
-//    dotenv auto-loader, so we manually load the repo-root `.env.local`.
-//
-// This module MUST be imported before any `@savant-code/common` import that
-// would trigger `common/src/env.ts` (which parses the schema at module load).
-import fs from 'fs'
-import path from 'path'
-
-/**
- * Walk upward from startDir looking for relName; return its absolute path
- * or null if not found before the filesystem root.
- */
-function findUp(startDir: string, relName: string): string | null {
-  let dir = startDir
-  // Guard against infinite loop at filesystem root.
-  for (let i = 0; i < 20; i++) {
-    const candidate = path.join(dir, relName)
-    if (fs.existsSync(candidate)) return candidate
-    const parent = path.dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  return null
-}
-
-/**
- * Load a sibling `env.json` from the directory containing the running binary.
- * Returns true if the file was found and applied.
- */
-function loadBinaryEnvIfPresent(): boolean {
-  const execPath = process.execPath
-  if (!execPath) return false
-
-  const envJsonPath = path.join(path.dirname(execPath), 'env.json')
-  try {
-    if (!fs.existsSync(envJsonPath)) return false
-    const parsed = JSON.parse(fs.readFileSync(envJsonPath, 'utf-8'))
-    if (!parsed || typeof parsed !== 'object') return false
-
-    for (const [key, value] of Object.entries(
-      parsed as Record<string, unknown>,
-    )) {
-      if (typeof value === 'string') {
-        process.env[key] = value
-      }
-    }
-    return true
-  } catch {
-    // A missing or corrupt env.json is fine; fall through to .env.local logic.
-    return false
-  }
-}
-
-/**
- * Parse a dotenv-style file and apply it to process.env.
- * Mirrors the e2e harness `loadEnvFile` parser so dev and test agree.
- * Existing process.env values win (don't clobber real shell exports).
- */
-function applyEnvLocal(): void {
-  const envLocalPath = findUp(import.meta.dir, '.env.local')
-  if (!envLocalPath) return
-  try {
-    const content = fs.readFileSync(envLocalPath, 'utf-8')
-    for (const rawLine of content.split('\n')) {
-      const line = rawLine.trim()
-      if (!line || line.startsWith('#')) continue
-      const normalized = line.startsWith('export ')
-        ? line.slice('export '.length)
-        : line
-      const equalsIndex = normalized.indexOf('=')
-      if (equalsIndex <= 0) continue
-      const key = normalized.slice(0, equalsIndex).trim()
-      if (!key || process.env[key]) continue
-      let value = normalized.slice(equalsIndex + 1).trim()
-      if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1)
-      }
-      process.env[key] = value
-    }
-  } catch {
-    // Missing .env.local is fine — real deployments set these via the shell.
-  }
-}
-
-// Release binaries ship their own env.json; everything else loads .env.local.
-if (!loadBinaryEnvIfPresent()) {
-  applyEnvLocal()
-}

package/cli/src/pre-init/tree-sitter-wasm.ts

@@ -1,98 +0,0 @@
-// Find tree-sitter.wasm so the SDK's tree-sitter parser singleton can load
-// it at runtime. Must be the very first import in `index.tsx`: subsequent
-// imports (the SDK / code-map) eagerly construct the parser, and its init
-// reads what we publish here on `globalThis` and via the env var.
-//
-// Final approach after several attempts to embed the wasm into the bun
-// --compile binary all failed on Windows (the bytes ended up in the
-// binary, but every JS-level retrieval mechanism — `with { type: 'file' }`
-// import binding, base64 string literals, chunked base64 in a generated
-// module, function-export wrappers — was either tree-shaken, transformed
-// by the minifier, or otherwise stripped):
-//
-//   ship tree-sitter.wasm as a sibling file next to the binary.
-//
-// It's 200KB, the npm tarball already contains the binary; adding one
-// more file is trivial. The build script copies the wasm into `cli/bin/`
-// after compile, the release workflow tarballs both, and the savant-free /
-// savant-code downloader extracts both into the same directory. At runtime,
-// `process.execPath` plus a relative file lookup gets us the wasm with
-// zero bundler involvement.
-
-import { existsSync, readFileSync } from 'fs'
-import { dirname, isAbsolute, join, resolve } from 'path'
-
-// Where to look for the sibling tree-sitter.wasm. We can't just use
-// `dirname(process.execPath)`: at pre-init time inside a bun --compile
-// binary on Windows, `process.execPath` returns the *bunfs* internal
-// path (`B:\~BUN\root\<binary>.exe`) rather than the on-disk path of
-// the .exe the user invoked. By the time main() runs it switches to
-// the disk path, but pre-init has long since bailed out.
-//
-// Try several sources in order; the first whose sibling .wasm exists
-// wins. argv[0] is normally the path the binary was invoked with —
-// always a real disk path, never bunfs. execPath is kept as a fallback
-// for environments where argv[0] is something exotic.
-const candidates = (
-  [process.argv[0], process.execPath] as Array<string | undefined>
-)
-  .filter((p): p is string => typeof p === 'string' && p.length > 0)
-  .map((p) => (isAbsolute(p) ? p : resolve(p)))
-  .map((p) => join(dirname(p), 'tree-sitter.wasm'))
-
-const siblingPath = candidates.find((p) => existsSync(p))
-
-// Pre-init diagnostic — only fires when --smoke-tree-sitter is set so we
-// don't spam every run. We need to see what argv[0] / execPath looked
-// like at this exact phase on Windows: the round-7 main() diag showed
-// disk paths, but pre-init silently bailed, meaning module-init time
-// gives different values. argv[0] alone wasn't enough to fix it.
-if (process.argv.includes('--smoke-tree-sitter')) {
-  // eslint-disable-next-line no-console -- pre-init diagnostic; logger is not available this early
-  console.error(
-    `[pre-init diag] argv[0]=${process.argv[0]}\n` +
-      `[pre-init diag] execPath=${process.execPath}\n` +
-      `[pre-init diag] candidates=${JSON.stringify(candidates)}\n` +
-      `[pre-init diag] resolved siblingPath=${siblingPath ?? '<none>'}\n`,
-  )
-}
-
-if (siblingPath) {
-  // Tell init-node.ts (in code-map / the SDK bundle) where the wasm
-  // is. The locateFile callback there will hand this path to
-  // emscripten, which fs.readFile's it.
-  process.env.SAVANT_CODE_TREE_SITTER_WASM_PATH = siblingPath
-
-  // Also publish on globalThis so the smoke handler in index.tsx can
-  // read it without touching process.env (which is gated by the env
-  // architecture check outside the allowlisted pre-init files).
-  ;(
-    globalThis as { __SAVANT_CODE_TREE_SITTER_WASM_PATH__?: string }
-  ).__SAVANT_CODE_TREE_SITTER_WASM_PATH__ = siblingPath
-
-  // Also try the synchronous-bytes path: hand the bytes straight to
-  // Parser.init({ wasmBinary }) so the SDK doesn't need to round-trip
-  // through emscripten's path resolution. Both channels feed the same
-  // tree-sitter init; whichever one trips first wins.
-  try {
-    const buf = readFileSync(siblingPath)
-    ;(
-      globalThis as { __SAVANT_CODE_TREE_SITTER_WASM_BINARY__?: Uint8Array }
-    ).__SAVANT_CODE_TREE_SITTER_WASM_BINARY__ = new Uint8Array(
-      buf.buffer,
-      buf.byteOffset,
-      buf.byteLength,
-    )
-  } catch (err) {
-    // eslint-disable-next-line no-console -- pre-init diagnostic; logger is not available this early
-    console.error(
-      '[tree-sitter pre-init] readFileSync failed for sibling wasm at',
-      siblingPath,
-      '—',
-      err instanceof Error ? err.message : String(err),
-    )
-  }
-}
-
-// `--smoke-tree-sitter` is the deterministic CI gate. The handler lives at
-// the top of main() in cli/src/index.tsx (before parseArgs).

package/cli/src/project-files.ts

@@ -1,102 +0,0 @@
-import { mkdirSync, readdirSync, statSync } from 'fs'
-import path from 'path'
-
-import { getConfigDir } from './utils/auth'
-
-let projectRoot: string | undefined
-let currentChatId: string | undefined
-
-function ensureChatDirectory(dir: string) {
-  mkdirSync(dir, { recursive: true })
-}
-
-export function setProjectRoot(dir: string) {
-  projectRoot = dir
-  return projectRoot
-}
-
-export function getProjectRoot() {
-  if (!projectRoot) {
-    throw new Error('Project root not set')
-  }
-  return projectRoot
-}
-
-export function tryGetProjectRoot() {
-  return projectRoot
-}
-
-export function getCurrentChatId() {
-  if (!currentChatId) {
-    currentChatId = new Date().toISOString().replace(/:/g, '-')
-  }
-  return currentChatId
-}
-
-export function setCurrentChatId(chatId: string) {
-  currentChatId = chatId
-  return currentChatId
-}
-
-export function startNewChat() {
-  currentChatId = new Date().toISOString().replace(/:/g, '-')
-  return currentChatId
-}
-
-// Get the project-specific data directory
-export function getProjectDataDir(): string {
-  const root = getProjectRoot()
-  if (!root) {
-    throw new Error('Project root not set')
-  }
-
-  const baseName = path.basename(root)
-  const baseDir = path.join(getConfigDir(), 'projects', baseName)
-
-  return baseDir
-}
-
-/**
- * Find the most recent chat directory based on modification time
- * Returns null if no chat directories exist
- */
-export function getMostRecentChatDir(): string | null {
-  try {
-    const chatsDir = path.join(getProjectDataDir(), 'chats')
-    if (!statSync(chatsDir, { throwIfNoEntry: false })) {
-      return null
-    }
-
-    const chatDirs = readdirSync(chatsDir)
-      .map((name) => {
-        const fullPath = path.join(chatsDir, name)
-        try {
-          const stat = statSync(fullPath)
-          return { name, fullPath, mtime: stat.mtime }
-        } catch {
-          return null
-        }
-      })
-      .filter(
-        (item): item is { name: string; fullPath: string; mtime: Date } =>
-          item !== null && statSync(item.fullPath).isDirectory(),
-      )
-
-    if (chatDirs.length === 0) {
-      return null
-    }
-
-    // Sort by modification time, most recent first
-    chatDirs.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-    return chatDirs[0].fullPath
-  } catch {
-    return null
-  }
-}
-
-export function getCurrentChatDir(): string {
-  const chatId = getCurrentChatId()
-  const dir = path.join(getProjectDataDir(), 'chats', chatId)
-  ensureChatDirectory(dir)
-  return dir
-}

package/cli/src/state/__tests__/chat-store-focus.test.ts

@@ -1,22 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-
-import { useChatStore } from '../chat-store'
-
-afterEach(() => {
-  const store = useChatStore.getState()
-  store.setInputFocused(true)
-  store.setIsFocusSupported(false)
-})
-
-describe('chat store focus state', () => {
-  test('chat reset preserves terminal focus and detected capabilities', () => {
-    const store = useChatStore.getState()
-    store.setInputFocused(false)
-    store.setIsFocusSupported(true)
-
-    store.reset()
-
-    expect(useChatStore.getState().inputFocused).toBe(false)
-    expect(useChatStore.getState().isFocusSupported).toBe(true)
-  })
-})