@alumbwe/anvil 1.0.0 → 1.0.2

package/src/utils/anvil-client.ts

@@ -1,217 +0,0 @@
-import { API_KEY_ENV_VAR } from '@anvil/common/old-constants'
-import { AskUserBridge } from '@anvil/common/utils/ask-user-bridge'
-import { AnvilClient } from '@anvil/sdk'
-
-import { getAuthTokenDetails } from './auth'
-import { getCliEnv, getSystemProcessEnv } from './env'
-import { loadAgentDefinitions } from './local-agent-registry'
-import { logger } from './logger'
-import { createTraceWriter } from './trace-writer'
-import { terminalCommandBroker } from './terminal-command-broker'
-import { getRgPath } from '../native/ripgrep'
-import { getProjectRoot } from '../project-files'
-
-import type { ClientToolCall } from '@anvil/common/tools/list'
-
-let clientInstance: AnvilClient | null = null
-
-/**
- * Recursively removes undefined values from an object to ensure clean JSON serialization.
- * This prevents issues with APIs that don't accept explicit undefined values.
- */
-function removeUndefinedValues<T>(obj: T): T {
-  if (obj === null || obj === undefined) {
-    return obj
-  }
-  if (Array.isArray(obj)) {
-    return obj.map(removeUndefinedValues) as T
-  }
-  if (typeof obj === 'object') {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(obj)) {
-      if (value !== undefined) {
-        result[key] = removeUndefinedValues(value)
-      }
-    }
-    return result as T
-  }
-  return obj
-}
-
-/**
- * Reset the cached AnvilClient instance.
- * This should be called after login to ensure the client is re-initialized with new credentials.
- */
-export function resetAnvilClient(): void {
-  clientInstance = null
-}
-
-export async function getAnvilClient(): Promise<AnvilClient | null> {
-  if (!clientInstance) {
-    const { token: apiKey } = getAuthTokenDetails()
-
-    if (!apiKey) {
-      logger.warn(
-        {},
-        `No authentication token found. Please run the login flow or set ${API_KEY_ENV_VAR}.`,
-      )
-      return null
-    }
-
-    const projectRoot = getProjectRoot()
-
-    // Set up ripgrep path for SDK to use
-    const env = getCliEnv()
-    if (env.ANVIL_IS_BINARY) {
-      try {
-        const rgPath = await getRgPath()
-        // Note: We still set process.env here because SDK reads from it
-        getSystemProcessEnv().ANVIL_RG_PATH = rgPath
-      } catch (error) {
-        logger.error(error, 'Failed to set up ripgrep binary for SDK')
-      }
-    }
-
-    try {
-      const agentDefinitions = loadAgentDefinitions()
-      clientInstance = new AnvilClient({
-        apiKey,
-        cwd: projectRoot,
-        agentDefinitions,
-        logger,
-        traceWriter: createTraceWriter(),
-        terminalCommandBroker,
-        overrideTools: {
-          ask_user: async (input: ClientToolCall<'ask_user'>['input']) => {
-            const askUserResponse = await AskUserBridge.request(
-              'cli-override',
-              input.questions,
-            )
-            const response = askUserResponse as {
-              answers?: Array<{ questionIndex: number; selectedOption: string }>
-              skipped?: boolean
-            }
-            return [
-              {
-                type: 'json',
-                value: removeUndefinedValues(response),
-              },
-            ]
-          },
-        },
-      })
-    } catch (error) {
-      logger.error(error, 'Failed to initialize AnvilClient')
-      return null
-    }
-  }
-
-  return clientInstance
-}
-
-export function getToolDisplayInfo(toolName: string): {
-  name: string
-  type: string
-} {
-  const TOOL_NAME_OVERRIDES: Record<string, string> = {
-    list_directory: 'List Directories',
-  }
-
-  const capitalizeWords = (str: string) => {
-    return str.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase())
-  }
-
-  return {
-    name: TOOL_NAME_OVERRIDES[toolName] ?? capitalizeWords(toolName),
-    type: 'tool',
-  }
-}
-
-function toYaml(obj: any, indent = 0): string {
-  const spaces = '  '.repeat(indent)
-
-  if (obj === null || obj === undefined) {
-    return 'null'
-  }
-
-  if (typeof obj === 'string') {
-    if (obj.includes('\n')) {
-      const lines = obj.split('\n')
-      return (
-        '|\n' + lines.map((line) => '  '.repeat(indent + 1) + line).join('\n')
-      )
-    }
-    return obj.includes(':') || obj.includes('#') ? `"${obj}"` : obj
-  }
-
-  if (typeof obj === 'number' || typeof obj === 'boolean') {
-    return String(obj)
-  }
-
-  if (Array.isArray(obj)) {
-    if (obj.length === 0) return '[]'
-    return (
-      '\n' +
-      obj
-        .map((item) => spaces + '- ' + toYaml(item, indent + 1).trimStart())
-        .join('\n')
-    )
-  }
-
-  if (typeof obj === 'object') {
-    const entries = Object.entries(obj)
-    if (entries.length === 0) return '{}'
-
-    return entries
-      .map(([key, value]) => {
-        const yamlValue = toYaml(value, indent + 1)
-        if (
-          typeof value === 'object' &&
-          value !== null &&
-          !Array.isArray(value) &&
-          Object.keys(value).length > 0
-        ) {
-          return `${spaces}${key}:\n${yamlValue}`
-        }
-        if (typeof value === 'string' && value.includes('\n')) {
-          return `${spaces}${key}: ${yamlValue}`
-        }
-        return `${spaces}${key}: ${yamlValue}`
-      })
-      .join('\n')
-  }
-
-  return String(obj)
-}
-
-export function formatToolOutput(output: unknown): string {
-  if (!output) return ''
-
-  if (Array.isArray(output)) {
-    return output
-      .map((item) => {
-        if (item.type === 'json') {
-          // Handle errorMessage in the value object
-          if (
-            item.value &&
-            typeof item.value === 'object' &&
-            'errorMessage' in item.value
-          ) {
-            return String(item.value.errorMessage)
-          }
-          return toYaml(item.value)
-        }
-        if (item.type === 'text') {
-          return item.text || ''
-        }
-        return String(item)
-      })
-      .join('\n')
-  }
-
-  if (typeof output === 'string') {
-    return output
-  }
-
-  return toYaml(output)
-}

