@alumbwe/anvil 1.0.0

package/src/utils/status-indicator-state.ts

@@ -0,0 +1,107 @@
+import type { StreamStatus } from '../hooks/use-message-queue'
+
+export type StatusIndicatorState =
+  | { kind: 'idle' }
+  | { kind: 'clipboard'; message: string }
+  | { kind: 'ctrlC' }
+  | { kind: 'connecting' }
+  | { kind: 'retrying' }
+  | { kind: 'capacityWait' }
+  | { kind: 'waiting' }
+  | { kind: 'streaming' }
+  | { kind: 'reconnected' }
+  | { kind: 'paused' }
+
+export type AuthStatus = 'ok' | 'retrying' | 'unreachable'
+
+export type StatusIndicatorStateArgs = {
+  statusMessage?: string | null
+  streamStatus: StreamStatus
+  nextCtrlCWillExit: boolean
+  isConnected: boolean
+  authStatus?: AuthStatus
+  isRetrying?: boolean
+  /**
+   * Whether the current retry wait is a server capacity deferral (free-mode
+   * shed during peak demand). Only meaningful while isRetrying is true.
+   */
+  isCapacityWait?: boolean
+  /**
+   * Whether to show a transient "Reconnected" status message.
+   * This should only be true for a short period after a reconnection event.
+   */
+  showReconnectionMessage?: boolean
+  /**
+   * Whether the ask_user tool is currently active (waiting for user input).
+   * When true, hides the "working..." and "thinking..." indicators.
+   */
+  isAskUserActive?: boolean
+}
+
+/**
+ * Determines the status indicator state based on current context.
+ *
+ * State priority (highest to lowest):
+ * 1. nextCtrlCWillExit - User pressed Ctrl+C once, warn about exit
+ * 2. statusMessage - Temporary feedback for clipboard operations
+ * 3. connecting - Not connected to backend
+ * 4. waiting - Waiting for AI response to start
+ * 5. streaming - AI is actively responding
+ * 6. idle - No activity
+ *
+ * @param args - Context for determining indicator state
+ * @returns The appropriate state indicator
+ */
+export const getStatusIndicatorState = ({
+  statusMessage,
+  streamStatus,
+  nextCtrlCWillExit,
+  isConnected,
+  authStatus = 'ok',
+  isRetrying = false,
+  isCapacityWait = false,
+  showReconnectionMessage = false,
+  isAskUserActive = false,
+}: StatusIndicatorStateArgs): StatusIndicatorState => {
+  if (nextCtrlCWillExit) {
+    return { kind: 'ctrlC' }
+  }
+
+  if (statusMessage) {
+    return { kind: 'clipboard', message: statusMessage }
+  }
+
+  // Transient reconnection indicator takes precedence over other status
+  if (showReconnectionMessage) {
+    return { kind: 'reconnected' }
+  }
+
+  // If we're online but the auth request hit a retryable error and is auto-retrying,
+  // surface that explicitly to the user.
+  if (authStatus === 'retrying') {
+    return { kind: 'retrying' }
+  }
+  if (isRetrying) {
+    return isCapacityWait ? { kind: 'capacityWait' } : { kind: 'retrying' }
+  }
+
+  // Show connecting if service is disconnected OR auth service is unreachable
+  if (!isConnected || authStatus === 'unreachable') {
+    return { kind: 'connecting' }
+  }
+
+  // Show paused state when ask_user is active (timer stays visible but frozen)
+  if (isAskUserActive) {
+    return { kind: 'paused' }
+  }
+
+  if (streamStatus === 'waiting') {
+    return { kind: 'waiting' }
+  }
+
+  if (streamStatus === 'streaming') {
+    return { kind: 'streaming' }
+  }
+
+  return { kind: 'idle' }
+}

package/src/utils/stream-chunk-processor.ts

