@alumbwe/anvil 1.0.0

package/src/utils/message-history.ts

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,279 @@
+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

@@ -0,0 +1,146 @@
+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

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