package/src/utils/arrays.ts

@@ -1,117 +0,0 @@
-/** Python-style range function */
-export function* range(start: number, stop?: number, step: number = 1) {
-  if (stop === undefined) {
-    stop = start
-    start = 0
-  }
-
-  if (step === 0) {
-    throw new Error('Step cannot be zero')
-  }
-
-  if (step > 0) {
-    for (let i = start; i < stop; i += step) {
-      yield i
-    }
-  } else {
-    for (let i = start; i > stop; i += step) {
-      yield i
-    }
-  }
-}
-
-export function repeated<T>(value: T, count: number): T[] {
-  return Array.from({ length: count }, () => value)
-}
-
-export class Queue<T> {
-  private _items: T[]
-  private _head: number
-  private _length: number
-  private _defaultCapacity: number
-
-  constructor(items: T[] | undefined = undefined, capacity: number = 100) {
-    this._defaultCapacity = capacity
-    if (!items) {
-      items = []
-    }
-    this._items = items.length
-      ? [
-          ...items,
-          ...repeated(undefined as T, Math.max(0, capacity - items.length)),
-        ]
-      : [undefined as T]
-    this._head = 0
-    this._length = items.length
-  }
-
-  static from<T>(iterable: Iterable<T>): Queue<T> {
-    return new Queue<T>([...iterable])
-  }
-
-  enqueue(...items: T[]) {
-    if (this._items.length < this._length + items.length) {
-      const newItems = [
-        ...repeated(undefined as T, this._length),
-        ...items,
-        ...repeated(undefined as T, this._length),
-      ]
-      for (let i = 0; i < this._length; i++) {
-        newItems[i] = this.at(i)!
-      }
-
-      this._items = newItems
-      this._head = 0
-      this._length += items.length
-      return
-    }
-
-    let index = (this._head + this._length) % this._items.length
-    for (const item of items) {
-      this._items[index] = item
-      index = (index + 1) % this._items.length
-    }
-    this._length += items.length
-  }
-
-  dequeue(): T | undefined {
-    if (this._length === 0) {
-      return undefined
-    }
-
-    const item = this._items[this._head]
-    this._items[this._head] = undefined as T
-    this._head = (this._head + 1) % this._items.length
-    this._length--
-    return item
-  }
-
-  peek(): T | undefined {
-    if (this._length === 0) {
-      return undefined
-    }
-    return this._items[this._head]
-  }
-
-  at(index: number): T | undefined {
-    if (index >= this._length || index < -this.length) {
-      return undefined
-    }
-    if (index < 0) {
-      return this._items[
-        (this._head + this._length + index) % this._items.length
-      ]
-    }
-    return this._items[(this._head + index) % this._items.length]
-  }
-
-  clear(): void {
-    this._items = repeated(undefined as T, this._defaultCapacity)
-    this._head = 0
-    this._length = 0
-  }
-
-  get length() {
-    return this._length
-  }
-}

