@alumbwe/anvil 1.0.0 → 1.0.1

package/src/utils/message-history.ts

@@ -1,143 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-
-import { getConfigDir } from './auth'
-import { formatTimestamp } from './helpers'
-import { logger } from './logger'
-
-import type { ChatMessage, ContentBlock, FileAttachment, ImageAttachment, TextAttachment } from '../types/chat'
-
-const MAX_HISTORY_SIZE = 1000
-
-export function getUserMessage(
-  message: string | ContentBlock[],
-  attachments?: ImageAttachment[],
-  textAttachments?: TextAttachment[],
-  fileAttachments?: FileAttachment[],
-): ChatMessage {
-  return {
-    id: `user-${Date.now()}`,
-    variant: 'user',
-    ...(typeof message === 'string'
-      ? {
-          content: message,
-        }
-      : {
-          content: '',
-          blocks: message,
-        }),
-    timestamp: formatTimestamp(),
-    ...(attachments && attachments.length > 0 ? { attachments } : {}),
-    ...(textAttachments && textAttachments.length > 0 ? { textAttachments } : {}),
-    ...(fileAttachments && fileAttachments.length > 0 ? { fileAttachments } : {}),
-  }
-}
-
-export function getSystemMessage(
-  content: string | ContentBlock[],
-): ChatMessage {
-  return {
-    id: `sys-${Date.now()}`,
-    variant: 'ai' as const,
-    ...(typeof content === 'string'
-      ? {
-          content,
-        }
-      : {
-          content: '',
-          blocks: content,
-        }),
-    timestamp: formatTimestamp(),
-  }
-}
-
-/**
- * Get the message history file path
- */
-export const getMessageHistoryPath = (): string => {
-  return path.join(getConfigDir(), 'message-history.json')
-}
-
-/**
- * Load message history from file system
- * @returns Array of previous messages, most recent last
- */
-export const loadMessageHistory = (): string[] => {
-  const historyPath = getMessageHistoryPath()
-
-  if (!fs.existsSync(historyPath)) {
-    return []
-  }
-
-  try {
-    const historyFile = fs.readFileSync(historyPath, 'utf8')
-    const history = JSON.parse(historyFile)
-
-    if (!Array.isArray(history)) {
-      logger.warn('Message history file has invalid format, resetting')
-      return []
-    }
-
-    return history.filter((item) => typeof item === 'string')
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error reading message history',
-    )
-    return []
-  }
-}
-
-/**
- * Save message history to file system
- */
-export const saveMessageHistory = (history: string[]): void => {
-  const configDir = getConfigDir()
-  const historyPath = getMessageHistoryPath()
-
-  try {
-    // Ensure config directory exists
-    if (!fs.existsSync(configDir)) {
-      fs.mkdirSync(configDir, { recursive: true })
-    }
-
-    // Limit history size to prevent file from growing too large
-    const limitedHistory =
-      history.length > MAX_HISTORY_SIZE
-        ? history.slice(history.length - MAX_HISTORY_SIZE)
-        : history
-
-    // Save history
-    fs.writeFileSync(historyPath, JSON.stringify(limitedHistory, null, 2))
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error saving message history',
-    )
-    // Don't throw - history persistence is not critical
-  }
-}
-
-/**
- * Clear message history from file system
- */
-export const clearMessageHistory = (): void => {
-  const historyPath = getMessageHistoryPath()
-
-  try {
-    if (fs.existsSync(historyPath)) {
-      fs.unlinkSync(historyPath)
-    }
-  } catch (error) {
-    logger.error(
-      {
-        error: error instanceof Error ? error.message : String(error),
-      },
-      'Error clearing message history',
-    )
-  }
-}

package/src/utils/message-tree-utils.ts

