@alumbwe/anvil 1.0.0

package/src/utils/block-processor.ts

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

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

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

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