@alumbwe/anvil 1.0.0 → 1.0.2

package/src/utils/block-processor.ts

@@ -1,213 +0,0 @@
-
-import { shouldCollapseByDefault } from './constants'
-import {
-  isImplementorAgent,
-  groupConsecutiveImplementors,
-  groupConsecutiveNonImplementorAgents,
-  groupConsecutiveToolBlocks,
-} from './implementor-helpers'
-import { isImageBlock } from '../types/chat'
-
-import type {
-  ContentBlock,
-  AgentContentBlock,
-  ToolContentBlock,
-  TextContentBlock,
-  ImageContentBlock,
-} from '../types/chat'
-import type { ReactNode } from 'react'
-
-/**
- * Type guard for reasoning text blocks (thinking blocks)
- */
-export function isReasoningTextBlock(
-  block: ContentBlock,
-): block is Extract<ContentBlock, { type: 'text' }> {
-  return block.type === 'text' && block.textType === 'reasoning'
-}
-
-/**
- * Handler callbacks for processing different block types.
- * Each handler receives the block(s) and relevant indices, and returns a ReactNode.
- */
-export interface BlockProcessorHandlers {
-  /** Handle a group of consecutive reasoning text blocks */
-  onReasoningGroup: (
-    blocks: TextContentBlock[],
-    startIndex: number,
-  ) => ReactNode
-
-  /** Handle an image block (optional - if not provided, images are skipped) */
-  onImageBlock?: (block: ImageContentBlock, index: number) => ReactNode
-
-  /** Handle a group of consecutive tool blocks */
-  onToolGroup: (
-    blocks: ToolContentBlock[],
-    startIndex: number,
-    nextIndex: number,
-  ) => ReactNode
-
-  /** Handle a group of consecutive implementor agent blocks */
-  onImplementorGroup: (
-    blocks: AgentContentBlock[],
-    startIndex: number,
-    nextIndex: number,
-  ) => ReactNode
-
-  /** Handle a group of consecutive non-implementor agent blocks */
-  onAgentGroup: (
-    blocks: AgentContentBlock[],
-    startIndex: number,
-    nextIndex: number,
-  ) => ReactNode
-
-  /** Handle a single block that doesn't fit into any group category */
-  onSingleBlock: (block: ContentBlock, index: number) => ReactNode
-}
-
-/**
- * Split an array of items into sub-groups based on agent size.
- * Consecutive "small" agents (collapsed by default) are grouped together
- * so they can share a grid row. Each "large" agent gets its own sub-group
- * so it renders at full width.
- */
-export function splitByAgentSize<T>(
-  items: T[],
-  getAgentType: (item: T) => string,
-): T[][] {
-  if (items.length <= 1) return [items]
-
-  const subGroups: T[][] = []
-  let currentSmallGroup: T[] = []
-
-  for (const item of items) {
-    if (shouldCollapseByDefault(getAgentType(item))) {
-      currentSmallGroup.push(item)
-    } else {
-      if (currentSmallGroup.length > 0) {
-        subGroups.push(currentSmallGroup)
-        currentSmallGroup = []
-      }
-      subGroups.push([item])
-    }
-  }
-
-  if (currentSmallGroup.length > 0) {
-    subGroups.push(currentSmallGroup)
-  }
-
-  return subGroups
-}
-
-/** Convenience wrapper for splitting AgentContentBlock arrays by size. */
-export function splitAgentsBySize(
-  agents: AgentContentBlock[],
-): AgentContentBlock[][] {
-  return splitByAgentSize(agents, (a) => a.agentType)
-}
-
-/**
- * Process a list of content blocks, grouping consecutive blocks of the same type
- * and calling the appropriate handler for each group or single block.
- *
- * This utility abstracts the common iteration pattern used by BlocksRenderer and AgentBody.
- *
- * @param blocks - The array of content blocks to process
- * @param handlers - Callback handlers for each block type
- * @returns An array of ReactNode elements
- */
-export function processBlocks(
-  blocks: ContentBlock[],
-  handlers: BlockProcessorHandlers,
-): ReactNode[] {
-  const nodes: ReactNode[] = []
-
-  for (let i = 0; i < blocks.length; ) {
-    const block = blocks[i]
-
-    // Handle reasoning text blocks (thinking)
-    if (isReasoningTextBlock(block)) {
-      const start = i
-      const reasoningBlocks: TextContentBlock[] = []
-      while (i < blocks.length) {
-        const currentBlock = blocks[i]
-        if (!isReasoningTextBlock(currentBlock)) break
-        reasoningBlocks.push(currentBlock)
-        i++
-      }
-
-      const node = handlers.onReasoningGroup(reasoningBlocks, start)
-      if (node !== null) {
-        nodes.push(node)
-      }
-      continue
-    }
-
-    // Handle image blocks
-    if (isImageBlock(block)) {
-      if (handlers.onImageBlock) {
-        const node = handlers.onImageBlock(block, i)
-        if (node !== null) {
-          nodes.push(node)
-        }
-      }
-      i++
-      continue
-    }
-
-    // Handle tool blocks
-    if (block.type === 'tool') {
-      const start = i
-      const { group: toolBlocks, nextIndex } = groupConsecutiveToolBlocks(
-        blocks,
-        i,
-      )
-      i = nextIndex
-
-      const node = handlers.onToolGroup(toolBlocks, start, nextIndex)
-      if (node !== null) {
-        nodes.push(node)
-      }
-      continue
-    }
-
-    // Handle agent blocks
-    if (block.type === 'agent') {
-      if (isImplementorAgent(block)) {
-        // Implementor agents
-        const start = i
-        const { group: implementors, nextIndex } = groupConsecutiveImplementors(
-          blocks,
-          i,
-        )
-        i = nextIndex
-
-        const node = handlers.onImplementorGroup(implementors, start, nextIndex)
-        if (node !== null) {
-          nodes.push(node)
-        }
-      } else {
-        // Non-implementor agents
-        const start = i
-        const { group: agentBlocks, nextIndex } =
-          groupConsecutiveNonImplementorAgents(blocks, i)
-        i = nextIndex
-
-        const node = handlers.onAgentGroup(agentBlocks, start, nextIndex)
-        if (node !== null) {
-          nodes.push(node)
-        }
-      }
-      continue
-    }
-
-    // Handle all other block types (text, html, etc.)
-    const node = handlers.onSingleBlock(block, i)
-    if (node !== null) {
-      nodes.push(node)
-    }
-    i++
-  }
-
-  return nodes
-}