@@ -1,67 +0,0 @@
-import type { ChatMessage } from '../types/chat'
-
-export function buildMessageTree(messages: ChatMessage[]): {
-  tree: Map<string, ChatMessage[]>
-  topLevelMessages: ChatMessage[]
-} {
-  const messageTree = new Map<string, ChatMessage[]>()
-  const topLevelMessages: ChatMessage[] = []
-
-  for (const message of messages) {
-    if (message.parentId) {
-      const siblings = messageTree.get(message.parentId) ?? []
-      siblings.push(message)
-      messageTree.set(message.parentId, siblings)
-    } else {
-      topLevelMessages.push(message)
-    }
-  }
-
-  return { tree: messageTree, topLevelMessages }
-}
-
-export function getDescendantIds(
-  agentId: string,
-  tree: Map<string, ChatMessage[]>,
-): string[] {
-  const children = tree.get(agentId) ?? []
-  const descendantIds: string[] = []
-
-  for (const child of children) {
-    if (child.variant === 'agent') {
-      descendantIds.push(child.id)
-      descendantIds.push(...getDescendantIds(child.id, tree))
-    }
-  }
-
-  return descendantIds
-}
-
-export function getAncestorIds(
-  agentId: string,
-  messages: ChatMessage[],
-): string[] {
-  const agent = messages.find((m) => m.id === agentId)
-  if (!agent || !agent.parentId) return []
-
-  const parent = messages.find((m) => m.id === agent.parentId)
-  if (!parent || parent.variant !== 'agent') return []
-
-  return [parent.id, ...getAncestorIds(parent.id, messages)]
-}
-
-export function isAgentVisible(
-  agentId: string,
-  messages: ChatMessage[],
-  collapsedAgents: Set<string>,
-): boolean {
-  const agent = messages.find((m) => m.id === agentId)
-  if (!agent || agent.variant !== 'agent') return false
-
-  const parent = messages.find((m) => m.id === agent.parentId)
-  if (!parent || parent.variant !== 'agent') return true
-
-  if (collapsedAgents.has(parent.id)) return false
-
-  return isAgentVisible(parent.id, messages, collapsedAgents)
-}

package/src/utils/message-updater.ts