@@ -0,0 +1,57 @@
+import { appendTextToAgentBlock, appendTextToRootStream } from './block-operations'
+
+import type { StreamChunkEvent } from './sdk-event-handlers'
+import type { ContentBlock } from '../types/chat'
+
+export type ChunkDestination =
+  | { type: 'root'; textType: 'text' | 'reasoning' }
+  | { type: 'agent'; agentId: string; textType: 'text' | 'reasoning' }
+
+export const destinationFromTextEvent = (
+  event: { agentId?: string },
+): ChunkDestination => {
+  if (event.agentId) {
+    return { type: 'agent', agentId: event.agentId, textType: 'text' }
+  }
+  return { type: 'root', textType: 'text' }
+}
+
+export const destinationFromChunkEvent = (
+  event: StreamChunkEvent,
+): ChunkDestination | null => {
+  if (typeof event === 'string') {
+    return { type: 'root', textType: 'text' }
+  }
+
+  if (event.type === 'subagent_chunk') {
+    return { type: 'agent', agentId: event.agentId, textType: 'text' }
+  }
+
+  if (event.type === 'reasoning_chunk') {
+    if (event.ancestorRunIds.length === 0) {
+      return { type: 'root', textType: 'reasoning' }
+    }
+    return { type: 'agent', agentId: event.agentId, textType: 'reasoning' }
+  }
+
+  return null
+}
+
+export const processTextChunk = (
+  blocks: ContentBlock[],
+  destination: ChunkDestination,
+  text: string,
+): ContentBlock[] => {
+  if (!text) {
+    return blocks
+  }
+
+  if (destination.type === 'agent') {
+    return appendTextToAgentBlock(blocks, destination.agentId, text, destination.textType)
+  }
+
+  return appendTextToRootStream(blocks, {
+    type: destination.textType,
+    text,
+  })
+}

package/src/utils/strings.ts