package/src/utils/chat-history.ts

@@ -1,253 +0,0 @@
-import * as fs from 'fs'
-import path from 'path'
-
-import {
-  CHAT_MESSAGES_FILENAME,
-  getFirstUserPrompt,
-  readChatMeta,
-} from './chat-meta'
-import { CHAT_LOG_FILENAME, logger } from './logger'
-import { getProjectDataDir } from '../project-files'
-
-import type { ChatMessage } from '../types/chat'
-
-export interface ChatHistoryEntry {
-  chatId: string
-  lastPrompt: string
-  timestamp: Date
-  messageCount: number
-  /** True when chat-messages.json exists but can't be parsed (e.g. truncated
-   * by a crash mid-write). Shown in /history so the chat doesn't silently
-   * vanish; can be deleted but not resumed. */
-  unreadable?: boolean
-}
-
-function getChatsDir(dataDir: string = getProjectDataDir()): string {
-  return path.join(dataDir, 'chats')
-}
-
-interface ChatDirInfo {
-  chatId: string
-  chatPath: string
-  messagesPath: string
-  mtime: Date
-}
-
-/**
- * List all available chats sorted by most recent first
- * @param maxChats - Maximum number of chats to load (default: 500)
- */
-export function getAllChats(
-  maxChats: number = 500,
-  dataDir?: string,
-): ChatHistoryEntry[] {
-  try {
-    const chatsDir = getChatsDir(dataDir)
-
-    if (!fs.existsSync(chatsDir)) {
-      return []
-    }
-
-    const chatDirs = fs.readdirSync(chatsDir)
-
-    // First pass: get mtime for all chat directories (fast, no file reading)
-    const chatDirInfos: ChatDirInfo[] = []
-    for (const chatId of chatDirs) {
-      const chatPath = path.join(chatsDir, chatId)
-      try {
-        const stat = fs.statSync(chatPath)
-        if (!stat.isDirectory()) continue
-
-        chatDirInfos.push({
-          chatId,
-          chatPath,
-          messagesPath: path.join(chatPath, CHAT_MESSAGES_FILENAME),
-          mtime: stat.mtime,
-        })
-      } catch {
-        // Skip directories we can't stat
-      }
-    }
-
-    // Sort by mtime first (most recent first)
-    chatDirInfos.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
-
-    // Second pass: only read message content for the top N chats
-    const chats: ChatHistoryEntry[] = []
-    const chatsToLoad = chatDirInfos.slice(0, maxChats)
-
-    for (const info of chatsToLoad) {
-      try {
-        let messageCount = 0
-        let lastPrompt = '(empty chat)'
-
-        if (fs.existsSync(info.messagesPath)) {
-          // Prefer the sidecar summary: transcripts are unbounded, so parsing
-          // every full chat-messages.json here can make /history slow.
-          const meta = readChatMeta(info.chatPath)
-          if (meta) {
-            messageCount = meta.messageCount
-            lastPrompt = meta.firstPrompt
-          } else {
-            // Pre-sidecar chats, or a sidecar that no longer matches the
-            // messages file (rewritten by an older CLI, crash between the
-            // two writes): parse the full file.
-            const content = fs.readFileSync(info.messagesPath, 'utf8')
-            const messages = JSON.parse(content) as ChatMessage[]
-            if (!Array.isArray(messages)) {
-              throw new Error('chat-messages.json is not an array')
-            }
-            messageCount = messages.length
-            lastPrompt = getFirstUserPrompt(messages)
-          }
-        }
-
-        // Skip empty chats (no messages)
-        if (messageCount > 0) {
-          chats.push({
-            chatId: info.chatId,
-            lastPrompt,
-            timestamp: info.mtime,
-            messageCount,
-          })
-        }
-      } catch (error) {
-        logger.debug(
-          {
-            chatId: info.chatId,
-            error: error instanceof Error ? error.message : String(error),
-          },
-          'Failed to read chat messages',
-        )
-        // Don't silently hide the chat: list it as unreadable so the user
-        // knows it exists (and can delete it) instead of thinking it was lost
-        chats.push({
-          chatId: info.chatId,
-          lastPrompt: '(unreadable chat)',
-          timestamp: info.mtime,
-          messageCount: 0,
-          unreadable: true,
-        })
-      }
-    }
-
-    return chats
-  } catch (error) {
-    logger.error(
-      { error: error instanceof Error ? error.message : String(error) },
-      'Failed to list chats',
-    )
-    return []
-  }
-}
-
-// Older CLI versions logged the full conversation (including attachments) to
-// log.jsonl on every step, leaving multi-GB files in chat directories. Delete
-// any log file over this cap; with summary-only logging, healthy logs stay
-// far below it.
-const MAX_LOG_FILE_BYTES = 10 * 1024 * 1024
-// Only delete logs from chats untouched for this long, so debug logs for
-// recent chats stay available.
-const MIN_LOG_AGE_MS = 14 * 24 * 60 * 60 * 1000
-
-/**
- * Delete oversized log.jsonl files from chat directories that haven't been
- * touched in 14+ days. Only debug logs are removed — chat history files are
- * untouched.
- */
-export function trimOversizedChatLogs(dataDir?: string): void {
-  let chatsDir: string
-  let chatIds: string[]
-  try {
-    chatsDir = getChatsDir(dataDir)
-    chatIds = fs.readdirSync(chatsDir)
-  } catch {
-    return // No project root set or no chats directory yet
-  }
-
-  const deleteBefore = Date.now() - MIN_LOG_AGE_MS
-  for (const chatId of chatIds) {
-    const logFile = path.join(chatsDir, chatId, CHAT_LOG_FILENAME)
-    try {
-      const stats = fs.statSync(logFile, { throwIfNoEntry: false })
-      if (
-        stats &&
-        stats.size > MAX_LOG_FILE_BYTES &&
-        stats.mtimeMs < deleteBefore
-      ) {
-        fs.unlinkSync(logFile)
-      }
-    } catch {
-      // Ignore errors for individual files
-    }
-  }
-}
-
-/**
- * Delete a saved chat session from local history.
- */
-export function deleteChatSession(chatId: string, dataDir?: string): boolean {
-  try {
-    const safeChatId = chatId.trim()
-    if (
-      !safeChatId ||
-      safeChatId === '.' ||
-      safeChatId === '..' ||
-      path.basename(safeChatId) !== safeChatId
-    ) {
-      logger.warn({ chatId }, 'Refusing to delete invalid chat id')
-      return false
-    }
-
-    const chatsDir = getChatsDir(dataDir)
-    const chatPath = path.join(chatsDir, safeChatId)
-
-    if (!fs.existsSync(chatPath)) {
-      return false
-    }
-
-    const stat = fs.statSync(chatPath)
-    if (!stat.isDirectory()) {
-      logger.warn(
-        { chatId, chatPath },
-        'Refusing to delete non-directory chat path',
-      )
-      return false
-    }
-
-    fs.rmSync(chatPath, { recursive: true, force: false })
-    return true
-  } catch (error) {
-    logger.error(
-      { chatId, error: error instanceof Error ? error.message : String(error) },
-      'Failed to delete chat session',
-    )
-    return false
-  }
-}
-
-/**
- * Format a timestamp relative to now (e.g., "2 hours ago", "yesterday")
- */
-export function formatRelativeTime(date: Date): string {
-  const now = new Date()
-  const diffMs = now.getTime() - date.getTime()
-  const diffSecs = Math.floor(diffMs / 1000)
-  const diffMins = Math.floor(diffSecs / 60)
-  const diffHours = Math.floor(diffMins / 60)
-  const diffDays = Math.floor(diffHours / 24)
-
-  if (diffSecs < 60) {
-    return 'just now'
-  } else if (diffMins < 60) {
-    return `${diffMins}m ago`
-  } else if (diffHours < 24) {
-    return `${diffHours}h ago`
-  } else if (diffDays === 1) {
-    return 'yesterday'
-  } else if (diffDays < 7) {
-    return `${diffDays}d ago`
-  } else {
-    return date.toLocaleDateString()
-  }
-}