@@ -1,279 +0,0 @@
-import type { ChatMessage, ContentBlock, TextContentBlock } from '../types/chat'
-
-// Small wrapper to avoid repeating the ai-message map/update pattern.
-export type SetMessagesFn = (
-  updater: (messages: ChatMessage[]) => ChatMessage[],
-) => void
-
-export type MessageUpdater = {
-  updateAiMessage: (updater: (msg: ChatMessage) => ChatMessage) => void
-  updateAiMessageBlocks: (
-    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
-  ) => void
-  markComplete: (metadata?: Partial<ChatMessage>) => void
-  setError: (message: string) => void
-  /** Clears the userError field (e.g., when a new message is sent successfully) */
-  clearUserError: () => void
-  addBlock: (block: ContentBlock) => void
-}
-
-/** Extended updater with batching control methods */
-export type BatchedMessageUpdater = MessageUpdater & {
-  /** Immediately flush all pending updates to state */
-  flush: () => void
-  /** Stop the flush interval and clean up. Called automatically by markComplete/setError */
-  dispose: () => void
-}
-
-/** Default interval for batched updates in milliseconds */
-export const DEFAULT_FLUSH_INTERVAL_MS = 100
-
-export const createMessageUpdater = (
-  aiMessageId: string,
-  setMessages: SetMessagesFn,
-): MessageUpdater => {
-  const updateAiMessage = (updater: (msg: ChatMessage) => ChatMessage) => {
-    setMessages((prev) =>
-      prev.map((msg) => (msg.id === aiMessageId ? updater(msg) : msg)),
-    )
-  }
-
-  const updateAiMessageBlocks = (
-    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
-  ) => {
-    updateAiMessage((msg) => ({
-      ...msg,
-      blocks: blockUpdater(msg.blocks ?? []),
-    }))
-  }
-
-  const addBlock = (block: ContentBlock) => {
-    updateAiMessage((msg) => ({
-      ...msg,
-      blocks: [...(msg.blocks ?? []), block],
-    }))
-  }
-
-  const markComplete = (metadata?: Partial<ChatMessage>) => {
-    updateAiMessage((msg) => {
-      const { metadata: messageMetadata, ...rest } = metadata ?? {}
-      
-      // Mark native reasoning blocks as complete by setting thinkingOpen = false
-      // This ensures thinking blocks auto-collapse when the message finishes
-      // Check for thinkingOpen !== false to handle both true (native) and undefined (legacy)
-      const updatedBlocks = msg.blocks?.map((block) => {
-        if (
-          block.type === 'text' &&
-          (block as TextContentBlock).textType === 'reasoning' &&
-          (block as TextContentBlock).thinkingOpen !== false
-        ) {
-          return { ...block, thinkingOpen: false } as ContentBlock
-        }
-        return block
-      })
-      
-      const nextMessage: ChatMessage = {
-        ...msg,
-        isComplete: true,
-        ...(updatedBlocks && { blocks: updatedBlocks }),
-        ...rest,
-      }
-
-      if (messageMetadata) {
-        nextMessage.metadata = {
-          ...(msg.metadata ?? {}),
-          ...messageMetadata,
-        }
-      }
-
-      return nextMessage
-    })
-  }
-
-  const setError = (message: string) => {
-    updateAiMessage((msg) => ({
-      ...msg,
-      userError: message,
-      isComplete: true,
-    }))
-  }
-
-  /**
-   * Clears the userError field from the message.
-   * Call this when starting a new successful interaction to dismiss any previous error banners.
-   */
-  const clearUserError = () => {
-    updateAiMessage((msg) => {
-      if (!msg.userError) return msg
-      const { userError: _, ...rest } = msg
-      return rest as ChatMessage
-    })
-  }
-
-  return {
-    updateAiMessage,
-    updateAiMessageBlocks,
-    markComplete,
-    setError,
-    clearUserError,
-    addBlock,
-  }
-}
-
-/** Batched updater that queues updates and flushes at a regular interval. */
-export const createBatchedMessageUpdater = (
-  aiMessageId: string,
-  setMessages: SetMessagesFn,
-  flushIntervalMs: number = DEFAULT_FLUSH_INTERVAL_MS,
-): BatchedMessageUpdater => {
-  // Queue of message updater functions to be applied on next flush
-  const pendingUpdaters: Array<(msg: ChatMessage) => ChatMessage> = []
-  let intervalId: ReturnType<typeof setInterval> | null = null
-  let isDisposed = false
-
-  const flush = () => {
-    if (pendingUpdaters.length === 0) return
-
-    // Capture and clear the queue atomically
-    const updaters = pendingUpdaters.splice(0, pendingUpdaters.length)
-
-    // Compose all pending updaters into a single transform
-    const composedUpdater = (msg: ChatMessage): ChatMessage => {
-      return updaters.reduce((m, fn) => fn(m), msg)
-    }
-
-    // Apply composed update to the target message
-    setMessages((prev) =>
-      prev.map((msg) => (msg.id === aiMessageId ? composedUpdater(msg) : msg)),
-    )
-  }
-
-  const dispose = () => {
-    if (isDisposed) return
-    // Flush any pending updates before disposing to prevent data loss
-    flush()
-    isDisposed = true
-    if (intervalId !== null) {
-      clearInterval(intervalId)
-      intervalId = null
-    }
-  }
-
-  // Start the periodic flush interval
-  intervalId = setInterval(flush, flushIntervalMs)
-
-  const updateAiMessage = (updater: (msg: ChatMessage) => ChatMessage) => {
-    if (isDisposed) {
-      // If disposed, apply immediately as fallback
-      setMessages((prev) =>
-        prev.map((msg) => (msg.id === aiMessageId ? updater(msg) : msg)),
-      )
-      return
-    }
-    pendingUpdaters.push(updater)
-  }
-
-  const updateAiMessageBlocks = (
-    blockUpdater: (blocks: ContentBlock[]) => ContentBlock[],
-  ) => {
-    updateAiMessage((msg) => ({
-      ...msg,
-      blocks: blockUpdater(msg.blocks ?? []),
-    }))
-  }
-
-  const addBlock = (block: ContentBlock) => {
-    updateAiMessage((msg) => ({
-      ...msg,
-      blocks: [...(msg.blocks ?? []), block],
-    }))
-  }
-
-  const markComplete = (metadata?: Partial<ChatMessage>) => {
-    // Flush any pending updates first
-    flush()
-    // Stop the interval
-    dispose()
-
-    // Apply completion immediately
-    setMessages((prev) =>
-      prev.map((msg) => {
-        if (msg.id !== aiMessageId) return msg
-        const { metadata: messageMetadata, ...rest } = metadata ?? {}
-        
-        // Mark native reasoning blocks as complete by setting thinkingOpen = false
-        // This ensures thinking blocks auto-collapse when the message finishes
-        // Check for thinkingOpen !== false to handle both true (native) and undefined (legacy)
-        const updatedBlocks = msg.blocks?.map((block) => {
-          if (
-            block.type === 'text' &&
-            (block as TextContentBlock).textType === 'reasoning' &&
-            (block as TextContentBlock).thinkingOpen !== false
-          ) {
-            return { ...block, thinkingOpen: false } as ContentBlock
-          }
-          return block
-        })
-        
-        const nextMessage: ChatMessage = {
-          ...msg,
-          isComplete: true,
-          ...(updatedBlocks && { blocks: updatedBlocks }),
-          ...rest,
-        }
-        if (messageMetadata) {
-          nextMessage.metadata = {
-            ...(msg.metadata ?? {}),
-            ...messageMetadata,
-          }
-        }
-        return nextMessage
-      }),
-    )
-  }
-
-  const setError = (message: string) => {
-    // Flush any pending updates first so we don't lose streamed content
-    flush()
-    // Stop the interval
-    dispose()
-
-    // Apply error immediately while preserving existing content and blocks
-    setMessages((prev) =>
-      prev.map((msg) => {
-        if (msg.id !== aiMessageId) return msg
-        return {
-          ...msg,
-          userError: message,
-          isComplete: true,
-        }
-      }),
-    )
-  }
-
-  /**
-   * Clears the userError field from the message immediately (bypasses batch queue).
-   * Call this when starting a new successful interaction to dismiss any previous error banners.
-   */
-  const clearUserError = () => {
-    // Apply immediately (bypass batch queue) so error banners are dismissed instantly
-    setMessages((prev) =>
-      prev.map((msg) => {
-        if (msg.id !== aiMessageId || !msg.userError) return msg
-        const { userError: _, ...rest } = msg
-        return rest as ChatMessage
-      }),
-    )
-  }
-
-  return {
-    updateAiMessage,
-    updateAiMessageBlocks,
-    markComplete,
-    setError,
-    clearUserError,
-    addBlock,
-    flush,
-    dispose,
-  }
-}