@@ -0,0 +1,271 @@
+import path from 'path'
+
+/** Max number of lines to show in collapsed previews */
+export const MAX_COLLAPSED_LINES = 3
+
+/**
+ * Truncate text to a maximum number of lines, adding '...' if truncated.
+ * Returns the input unchanged if it's null/undefined/empty.
+ */
+export function truncateToLines(
+  text: string | null | undefined,
+  maxLines: number,
+): string | null | undefined {
+  if (!text) return text
+  const lines = text.split('\n')
+  if (lines.length <= maxLines) {
+    return text
+  }
+  return lines.slice(0, maxLines).join('\n').trimEnd() + '...'
+}
+
+import { statSync } from 'fs'
+
+import {
+  getFileOrFolderPathFromText,
+  getImageFilePathFromText,
+  hasClipboardImage,
+  readClipboardFilePath,
+  readClipboardImageFilePath,
+  readClipboardText,
+} from './clipboard-image'
+import { isImageFile } from './image-handler'
+
+import type { InputValue } from '../types/store'
+
+export function getSubsequenceIndices(
+  str: string,
+  sub: string,
+): number[] | null {
+  let strIndex = 0
+  let subIndex = 0
+
+  const indices: number[] = []
+
+  while (strIndex < str.length && subIndex < sub.length) {
+    if (str[strIndex] === sub[subIndex]) {
+      indices.push(strIndex)
+      subIndex++
+    }
+    strIndex++
+  }
+
+  if (subIndex >= sub.length) {
+    return indices
+  }
+
+  return null
+}
+
+export const BULLET_CHAR = '• '
+
+// Threshold for treating pasted text as an attachment instead of inline insertion
+// Text longer than this value (not equal) becomes an attachment
+export const LONG_TEXT_THRESHOLD = 2000
+
+/**
+ * Insert text at cursor position and return the new text and cursor position.
+ */
+function insertTextAtCursor(
+  text: string,
+  cursorPosition: number,
+  textToInsert: string,
+): { newText: string; newCursor: number } {
+  const before = text.slice(0, cursorPosition)
+  const after = text.slice(cursorPosition)
+  return {
+    newText: before + textToInsert + after,
+    newCursor: before.length + textToInsert.length,
+  }
+}
+
+/**
+ * Creates a paste handler for text-only inputs (feedback, ask-user, etc.).
+ * Reads from clipboard with OpenTUI fallback, then inserts at cursor.
+ */
+export function createTextPasteHandler(
+  text: string,
+  cursorPosition: number,
+  onChange: (value: InputValue) => void,
+): (eventText?: string) => void {
+  return (eventText) => {
+    const rawPaste = eventText || readClipboardText()
+    if (!rawPaste) return
+    const pasteText = Bun.stripANSI(rawPaste)
+    if (!pasteText) return
+    const { newText, newCursor } = insertTextAtCursor(
+      text,
+      cursorPosition,
+      pasteText,
+    )
+    onChange({
+      text: newText,
+      cursorPosition: newCursor,
+      lastEditDueToNav: false,
+    })
+  }
+}
+
+/**
+ * Creates a paste handler that supports both image and text paste.
+ *
+ * When eventText is provided (from drag-drop or native paste event),
+ * it takes priority over the clipboard. This is because:
+ * - Drag operations provide file paths directly without updating the clipboard
+ * - The clipboard might contain stale data from a previous copy operation
+ *
+ * Only when NO eventText is provided do we read from the clipboard.
+ */
+export function createPasteHandler(options: {
+  text: string
+  cursorPosition: number
+  onChange: (value: InputValue) => void
+  onPasteImage?: () => void
+  onPasteImagePath?: (imagePath: string) => void
+  onPasteFilePath?: (filePath: string, isDirectory: boolean) => void
+  onPasteLongText?: (text: string) => void
+  cwd?: string
+}): (eventText?: string) => void {
+  const {
+    text,
+    cursorPosition,
+    onChange,
+    onPasteImage,
+    onPasteImagePath,
+    onPasteFilePath,
+    onPasteLongText,
+    cwd,
+  } = options
+  return (eventText) => {
+    // Strip ANSI escape sequences from pasted text — terminal paste events
+    // (bracketed paste) may include ANSI sequences from the source content.
+    if (eventText) {
+      eventText = Bun.stripANSI(eventText)
+    }
+
+    // If we have direct input text from the paste event (e.g., from terminal paste),
+    // check if it looks like an image filename and if we can get the full path from clipboard
+    if (eventText && onPasteImagePath) {
+      // The terminal often only passes the filename when pasting a file copied from Finder.
+      // Check if this looks like just a filename (no path separators) that's an image.
+      const looksLikeImageFilename =
+        isImageFile(eventText) &&
+        !eventText.includes('/') &&
+        !eventText.includes('\\')
+
+      if (looksLikeImageFilename) {
+        // Try to get the full path from the clipboard's file URL
+        const clipboardFilePath = readClipboardImageFilePath()
+        // Verify the clipboard path's basename matches exactly (not just endsWith)
+        if (
+          clipboardFilePath &&
+          path.basename(clipboardFilePath) === eventText
+        ) {
+          // The clipboard has the full path to the same file - use it!
+          onPasteImagePath(clipboardFilePath)
+          return
+        }
+      }
+
+      // Check if eventText is a full path to an image file
+      if (cwd) {
+        const imagePath = getImageFilePathFromText(eventText, cwd)
+        if (imagePath) {
+          onPasteImagePath(imagePath)
+          return
+        }
+      }
+    }
+
+    // Check if eventText is a path to a file or folder (drag-and-drop)
+    if (eventText && onPasteFilePath && cwd) {
+      const fileInfo = getFileOrFolderPathFromText(eventText, cwd)
+      if (fileInfo) {
+        onPasteFilePath(fileInfo.path, fileInfo.isDirectory)
+        return
+      }
+    }
+
+    // eventText provided but not an image - check if it's long text
+    if (eventText) {
+      // If text is long, treat it as an attachment
+      if (onPasteLongText && eventText.length > LONG_TEXT_THRESHOLD) {
+        onPasteLongText(eventText)
+        return
+      }
+
+      // Otherwise paste it as regular text
+      const { newText, newCursor } = insertTextAtCursor(
+        text,
+        cursorPosition,
+        eventText,
+      )
+      onChange({
+        text: newText,
+        cursorPosition: newCursor,
+        lastEditDueToNav: false,
+      })
+      return
+    }
+
+    // No direct text provided - read from clipboard
+
+    // First, check if clipboard contains a copied file (e.g., from Finder)
+    if (onPasteImagePath || onPasteFilePath) {
+      const copiedFilePath = readClipboardFilePath()
+      if (copiedFilePath) {
+        if (isImageFile(copiedFilePath) && onPasteImagePath) {
+          onPasteImagePath(copiedFilePath)
+          return
+        }
+        if (!isImageFile(copiedFilePath) && onPasteFilePath) {
+          try {
+            const stats = statSync(copiedFilePath)
+            onPasteFilePath(copiedFilePath, stats.isDirectory())
+            return
+          } catch {
+            // Fall through to other paste handlers
+          }
+        }
+      }
+    }
+
+    const rawClipboardText = readClipboardText()
+    const clipboardText = rawClipboardText ? Bun.stripANSI(rawClipboardText) : null
+
+    // Check if clipboard text is a path to an image file
+    if (clipboardText && onPasteImagePath && cwd) {
+      const imagePath = getImageFilePathFromText(clipboardText, cwd)
+      if (imagePath) {
+        onPasteImagePath(imagePath)
+        return
+      }
+    }
+
+    // Check for actual image data (screenshots, copied images)
+    if (onPasteImage && hasClipboardImage()) {
+      onPasteImage()
+      return
+    }
+
+    // Regular text paste
+    if (!clipboardText) return
+
+    // If text is long, treat it as an attachment
+    if (onPasteLongText && clipboardText.length > LONG_TEXT_THRESHOLD) {
+      onPasteLongText(clipboardText)
+      return
+    }
+
+    const { newText, newCursor } = insertTextAtCursor(
+      text,
+      cursorPosition,
+      clipboardText,
+    )
+    onChange({
+      text: newText,
+      cursorPosition: newCursor,
+      lastEditDueToNav: false,
+    })
+  }
+}