package/src/utils/chat-input-key-intercept.ts

@@ -1,52 +0,0 @@
-import { isPlainEnterKey } from './terminal-enter-detection'
-
-type ChatInputKey = {
-  name?: string
-  sequence?: string
-  shift?: boolean
-  ctrl?: boolean
-  meta?: boolean
-  option?: boolean
-}
-
-type ChatInputKeyInterceptState = {
-  hasSlashSuggestions: boolean
-  hasMentionSuggestions: boolean
-  lastEditDueToNav: boolean
-  cursorPosition: number
-  inputLength: number
-}
-
-export function shouldInterceptChatInputKey(
-  key: ChatInputKey,
-  state: ChatInputKeyInterceptState,
-): boolean {
-  const isPlainEnter = isPlainEnterKey(key)
-  const isTab = key.name === 'tab' && !key.ctrl && !key.meta && !key.option
-  const isUp = key.name === 'up' && !key.ctrl && !key.meta && !key.option
-  const isDown = key.name === 'down' && !key.ctrl && !key.meta && !key.option
-  const isUpDown = isUp || isDown
-
-  const hasSuggestions =
-    state.hasSlashSuggestions || state.hasMentionSuggestions
-  if (hasSuggestions) {
-    if (isUpDown && state.lastEditDueToNav) {
-      return true
-    }
-    if (isPlainEnter || isTab || isUpDown) {
-      return true
-    }
-  }
-
-  const historyUpEnabled = state.lastEditDueToNav || state.cursorPosition === 0
-  const historyDownEnabled =
-    state.lastEditDueToNav || state.cursorPosition === state.inputLength
-  if (isUp && historyUpEnabled) {
-    return true
-  }
-  if (isDown && historyDownEnabled) {
-    return true
-  }
-
-  return false
-}