package/src/utils/open-file.ts

@@ -1,146 +0,0 @@
-import { spawn } from 'child_process'
-import os from 'os'
-
-import { getCliEnv } from './env'
-import { logger } from './logger'
-
-import type { CliEnv } from '../types/env'
-
-const isWindows = os.platform() === 'win32'
-const isMac = os.platform() === 'darwin'
-
-const escapeForShell = (value: string): string =>
-  `'${value.replace(/'/g, `'\\''`)}'`
-
-const escapeForCmd = (value: string): string =>
-  `"${value.replace(/"/g, '""')}"`
-
-const replaceFilePlaceholder = (command: string, filePath: string): string => {
-  if (command.includes('%f')) {
-    return command.replace(/%f/g, filePath)
-  }
-  if (command.includes('{file}')) {
-    return command.replace(/{file}/g, filePath)
-  }
-  return command
-}
-
-const buildEditorCommands = (
-  filePath: string,
-  env: CliEnv = getCliEnv(),
-): string[] => {
-  const commands: string[] = []
-  const shellPath = isWindows ? escapeForCmd(filePath) : escapeForShell(filePath)
-  const rawPath = filePath
-
-  // Check custom editor env vars
-  const editorValues = [
-    env.ANVIL_CLI_EDITOR,
-    env.ANVIL_EDITOR,
-    env.VISUAL,
-    env.EDITOR,
-  ]
-
-  for (const value of editorValues) {
-    if (!value) continue
-    const withFile = replaceFilePlaceholder(value, rawPath)
-    if (withFile !== value) {
-      commands.push(withFile)
-    } else {
-      commands.push(`${value} ${isWindows ? shellPath : shellPath}`)
-    }
-  }
-
-  const termProgram = (env.TERM_PROGRAM || '').toLowerCase()
-  const candidates: Array<{ detect: boolean; command: string }> = [
-    {
-      detect:
-        termProgram.includes('vscode') ||
-        env.VSCODE_GIT_IPC_HANDLE !== undefined ||
-        env.VSCODE_PID !== undefined,
-      command: `code --goto ${shellPath}`,
-    },
-    {
-      detect:
-        termProgram.includes('cursor') ||
-        env.CURSOR_PORT !== undefined ||
-        env.CURSOR !== undefined,
-      command: `cursor --goto ${shellPath}`,
-    },
-    {
-      detect:
-        termProgram.includes('zed') ||
-        env.ZED_NODE_ENV !== undefined,
-      command: `zed --add ${shellPath}`,
-    },
-    {
-      detect: termProgram.includes('sublime'),
-      command: `subl ${shellPath}`,
-    },
-    {
-      detect: termProgram.includes('atom'),
-      command: `atom ${shellPath}`,
-    },
-  ]
-
-  for (const candidate of candidates) {
-    if (candidate.detect) {
-      commands.push(candidate.command)
-    }
-  }
-
-  if (isMac) {
-    commands.push(`open ${shellPath}`)
-  } else if (isWindows) {
-    commands.push(`start "" ${escapeForCmd(filePath)}`)
-  } else {
-    commands.push(`xdg-open ${shellPath}`)
-  }
-
-  return [...new Set(commands)]
-}
-
-const runCommand = async (command: string): Promise<boolean> => {
-  return new Promise((resolve) => {
-    const child = spawn(command, {
-      shell: true,
-      stdio: 'ignore',
-      detached: true,
-    })
-
-    child.on('error', () => {
-      resolve(false)
-    })
-
-    child.on('close', (code) => {
-      resolve(code === 0)
-    })
-
-    try {
-      child.unref()
-    } catch {
-      // noop
-    }
-  })
-}
-
-export const openFileAtPath = async (
-  filePath: string,
-  env: CliEnv = getCliEnv(),
-): Promise<boolean> => {
-  const commands = buildEditorCommands(filePath, env)
-
-  for (const command of commands) {
-    // eslint-disable-next-line no-await-in-loop
-    const success = await runCommand(command)
-    if (success) {
-      return true
-    }
-  }
-
-  logger.warn(
-    { filePath, commands },
-    'Failed to open file with any configured editor command',
-  )
-  return false
-}

