@alumbwe/anvil 1.0.19 → 1.0.20

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

@@ -0,0 +1,96 @@
+// 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 anvil /
+// anvil 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')) {
+  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.ANVIL_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 { __ANVIL_TREE_SITTER_WASM_PATH__?: string }
+  ).__ANVIL_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 { __ANVIL_TREE_SITTER_WASM_BINARY__?: Uint8Array }
+    ).__ANVIL_TREE_SITTER_WASM_BINARY__ = new Uint8Array(
+      buf.buffer,
+      buf.byteOffset,
+      buf.byteLength,
+    )
+  } catch (err) {
+    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/src/project-files.ts

@@ -0,0 +1,102 @@
+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/src/setup/key-setup.ts

@@ -0,0 +1,295 @@
+/**
+ * Interactive key-setup wizard for first-time CLI boot.
+ *
+ * Prompts the user to paste API keys for DeepSeek (required), Gemini
+ * (required), and Serper (optional). Saves them to .env.local so they
+ * persist across sessions.
+ *
+ * Runs BEFORE the TUI renderer starts, using plain console I/O.
+ */
+
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { createInterface } from 'readline'
+
+import { cyan, green, yellow, bold, dim } from 'picocolors'
+
+// ─── constants ───────────────────────────────────────────────────────────────
+
+const REQUIRED_KEYS = [
+  {
+    envVar: 'DEEPSEEK_API_KEY',
+    label: 'DeepSeek API Key',
+    helpUrl: 'https://platform.deepseek.com/api_keys',
+    description: 'Powers the main coding agent (DeepSeek V4).',
+  },
+  {
+    envVar: 'GEMINI_API_KEY',
+    label: 'Gemini API Key',
+    helpUrl: 'https://aistudio.google.com/apikey',
+    description: 'Powers vision analysis, file search, and helper sub-agents.',
+  },
+] as const
+
+const OPTIONAL_KEYS = [
+  {
+    envVar: 'SERPER_API_KEY',
+    label: 'Serper API Key',
+    helpUrl: 'https://serper.dev',
+    description: 'Enables Google Search (web_search tool). Without it, web search is disabled.',
+  },
+] as const
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function askQuestion(
+  rl: ReturnType<typeof createInterface>,
+  question: string,
+): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer.trim())
+    })
+  })
+}
+
+function isValidApiKey(key: string): boolean {
+  // Loose check: non-empty, no whitespace, reasonable length
+  return key.length > 5 && !/\s/.test(key)
+}
+
+function maskKey(key: string): string {
+  if (key.length <= 8) return '••••••••'
+  return key.slice(0, 4) + '•'.repeat(Math.min(key.length - 8, 20)) + key.slice(-4)
+}
+
+// ─── .env.local writer ───────────────────────────────────────────────────────
+
+function getGlobalEnvPath(): string {
+  return path.join(os.homedir(), '.env.local')
+}
+
+function readExistingEnv(filePath: string): Record<string, string> {
+  const result: Record<string, string> = {}
+  if (!fs.existsSync(filePath)) return result
+
+  const content = fs.readFileSync(filePath, 'utf-8')
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#') || line.startsWith('//')) continue
+    const eqIndex = line.indexOf('=')
+    if (eqIndex === -1) continue
+    const key = line.slice(0, eqIndex).trim()
+    let value = line.slice(eqIndex + 1).trim()
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    if (key) result[key] = value
+  }
+  return result
+}
+
+function writeEnvFile(
+  filePath: string,
+  vars: Record<string, string>,
+): void {
+  const lines: string[] = [
+    '# API keys for Anvil / Freebuff CLI',
+    '# Generated by the setup wizard — do not commit this file.',
+    '',
+  ]
+
+  // Group: required keys first, then optional, then anything else
+  const allKeyOrder = [
+    ...REQUIRED_KEYS.map((k) => k.envVar),
+    ...OPTIONAL_KEYS.map((k) => k.envVar),
+  ]
+
+  const written = new Set<string>()
+
+  for (const key of allKeyOrder) {
+    if (key in vars) {
+      lines.push(`${key}=${vars[key]}`)
+      written.add(key)
+    }
+  }
+
+  // Append any extra keys not in our schema
+  for (const [key, value] of Object.entries(vars)) {
+    if (!written.has(key)) {
+      lines.push(`${key}=${value}`)
+    }
+  }
+
+  lines.push('')
+  fs.writeFileSync(filePath, lines.join('\n'), 'utf-8')
+}
+
+// ─── main wizard ─────────────────────────────────────────────────────────────
+
+export interface KeySetupResult {
+  /** true if the wizard ran and saved keys */
+  completed: boolean
+  /** true if all required keys are present (either pre-existing or entered) */
+  allRequired: boolean
+}
+
+/**
+ * Run the interactive key-setup wizard.
+ *
+ * @param cwd  Project root (where .env.local is written)
+ * @param force  If true, re-prompt even if keys already exist (for `setup` command)
+ */
+export async function runKeySetup(
+  _cwd: string,
+  force = false,
+): Promise<KeySetupResult> {
+  const envPath = getGlobalEnvPath()
+  const existing = readExistingEnv(envPath)
+
+  // Check which keys are already set (in existing .env.local OR in process.env)
+  const hasKey = (envVar: string): boolean =>
+    Boolean(existing[envVar] || process.env[envVar])
+
+  const missingRequired = REQUIRED_KEYS.filter((k) => !hasKey(k.envVar))
+  const missingOptional = OPTIONAL_KEYS.filter((k) => !hasKey(k.envVar))
+
+  // If nothing is missing and not forced, skip the wizard
+  if (missingRequired.length === 0 && missingOptional.length === 0 && !force) {
+    return { completed: false, allRequired: true }
+  }
+
+  console.log()
+  console.log(bold('  ╔══════════════════════════════════════════════╗'))
+  console.log(bold('  ║         🔑  API Key Setup Wizard            ║'))
+  console.log(bold('  ╚══════════════════════════════════════════════╝'))
+  console.log()
+
+  if (missingRequired.length > 0) {
+    console.log(cyan('  Required keys to get started:'))
+    console.log()
+    for (const k of missingRequired) {
+      console.log(`    ${bold(k.label)}`)
+      console.log(`      ${dim(k.description)}`)
+      console.log(`      Get one at: ${cyan(k.helpUrl)}`)
+      console.log()
+    }
+  }
+
+  if (missingOptional.length > 0 && !force) {
+    console.log(yellow('  Optional keys (can be added later):'))
+    console.log()
+    for (const k of missingOptional) {
+      console.log(`    ${bold(k.label)}`)
+      console.log(`      ${dim(k.description)}`)
+      console.log(`      Get one at: ${cyan(k.helpUrl)}`)
+      console.log()
+    }
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  const newVars: Record<string, string> = { ...existing }
+
+  try {
+    // ── Required keys ──────────────────────────────────────────────────
+    for (const k of REQUIRED_KEYS) {
+      if (hasKey(k.envVar) && !force) continue
+
+      const existingVal = existing[k.envVar] || process.env[k.envVar]
+      const suffix = existingVal ? ` ${dim(`(currently: ${maskKey(existingVal)})`)}` : ''
+
+      let attempts = 0
+      while (attempts < 3) {
+        const answer = await askQuestion(
+          rl,
+          `  Paste your ${k.label}${suffix}\n  → `,
+        )
+
+        // Allow skipping if there's already a value (force mode)
+        if (!answer && existingVal) {
+          newVars[k.envVar] = existingVal
+          break
+        }
+
+        if (!answer) {
+          console.log(yellow(`  ⚠ ${k.label} is required. Press Ctrl+C to abort.`))
+          attempts++
+          continue
+        }
+
+        if (!isValidApiKey(answer)) {
+          console.log(yellow('  ⚠ That doesn\'t look like a valid API key. Please try again.'))
+          attempts++
+          continue
+        }
+
+        newVars[k.envVar] = answer
+        console.log(green(`  ✓ ${k.label} saved`))
+        console.log()
+        break
+      }
+
+      if (attempts >= 3) {
+        console.log()
+        console.log(yellow('  Too many attempts. Please set the key manually in .env.local'))
+        console.log(yellow(`  and re-run the CLI.`))
+        console.log()
+        rl.close()
+        return { completed: false, allRequired: false }
+      }
+    }
+
+    // ── Optional keys ──────────────────────────────────────────────────
+    for (const k of OPTIONAL_KEYS) {
+      if (hasKey(k.envVar) && !force) continue
+
+      const existingVal = existing[k.envVar] || process.env[k.envVar]
+      const suffix = existingVal ? ` ${dim(`(currently: ${maskKey(existingVal)})`)}` : ''
+
+      const answer = await askQuestion(
+        rl,
+        `  Paste your ${k.label} ${dim('(optional, press Enter to skip)')}${suffix}\n  → `,
+      )
+
+      if (answer && isValidApiKey(answer)) {
+        newVars[k.envVar] = answer
+        console.log(green(`  ✓ ${k.label} saved`))
+        console.log()
+      } else if (answer && !isValidApiKey(answer)) {
+        console.log(yellow('  ⚠ Invalid format, skipping.'))
+        console.log()
+      } else {
+        console.log(dim('  Skipped.'))
+        console.log()
+      }
+    }
+  } finally {
+    rl.close()
+  }
+
+  // ── Save to .env.local ────────────────────────────────────────────────
+  writeEnvFile(envPath, newVars)
+
+  // Also load into process.env so the current session works immediately
+  for (const [key, value] of Object.entries(newVars)) {
+    if (!process.env[key]) {
+      process.env[key] = value
+    }
+  }
+
+  console.log(green(`  ✓ Keys saved to ${envPath}`))
+  console.log()
+  console.log(dim('  Tip: Add .env.local to your .gitignore to keep keys out of git.'))
+  console.log()
+
+  const allRequired = REQUIRED_KEYS.every((k) => Boolean(newVars[k.envVar]))
+  return { completed: true, allRequired }
+}

package/src/setup/load-env.ts

@@ -0,0 +1,106 @@
+/**
+ * Load environment variables from .env.local at runtime.
+ *
+ * Keys live in the user's HOME directory (~/.env.local) so they persist
+ * across every project and working directory. Bun does NOT auto-load
+ * .env.local for compiled binaries, so this module parses the simple
+ * KEY=VALUE format and applies values to process.env.
+ */
+
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+
+/**
+ * Resolve the global .env.local path in the user's home directory.
+ */
+function getGlobalEnvPath(): string {
+  return path.join(os.homedir(), '.env.local')
+}
+
+/**
+ * Parse a .env.local file into a record of key → value.
+ * Handles:
+ *   - # and // comments
+ *   - KEY=value, KEY="value", KEY='value'
+ *   - Trims whitespace around keys and values
+ */
+function parseEnvFile(content: string): Record<string, string> {
+  const result: Record<string, string> = {}
+
+  for (const rawLine of content.split('\n')) {
+    const line = rawLine.trim()
+
+    // Skip empty lines and comments
+    if (!line || line.startsWith('#') || line.startsWith('//')) continue
+
+    const eqIndex = line.indexOf('=')
+    if (eqIndex === -1) continue
+
+    const key = line.slice(0, eqIndex).trim()
+    let value = line.slice(eqIndex + 1).trim()
+
+    // Strip surrounding quotes (single or double)
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+
+    if (key) {
+      result[key] = value
+    }
+  }
+
+  return result
+}
+
+/**
+ * Load .env.local into process.env. Existing env vars are NOT overwritten.
+ * Looks in ~/  .env.local first, then walks up from cwd.
+ *
+ * @returns The path to the loaded .env.local, or null if none found.
+ */
+export function loadEnvLocal(cwd?: string): string | null {
+  // Always check the global home-dir location first.
+  const globalPath = getGlobalEnvPath()
+  let envPath: string | null = null
+
+  if (fs.existsSync(globalPath)) {
+    envPath = globalPath
+  } else if (cwd) {
+    // Fallback: walk up from cwd (legacy behavior).
+    let dir = path.resolve(cwd)
+    const root = path.parse(dir).root
+    while (dir !== root) {
+      const candidate = path.join(dir, '.env.local')
+      if (fs.existsSync(candidate)) {
+        envPath = candidate
+        break
+      }
+      const parent = path.dirname(dir)
+      if (parent === dir) break
+      dir = parent
+    }
+  }
+
+  if (!envPath) return null
+
+  const content = fs.readFileSync(envPath, 'utf-8')
+  const vars = parseEnvFile(content)
+
+  let loaded = 0
+  for (const [key, value] of Object.entries(vars)) {
+    if (!(key in process.env)) {
+      process.env[key] = value
+      loaded++
+    }
+  }
+
+  if (loaded > 0) {
+    console.log(`  Loaded ${loaded} env var(s) from ${envPath}`)
+  }
+
+  return envPath
+}

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

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