package/src/utils/chat-meta.ts

@@ -1,90 +0,0 @@
-import * as fs from 'fs'
-import path from 'path'
-
-import { z } from 'zod'
-
-import { writeFileAtomic } from './write-file-atomic'
-
-import type { ChatMessage } from '../types/chat'
-
-export const CHAT_MESSAGES_FILENAME = 'chat-messages.json'
-export const CHAT_META_FILENAME = 'chat-meta.json'
-
-/**
- * Small sidecar summary of a chat written alongside chat-messages.json.
- * Transcripts are unbounded and can grow to many MB, so /history reads this
- * instead of parsing every full chat-messages.json.
- *
- * messagesSize/messagesMtimeMs bind the sidecar to the exact messages file it
- * summarizes: if the transcript is later rewritten by anything that doesn't
- * refresh the sidecar (an older CLI version, a crash between the two writes),
- * readChatMeta rejects the stale sidecar and callers fall back to the full
- * parse instead of showing outdated data or hiding corruption.
- */
-const chatMetaSchema = z.object({
-  messageCount: z.number(),
-  firstPrompt: z.string(),
-  messagesSize: z.number(),
-  messagesMtimeMs: z.number(),
-})
-
-export type ChatMeta = z.infer<typeof chatMetaSchema>
-
-/**
- * Get the first user message from a list of chat messages
- */
-export function getFirstUserPrompt(messages: ChatMessage[]): string {
-  for (const msg of messages) {
-    if (msg?.variant === 'user' && msg.content) {
-      // Truncate long prompts
-      const content = msg.content.trim()
-      if (content.length > 100) {
-        return content.slice(0, 97) + '...'
-      }
-      return content
-    }
-  }
-  return '(empty chat)'
-}
-
-/**
- * Write the sidecar for the given chat directory. The chat-messages.json in
- * that directory must already contain exactly `messages` (its stats are
- * recorded to bind the sidecar to it).
- */
-export function writeChatMeta(chatDir: string, messages: ChatMessage[]): void {
-  const stats = fs.statSync(path.join(chatDir, CHAT_MESSAGES_FILENAME))
-  const meta: ChatMeta = {
-    messageCount: messages.length,
-    firstPrompt: getFirstUserPrompt(messages),
-    messagesSize: stats.size,
-    messagesMtimeMs: stats.mtimeMs,
-  }
-  writeFileAtomic(path.join(chatDir, CHAT_META_FILENAME), JSON.stringify(meta))
-}
-
-/**
- * Read the sidecar for a chat directory. Returns null when it is missing,
- * unparsable, or stale (chat-messages.json no longer matches the recorded
- * size/mtime) — callers should fall back to parsing chat-messages.json.
- */
-export function readChatMeta(chatDir: string): ChatMeta | null {
-  try {
-    const raw = fs.readFileSync(path.join(chatDir, CHAT_META_FILENAME), 'utf8')
-    const parsed = chatMetaSchema.safeParse(JSON.parse(raw))
-    if (!parsed.success) {
-      return null
-    }
-    const meta = parsed.data
-    const stats = fs.statSync(path.join(chatDir, CHAT_MESSAGES_FILENAME))
-    if (
-      stats.size !== meta.messagesSize ||
-      stats.mtimeMs !== meta.messagesMtimeMs
-    ) {
-      return null
-    }
-    return meta
-  } catch {
-    return null
-  }
-}