package/src/utils/open-url.ts

@@ -1,63 +0,0 @@
-import fs from 'fs'
-import os from 'os'
-
-import open from 'open'
-import { isWsl, powerShellPathFromWsl } from 'wsl-utils'
-
-import { getCliEnv } from './env'
-import { logger } from './logger'
-
-/**
- * Safely open a URL in the user's default browser.
- *
- * On headless Linux (no DISPLAY or WAYLAND_DISPLAY), calling `open()` spawns
- * `xdg-open` which can crash the entire process — even inside a try/catch —
- * because the child process may trigger fatal signals. This wrapper detects
- * headless environments and skips the call entirely. WSL is exempt: there
- * `open()` goes through powershell.exe, which needs no display.
- *
- * On WSL, `open()` spawns powershell.exe from the Windows mount. If Windows
- * interop is disabled (no access to /mnt/c), that spawn fails with ENOENT.
- * Under Bun the failure is delivered before the `open()` promise resolves and
- * cannot be caught from here — not by try/catch, and not by an 'error'
- * listener attached afterward — so the only reliable defense is checking that
- * powershell.exe exists before calling `open()`. `wsl-utils` is what `open`
- * itself uses to build the path, so the check matches its behavior exactly.
- *
- * @returns `true` if the browser was (likely) opened, `false` if skipped.
- */
-export async function safeOpen(url: string): Promise<boolean> {
-  if (isWsl) {
-    const powershellPath = await powerShellPathFromWsl()
-    if (!fs.existsSync(powershellPath)) {
-      logger.warn(
-        { powershellPath },
-        'WSL detected but powershell.exe is not accessible (Windows interop disabled?). Skipping browser open.',
-      )
-      return false
-    }
-  } else if (os.platform() === 'linux') {
-    const env = getCliEnv()
-    const hasDisplay = Boolean(env.DISPLAY || env.WAYLAND_DISPLAY)
-    if (!hasDisplay) {
-      logger.warn(
-        'No display server detected (DISPLAY / WAYLAND_DISPLAY unset). Skipping browser open.',
-      )
-      return false
-    }
-  }
-
-  try {
-    const subprocess = await open(url)
-    // With the default `wait: false`, spawn failures can surface on the
-    // child's 'error' event after the promise resolves; without a listener
-    // they become uncaught exceptions that kill the process.
-    subprocess.once('error', (err) => {
-      logger.error(err, 'Failed to open browser')
-    })
-    return true
-  } catch (err) {
-    logger.error(err, 'Failed to open browser')
-    return false
-  }
-}