@alumbwe/anvil 1.0.0 → 1.0.2

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

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

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

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

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

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