package/src/utils/auth.ts

@@ -1,258 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-import { getCiEnv } from '@anvil/common/env-ci'
-import { getDirectDeepSeekApiKey } from '@anvil/common/constants/deepseek-direct'
-import { z } from 'zod'
-
-
-import { getApiClient, setApiClientAuthToken } from './anvil-api'
-import { getConfigDir as getConfigDirBase } from './config-dir'
-import { logger } from './logger'
-
-import type { CiEnv } from '@anvil/common/types/contracts/env'
-
-// User schema
-const userSchema = z.object({
-  id: z.string().optional(),
-  name: z.string(),
-  email: z.string(),
-  authToken: z.string(),
-  fingerprintId: z.string().optional(),
-  fingerprintHash: z.string().optional(),
-  credits: z.number().optional(),
-})
-
-export type User = z.infer<typeof userSchema>
-
-const credentialsSchema = z
-  .object({
-    default: userSchema.optional(),
-  })
-  .catchall(z.unknown())
-
-// Get the config directory path.
-// Re-exported as a wrapper (rather than a bare `export ... from`) so existing
-// tests can still `spyOn(authModule, 'getConfigDir')`.
-export const getConfigDir = (): string => getConfigDirBase()
-
-// Get the credentials file path
-export const getCredentialsPath = (): string => {
-  return path.join(getConfigDir(), 'credentials.json')
-}
-
-/**
- * Parse user from JSON string
- */
-const userFromJson = (
-  json: string,
-  profileName: string = 'default',
-): User | undefined => {
-  try {
-    const allCredentials = credentialsSchema.parse(JSON.parse(json))
-    const profile = allCredentials[profileName]
-    // Validate that the profile matches the user schema
-    const parsed = userSchema.safeParse(profile)
-    return parsed.success ? parsed.data : undefined
-  } catch (error) {
-    logger.error(
-      {
-        errorMessage: error instanceof Error ? error.message : String(error),
-        errorStack: error instanceof Error ? error.stack : undefined,
-        profileName,
-      },
-      'Error parsing user JSON',
-    )
-    return
-  }
-}
-
-/**
- * Get user credentials from file system
- * @returns User object or null if not found/authenticated
- */
-export const getUserCredentials = (): User | null => {
-  const credentialsPath = getCredentialsPath()
-
-  // Read user credentials directly from file
-  if (!fs.existsSync(credentialsPath)) {
-    return null
-  }
-
-  try {
-    const credentialsFile = fs.readFileSync(credentialsPath, 'utf8')
-    const user = userFromJson(credentialsFile)
-    return user || null
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error reading credentials',
-    )
-    return null
-  }
-}
-
-export type AuthTokenSource = 'credentials' | 'environment' | null
-
-export interface AuthTokenDetails {
-  token?: string
-  source: AuthTokenSource
-}
-
-/**
- * Resolve the auth token and track where it came from.
- */
-export const getAuthTokenDetails = (
-  ciEnv: CiEnv = getCiEnv(),
-): AuthTokenDetails => {
-  const userCredentials = getUserCredentials()
-  if (userCredentials?.authToken) {
-    return { token: userCredentials.authToken, source: 'credentials' }
-  }
-
-  const envToken = ciEnv.ANVIL_API_KEY
-  if (envToken) {
-    return { token: envToken, source: 'environment' }
-  }
-
-  // Direct-to-DeepSeek mode: the DeepSeek key doubles as the auth token so
-  // the CLI treats the user as authenticated without a Anvil backend.
-  const deepseekToken = getDirectDeepSeekApiKey()
-  if (deepseekToken) {
-    return { token: deepseekToken, source: 'environment' }
-  }
-
-  return { source: null }
-}
-
-/**
- * Get the auth token from user credentials or environment variable
- */
-export const getAuthToken = (): string | undefined => {
-  return getAuthTokenDetails().token
-}
-
-/**
- * Check if the user has authentication credentials (but doesn't validate them)
- */
-export const hasAuthCredentials = (): boolean => {
-  return !!getAuthTokenDetails().token
-}
-
-export interface AuthValidationResult {
-  authenticated: boolean
-  hasInvalidCredentials: boolean
-}
-
-/**
- * Read existing credentials file, returns empty object if missing/invalid.
- *
- * Drops `chatgptOAuth`, which the removed ChatGPT integration wrote. Both
- * callers spread this result straight back over the file, so the dead key —
- * an OAuth access and refresh token for the user's ChatGPT account — is
- * cleaned up the next time we write for any reason. Doing it here rather than
- * in a startup pass means no extra write and no new race with login/logout;
- * nothing reads the key anymore, and with /connect gone the user has no way
- * to clear it themselves.
- */
-const readCredentialsFile = (): Record<string, unknown> => {
-  const credentialsPath = getCredentialsPath()
-  if (!fs.existsSync(credentialsPath)) return {}
-  try {
-    const { chatgptOAuth: _removedIntegration, ...rest } = JSON.parse(
-      fs.readFileSync(credentialsPath, 'utf8'),
-    )
-    return rest
-  } catch {
-    return {}
-  }
-}
-
-/**
- * Save user credentials to file system.
- */
-export const saveUserCredentials = (user: User): void => {
-  const configDir = getConfigDir()
-  const credentialsPath = getCredentialsPath()
-
-  try {
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true })
-    }
-
-    const updatedData = { ...readCredentialsFile(), default: user }
-    fs.writeFileSync(credentialsPath, JSON.stringify(updatedData, null, 2))
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error saving credentials',
-    )
-    throw error
-  }
-}
-
-/**
- * Clear user credentials from file system.
- * Only removes the 'default' field, preserving other credentials.
- */
-export const clearUserCredentials = (): void => {
-  const credentialsPath = getCredentialsPath()
-
-  try {
-    if (!fs.existsSync(credentialsPath)) return
-
-    const { default: _, ...rest } = readCredentialsFile()
-
-    if (Object.keys(rest).length === 0) {
-      fs.unlinkSync(credentialsPath)
-    } else {
-      fs.writeFileSync(credentialsPath, JSON.stringify(rest, null, 2))
-    }
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error clearing credentials',
-    )
-    throw error
-  }
-}
-
-export async function logoutUser(): Promise<boolean> {
-  try {
-    const user = getUserCredentials()
-    if (user?.authToken) {
-      setApiClientAuthToken(user.authToken)
-      const apiClient = getApiClient()
-      try {
-        const response = await apiClient.logout({
-          userId: user.id,
-          fingerprintId: user.fingerprintId,
-          fingerprintHash: user.fingerprintHash,
-        })
-        if (!response.ok) {
-          logger.error(
-            { status: response.status, error: response.error },
-            'Logout request failed',
-          )
-        }
-      } catch (err) {
-        logger.error(err, 'Logout request error')
-      }
-    }
-  } catch (error) {
-    logger.error(error, 'Unexpected error preparing logout')
-  }
-
-  try {
-    clearUserCredentials()
-  } catch (error) {
-    logger.debug({ error }, 'Failed to clear credentials during logout')
-  }
-  return true
-}