package/src/utils/subscription.ts

@@ -0,0 +1,31 @@
+import type { SubscriptionResponse } from '../hooks/use-subscription-query'
+
+/**
+ * Calculates the percentage of subscription block credits remaining.
+ * Returns null if the subscription data is incomplete.
+ */
+export function getBlockPercentRemaining(
+  subscriptionData: SubscriptionResponse | null | undefined,
+): number | null {
+  if (!subscriptionData?.hasSubscription) return null
+  const rateLimit = subscriptionData.rateLimit
+  if (!rateLimit?.blockLimit || rateLimit.blockUsed == null) return null
+  return Math.round(
+    ((rateLimit.blockLimit - rateLimit.blockUsed) / rateLimit.blockLimit) * 100,
+  )
+}
+
+/**
+ * Determines if a request is covered by subscription based on subscription data.
+ * Returns true if the user has an active subscription that's not rate-limited
+ * and has remaining block credits.
+ */
+export function isCoveredBySubscription(
+  subscriptionData: SubscriptionResponse | null | undefined,
+): boolean {
+  if (!subscriptionData?.hasSubscription) return false
+  const rateLimit = subscriptionData.rateLimit
+  if (rateLimit?.limited) return false
+  const blockPercentRemaining = getBlockPercentRemaining(subscriptionData)
+  return blockPercentRemaining != null && blockPercentRemaining > 0
+}

package/src/utils/syntax-highlighter.tsx

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react'
+
+interface HighlightOptions {
+  fg?: string
+  monochrome?: boolean
+}
+
+// Basic syntax highlighting for common languages
+export function highlightCode(
+  code: string,
+  lang: string,
+  options: HighlightOptions = {},
+): ReactNode {
+  const { fg = '#d1d5db' } = options
+
+  // For now, just return the code with basic styling
+  // Can be enhanced later with actual syntax highlighting
+  return <span fg={fg}>{code}</span>
+}