package/src/utils/bash-context-processor.ts

@@ -1,47 +0,0 @@
-import {
-  buildBashHistoryMessages,
-  createRunTerminalToolResult,
-  formatBashContextForPrompt,
-} from './bash-messages'
-
-import type { PendingBashMessage } from '../types/store'
-import type { ChatMessage } from '../types/chat'
-
-// Turns pending bash executions into chat history messages and prompt context.
-export const processBashContext = (
-  pendingBashMessages: PendingBashMessage[],
-): {
-  bashMessages: ChatMessage[]
-  bashContextForPrompt: string
-} => {
-  const bashContextForPrompt = formatBashContextForPrompt(pendingBashMessages)
-  const bashMessages: ChatMessage[] = []
-
-  for (const bash of pendingBashMessages) {
-    if (bash.addedToHistory) {
-      continue
-    }
-
-    const toolCallId = crypto.randomUUID()
-    const cwd = bash.cwd || process.cwd()
-    const toolResultOutput = createRunTerminalToolResult({
-      command: bash.command,
-      cwd,
-      stdout: bash.stdout || null,
-      stderr: bash.stderr || null,
-      exitCode: bash.exitCode,
-    })
-    const outputJson = JSON.stringify(toolResultOutput)
-    const { assistantMessage } = buildBashHistoryMessages({
-      command: bash.command,
-      cwd,
-      toolCallId,
-      output: outputJson,
-      isComplete: true,
-    })
-
-    bashMessages.push(assistantMessage)
-  }
-
-  return { bashMessages, bashContextForPrompt }
-}