@alumbwe/anvil 1.0.0 → 1.0.2

package/src/utils/implementor-helpers.ts

@@ -1,787 +0,0 @@
-import type {
-  AgentContentBlock,
-  ContentBlock,
-  ToolContentBlock,
-} from '../types/chat'
-
-export const IMPLEMENTOR_AGENT_IDS = [
-  'editor-implementor',
-  'editor-implementor-opus',
-  'editor-implementor-gemini',
-  'editor-implementor-gpt-5',
-] as const
-
-/** All edit tool names (both direct and proposed variants) */
-const ALL_EDIT_TOOL_NAMES = [
-  'str_replace',
-  'write_file',
-  'propose_str_replace',
-  'propose_write_file',
-] as const
-
-const isProposedToolName = (toolName: ToolContentBlock['toolName']): boolean =>
-  typeof toolName === 'string' && toolName.startsWith('propose_')
-
-const getBaseToolName = (toolName: ToolContentBlock['toolName']): string =>
-  isProposedToolName(toolName) ? toolName.slice('propose_'.length) : toolName
-
-const SUCCESSFUL_EDIT_MESSAGES = [
-  'String replace applied successfully',
-  'Created file successfully',
-  'Created new file',
-  'Overwrote file successfully',
-  'Wrote file successfully',
-  'Updated file',
-  'Proposed new file',
-  'Proposed changes',
-  'Proposed string replacement',
-] as const
-
-const hasProposedTools = (blocks?: ContentBlock[]): boolean => {
-  if (!blocks || blocks.length === 0) return false
-
-  return blocks.some(
-    (block) => block.type === 'tool' && isProposedToolName(block.toolName),
-  )
-}
-
-/**
- * Check if an agent is an implementor agent.
- * These agents are rendered differently (as simple status lines instead of full agent blocks).
- */
-export const isImplementorAgent = (
-  agentBlock: Pick<AgentContentBlock, 'agentType' | 'blocks'>,
-): boolean => {
-  if (hasProposedTools(agentBlock.blocks)) {
-    return true
-  }
-
-  return IMPLEMENTOR_AGENT_IDS.some((id) => agentBlock.agentType.includes(id))
-}
-
-/**
- * Get the display name for an implementor agent.
- */
-export const getImplementorDisplayName = (
-  agentType: string,
-  index?: number,
-): string => {
-  let baseName = 'Implementor'
-  if (agentType.includes('editor-implementor-opus')) {
-    baseName = 'Opus'
-  } else if (agentType.includes('editor-implementor-gemini')) {
-    baseName = 'Gemini'
-  } else if (agentType.includes('editor-implementor-gpt-5')) {
-    baseName = 'GPT-5'
-  } else if (agentType.includes('editor-implementor')) {
-    baseName = 'Sonnet'
-  }
-
-  if (index !== undefined) {
-    return `${baseName} #${index + 1}`
-  }
-  return baseName
-}
-
-/**
- * Get the index of an implementor agent among its siblings.
- * Returns the 0-based index among all implementor agents of the same type.
- */
-export const getImplementorIndex = (
-  currentAgent: AgentContentBlock,
-  siblingBlocks: ContentBlock[],
-): number | undefined => {
-  if (!isImplementorAgent(currentAgent)) return undefined
-
-  // Filter to only implementor agents of the same type
-  const implementorSiblings = siblingBlocks.filter(
-    (block): block is AgentContentBlock =>
-      block.type === 'agent' &&
-      isImplementorAgent(block) &&
-      block.agentType === currentAgent.agentType,
-  )
-
-  // If there's only one, don't show an index
-  if (implementorSiblings.length <= 1) {
-    return undefined
-  }
-
-  // Find the index of the current agent
-  return implementorSiblings.findIndex(
-    (block) => block.agentId === currentAgent.agentId,
-  )
-}
-
-/**
- * Group consecutive blocks from a blocks array that match the predicate.
- * Returns the group and the next index to process.
- */
-export function groupConsecutiveBlocks<T extends ContentBlock>(
-  blocks: ContentBlock[],
-  startIndex: number,
-  predicate: (block: ContentBlock) => block is T,
-): { group: T[]; nextIndex: number } {
-  const group: T[] = []
-  let i = startIndex
-
-  while (i < blocks.length) {
-    const block = blocks[i]
-    if (!predicate(block)) {
-      break
-    }
-    group.push(block)
-    i++
-  }
-
-  return { group, nextIndex: i }
-}
-
-/**
- * Group consecutive implementor agents from a blocks array.
- * Returns the group of implementors and the next index to process.
- */
-export function groupConsecutiveImplementors(
-  blocks: ContentBlock[],
-  startIndex: number,
-): { group: AgentContentBlock[]; nextIndex: number } {
-  return groupConsecutiveBlocks(
-    blocks,
-    startIndex,
-    (block): block is AgentContentBlock =>
-      block.type === 'agent' && isImplementorAgent(block),
-  )
-}
-
-export function groupConsecutiveNonImplementorAgents(
-  blocks: ContentBlock[],
-  startIndex: number,
-): { group: AgentContentBlock[]; nextIndex: number } {
-  return groupConsecutiveBlocks(
-    blocks,
-    startIndex,
-    (block): block is AgentContentBlock =>
-      block.type === 'agent' && !isImplementorAgent(block),
-  )
-}
-
-export function groupConsecutiveToolBlocks(
-  blocks: ContentBlock[],
-  startIndex: number,
-): { group: ToolContentBlock[]; nextIndex: number } {
-  return groupConsecutiveBlocks(
-    blocks,
-    startIndex,
-    (block): block is ToolContentBlock => block.type === 'tool',
-  )
-}
-
-/**
- * Extract a value for a key from tool output (key: value format).
- * Supports multi-line values with pipe delimiter.
- */
-export function extractValueForKey(output: string, key: string): string | null {
-  if (!output) return null
-  const lines = output.split('\n')
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const match = line.match(/^\s*([A-Za-z0-9_]+):\s*(.*)$/)
-    if (match && match[1] === key) {
-      const rest = match[2]
-      if (rest.trim().startsWith('|')) {
-        const baseIndent = lines[i + 1]?.match(/^\s*/)?.[0].length ?? 0
-        const acc: string[] = []
-        for (let j = i + 1; j < lines.length; j++) {
-          const l = lines[j]
-          const indent = l.match(/^\s*/)?.[0].length ?? 0
-          if (l.trim().length === 0) {
-            acc.push('')
-            continue
-          }
-          if (indent < baseIndent) break
-          acc.push(l.slice(baseIndent))
-        }
-        return acc.join('\n')
-      } else {
-        let val = rest.trim()
-        if (val.startsWith('"') && val.endsWith('"')) {
-          val = val.slice(1, -1)
-        }
-        return val
-      }
-    }
-  }
-  return null
-}
-
-/**
- * Extract file path from tool block.
- */
-export function extractFilePath(toolBlock: ToolContentBlock): string | null {
-  const outputStr = typeof toolBlock.output === 'string' ? toolBlock.output : ''
-  const input = toolBlock.input as Record<string, unknown>
-
-  return (
-    extractValueForKey(outputStr, 'file') ||
-    (typeof input?.path === 'string' ? input.path : null) ||
-    (typeof input?.file_path === 'string' ? input.file_path : null)
-  )
-}
-
-/**
- * Extract unified diff from tool output, or construct from input.
- * For executed tools: use outputRaw/output with unifiedDiff.
- * For proposed tools (implementors): construct diff from input replacements.
- */
-export function extractDiff(toolBlock: ToolContentBlock): string | null {
-  let hasSuccessfulOutput = false
-
-  // First try to get from outputRaw (for executed tool results)
-  // outputRaw is typically an array like [{type: "json", value: {unifiedDiff: "..."}}]
-  const outputRaw = toolBlock.outputRaw as unknown
-  if (Array.isArray(outputRaw) && outputRaw[0]?.value) {
-    const value = outputRaw[0].value as Record<string, unknown>
-    if (hasErrorMessage(value)) return null
-    if (isSuccessfulEditMessage(value.message)) hasSuccessfulOutput = true
-    if (value.unifiedDiff) return value.unifiedDiff as string
-    if (value.patch) return value.patch as string
-  }
-  // Also check direct properties (in case format differs)
-  if (typeof outputRaw === 'object' && outputRaw !== null) {
-    const rawObj = outputRaw as Record<string, unknown>
-    if (hasErrorMessage(rawObj)) return null
-    if (isSuccessfulEditMessage(rawObj.message)) hasSuccessfulOutput = true
-    if (rawObj.unifiedDiff) return rawObj.unifiedDiff as string
-    if (rawObj.patch) return rawObj.patch as string
-  }
-
-  // Try to get from output string (key: value format)
-  const outputStr = typeof toolBlock.output === 'string' ? toolBlock.output : ''
-  const message = extractValueForKey(outputStr, 'message')
-  const diffFromOutput =
-    extractValueForKey(outputStr, 'unifiedDiff') ||
-    extractValueForKey(outputStr, 'patch')
-
-  if (hasFailedEditOutput({ outputStr, message, diffFromOutput })) {
-    return null
-  }
-  if (isSuccessfulEditMessage(message)) {
-    hasSuccessfulOutput = true
-  }
-
-  if (diffFromOutput) {
-    return diffFromOutput
-  }
-
-  // For proposed/pending edits, or confirmed successful executions, construct
-  // the preview from input when the result omits a diff.
-  const canUseInputFallback =
-    isProposedToolName(toolBlock.toolName) ||
-    outputStr === '' ||
-    hasSuccessfulOutput
-  if (!canUseInputFallback) {
-    return null
-  }
-
-  const input = toolBlock.input as Record<string, unknown>
-  const baseToolName = getBaseToolName(toolBlock.toolName)
-
-  // Handle str_replace: construct diff from replacements
-  if (baseToolName === 'str_replace' && Array.isArray(input?.replacements)) {
-    const replacements = input.replacements as ReplacementInput[]
-    if (replacements.length > 0) {
-      return constructDiffFromReplacements(replacements)
-    }
-  }
-
-  // Handle write_file: show content as addition
-  if (baseToolName === 'write_file' && typeof input?.content === 'string') {
-    return constructDiffFromWriteFile(input.content)
-  }
-
-  // Fallback: get from input.content (for other tools)
-  if (input?.content !== undefined && typeof input.content === 'string') {
-    return input.content
-  }
-
-  return null
-}
-
-function hasErrorMessage(value: Record<string, unknown>): boolean {
-  return Boolean(value.errorMessage || (value.value as any)?.errorMessage)
-}
-
-function hasFailedEditOutput(params: {
-  outputStr: string
-  message: string | null
-  diffFromOutput: string | null
-}): boolean {
-  const { outputStr, message, diffFromOutput } = params
-  const trimmedOutput = outputStr.trim()
-  if (!trimmedOutput) {
-    return false
-  }
-  if (
-    extractValueForKey(outputStr, 'errorMessage') ||
-    isErrorOutput(outputStr)
-  ) {
-    return true
-  }
-  if (diffFromOutput || isSuccessfulEditMessage(message)) {
-    return false
-  }
-  return !isSuccessfulEditMessage(trimmedOutput)
-}
-
-function isFailedEditToolBlock(toolBlock: ToolContentBlock): boolean {
-  const outputRaw = toolBlock.outputRaw as unknown
-  if (Array.isArray(outputRaw) && outputRaw[0]?.value) {
-    const value = outputRaw[0].value as Record<string, unknown>
-    if (hasErrorMessage(value)) return true
-  }
-  if (typeof outputRaw === 'object' && outputRaw !== null) {
-    const rawObj = outputRaw as Record<string, unknown>
-    if (hasErrorMessage(rawObj)) return true
-  }
-
-  const outputStr = typeof toolBlock.output === 'string' ? toolBlock.output : ''
-  const message = extractValueForKey(outputStr, 'message')
-  const diffFromOutput =
-    extractValueForKey(outputStr, 'unifiedDiff') ||
-    extractValueForKey(outputStr, 'patch')
-  return hasFailedEditOutput({ outputStr, message, diffFromOutput })
-}
-
-function isSuccessfulEditMessage(message: unknown): boolean {
-  if (typeof message !== 'string') {
-    return false
-  }
-
-  return message
-    .split('\n')
-    .some((line) =>
-      SUCCESSFUL_EDIT_MESSAGES.some((successMessage) =>
-        line.trim().startsWith(successMessage),
-      ),
-    )
-}
-
-function isErrorOutput(output: string): boolean {
-  const trimmedOutput = output.trim()
-  return trimmedOutput.startsWith('Error:') || trimmedOutput.startsWith('Failed ')
-}
-
-/**
- * Construct a simple diff view from str_replace replacements.
- */
-type ReplacementInput = {
-  oldString?: string
-  newString?: string
-  old?: string
-  new?: string
-}
-
-function constructDiffFromReplacements(
-  replacements: ReplacementInput[],
-): string {
-  const lines: string[] = []
-
-  for (const replacement of replacements) {
-    const oldString = replacement.oldString ?? replacement.old ?? ''
-    const newString = replacement.newString ?? replacement.new ?? ''
-
-    // Add old lines as removals
-    const oldLines = oldString.split('\n')
-    for (const line of oldLines) {
-      lines.push(`- ${line}`)
-    }
-    // Add new lines as additions
-    const newLines = newString.split('\n')
-    for (const line of newLines) {
-      lines.push(`+ ${line}`)
-    }
-    // Add separator between replacements if there are multiple
-    if (replacements.length > 1) {
-      lines.push('')
-    }
-  }
-
-  return lines.join('\n')
-}
-
-/**
- * Construct a diff view from write_file content.
- */
-function constructDiffFromWriteFile(content: string): string {
-  const lines = content.split('\n')
-  return lines.map((line) => `+ ${line}`).join('\n')
-}
-
-/**
- * Check if a tool is a "create new file" operation.
- */
-export function isCreateFile(toolBlock: ToolContentBlock): boolean {
-  const outputStr = typeof toolBlock.output === 'string' ? toolBlock.output : ''
-  const message = extractValueForKey(outputStr, 'message')
-  return (
-    typeof message === 'string' &&
-    (message.startsWith('Created file successfully') ||
-      message.startsWith('Created new file') ||
-      message.startsWith('Proposed new file'))
-  )
-}
-
-function hasToolResultOutput(toolBlock: ToolContentBlock): boolean {
-  const outputStr = typeof toolBlock.output === 'string' ? toolBlock.output : ''
-  return outputStr.length > 0 || toolBlock.outputRaw !== undefined
-}
-
-/**
- * Decide whether the direct edit tool renderer should show a diff preview.
- *
- * Real edit tool calls render immediately with input only, then receive output
- * once the edit completes. Wait for that result before showing diffs so create
- * operations never briefly flash an input-derived full-file diff.
- */
-export function shouldShowEditDiff(toolBlock: ToolContentBlock): boolean {
-  if (!extractDiff(toolBlock) || isCreateFile(toolBlock)) {
-    return false
-  }
-
-  if (
-    !isProposedToolName(toolBlock.toolName) &&
-    !hasToolResultOutput(toolBlock)
-  ) {
-    return false
-  }
-
-  return true
-}
-
-export interface TimelineItem {
-  type: 'commentary' | 'edit'
-  content: string // For commentary: the text. For edits: file path
-  diff?: string // For edits: the unified diff
-  isCreate?: boolean // For edits: whether this is a new file creation
-}
-
-/** Git-style change type for files */
-export type FileChangeType = 'A' | 'M' | 'D' | 'R'
-
-export interface DiffStats {
-  linesAdded: number
-  linesRemoved: number
-  hunks: number
-}
-
-export interface FileStats {
-  path: string
-  changeType: FileChangeType
-  stats: DiffStats
-}
-
-/**
- * Parse diff text and extract statistics.
- */
-export function parseDiffStats(diff: string | undefined): DiffStats {
-  if (!diff) return { linesAdded: 0, linesRemoved: 0, hunks: 0 }
-
-  const lines = diff.split('\n')
-  let linesAdded = 0
-  let linesRemoved = 0
-  let hunks = 0
-
-  for (const line of lines) {
-    // Count hunk headers (lines starting with @@)
-    if (line.startsWith('@@')) {
-      hunks++
-    }
-    // Count additions (lines starting with + but not +++ header)
-    else if (line.startsWith('+') && !line.startsWith('+++')) {
-      linesAdded++
-    }
-    // Count deletions (lines starting with - but not --- header)
-    else if (line.startsWith('-') && !line.startsWith('---')) {
-      linesRemoved++
-    }
-  }
-
-  // If no @@ markers found but we have +/- lines, count as 1 hunk
-  if (hunks === 0 && (linesAdded > 0 || linesRemoved > 0)) {
-    hunks = 1
-  }
-
-  return { linesAdded, linesRemoved, hunks }
-}
-
-/**
- * Determine file change type based on tool and context.
- */
-export function getFileChangeType(toolBlock: ToolContentBlock): FileChangeType {
-  const baseToolName = getBaseToolName(toolBlock.toolName)
-  // write_file creating new file = Added
-  if (baseToolName === 'write_file') {
-    const isCreate = isCreateFile(toolBlock)
-    return isCreate ? 'A' : 'M'
-  }
-
-  // str_replace is always a modification
-  if (baseToolName === 'str_replace') {
-    return 'M'
-  }
-
-  // Default to modified
-  return 'M'
-}
-
-/**
- * Get aggregated file stats from all edit blocks.
- * Groups by file path and sums up the stats.
- */
-export function getFileStatsFromBlocks(
-  blocks: ContentBlock[] | undefined,
-): FileStats[] {
-  if (!blocks || blocks.length === 0) return []
-
-  const fileMap = new Map<string, FileStats>()
-
-  for (const block of blocks) {
-    if (
-      block.type === 'tool' &&
-      ALL_EDIT_TOOL_NAMES.includes(
-        block.toolName as (typeof ALL_EDIT_TOOL_NAMES)[number],
-      )
-    ) {
-      if (isFailedEditToolBlock(block)) continue
-
-      const filePath = extractFilePath(block)
-      if (!filePath) continue
-
-      const diff = extractDiff(block)
-      const stats = parseDiffStats(diff ?? undefined)
-      const changeType = getFileChangeType(block)
-
-      const existing = fileMap.get(filePath)
-      if (existing) {
-        // Aggregate stats for same file
-        existing.stats.linesAdded += stats.linesAdded
-        existing.stats.linesRemoved += stats.linesRemoved
-        existing.stats.hunks += stats.hunks
-      } else {
-        fileMap.set(filePath, {
-          path: filePath,
-          changeType,
-          stats,
-        })
-      }
-    }
-  }
-
-  return Array.from(fileMap.values())
-}
-
-/**
- * Build an activity timeline from agent blocks.
- * Interleaves commentary (text blocks) and edits (tool calls).
- * Includes both executed tools (str_replace, write_file) and proposed tools.
- */
-export function buildActivityTimeline(
-  blocks: ContentBlock[] | undefined,
-): TimelineItem[] {
-  if (!blocks || blocks.length === 0) return []
-
-  const timeline: TimelineItem[] = []
-
-  for (const block of blocks) {
-    if (block.type === 'text' && block.textType !== 'reasoning') {
-      const content = block.content.trim()
-      if (content) {
-        timeline.push({ type: 'commentary', content })
-      }
-    } else if (
-      block.type === 'tool' &&
-      ALL_EDIT_TOOL_NAMES.includes(
-        block.toolName as (typeof ALL_EDIT_TOOL_NAMES)[number],
-      )
-    ) {
-      if (isFailedEditToolBlock(block)) continue
-
-      const filePath = extractFilePath(block)
-      const diff = extractDiff(block)
-      const isCreate = isCreateFile(block)
-
-      timeline.push({
-        type: 'edit',
-        content: filePath || 'unknown file',
-        diff: diff || undefined,
-        isCreate,
-      })
-    }
-  }
-
-  return timeline
-}
-
-/**
- * Truncate text to fit within maxWidth, adding ellipsis if needed.
- */
-export function truncateWithEllipsis(text: string, maxWidth: number): string {
-  if (text.length <= maxWidth) return text
-  if (maxWidth <= 3) return text.slice(0, maxWidth)
-  return text.slice(0, maxWidth - 3) + '...'
-}
-
-export interface MultiPromptProgress {
-  /** Total number of implementor agents */
-  total: number
-  /** Number of successfully completed implementors */
-  completed: number
-  /** Number of failed/errored implementors */
-  failed: number
-  /** Whether selector is active (all implementors done, selecting best) */
-  isSelecting: boolean
-  /** Whether selector has completed (used to detect applying phase) */
-  isSelectorComplete: boolean
-}
-
-/**
- * Analyze progress of a multi-prompt editor agent.
- * Returns counts of implementor agents and current phase.
- */
-export function getMultiPromptProgress(
-  blocks: ContentBlock[] | undefined,
-): MultiPromptProgress | null {
-  if (!blocks || blocks.length === 0) return null
-
-  const implementors = blocks.filter(
-    (block): block is AgentContentBlock =>
-      block.type === 'agent' && isImplementorAgent(block),
-  )
-
-  if (implementors.length === 0) return null
-
-  const completed = implementors.filter((a) => a.status === 'complete').length
-  const failed = implementors.filter(
-    (a) => a.status === 'failed' || a.status === 'cancelled',
-  ).length
-
-  const selectorAgent = blocks.find(
-    (block): block is AgentContentBlock =>
-      block.type === 'agent' && block.agentType.includes('best-of-n-selector'),
-  )
-  const isSelecting = selectorAgent?.status === 'running'
-
-  return {
-    total: implementors.length,
-    completed,
-    failed,
-    isSelecting,
-    isSelectorComplete: selectorAgent?.status === 'complete',
-  }
-}
-
-/** Expected shape of the set_output data from editor-multi-prompt */
-interface MultiPromptSetOutputData {
-  implementationId?: string
-  chosenStrategy?: string
-  reason?: string
-  suggestedImprovements?: string
-  toolResults?: unknown[]
-  error?: string
-}
-
-/** Expected shape of the set_output input (data is wrapped in a 'data' property) */
-interface SetOutputInput {
-  data?: MultiPromptSetOutputData
-}
-
-/** Type guard for set_output input with data property */
-function hasSetOutputData(input: unknown): input is SetOutputInput {
-  return (
-    typeof input === 'object' &&
-    input !== null &&
-    'data' in input &&
-    typeof (input as SetOutputInput).data === 'object'
-  )
-}
-
-/**
- * Extract the selection reason from multi-prompt agent's set_output block.
- * set_output wraps data in a 'data' property, so we need to access input.data.reason
- */
-function extractSelectionReason(
-  blocks: ContentBlock[] | undefined,
-): string | null {
-  if (!blocks || blocks.length === 0) return null
-
-  const setOutputBlock = blocks.find(
-    (block): block is ToolContentBlock =>
-      block.type === 'tool' &&
-      block.toolName === 'set_output' &&
-      hasSetOutputData(block.input) &&
-      typeof block.input.data?.reason === 'string',
-  )
-
-  if (!setOutputBlock || !hasSetOutputData(setOutputBlock.input)) {
-    return null
-  }
-
-  return setOutputBlock.input.data?.reason ?? null
-}
-
-/**
- * Generate a progress-focused preview string for multi-prompt editor.
- * @param blocks - The nested content blocks of the agent
- * @param isAgentComplete - Whether the parent agent has finished (status === 'complete')
- */
-export function getMultiPromptPreview(
-  blocks: ContentBlock[] | undefined,
-  isAgentComplete?: boolean,
-): string | null {
-  const progress = getMultiPromptProgress(blocks)
-  if (!progress) return null
-
-  const { total, completed, failed, isSelecting, isSelectorComplete } = progress
-  const finished = completed + failed
-
-  // Agent is fully complete - show final state with selection info
-  // Use multi-line format: line 1 = count, lines 2-3 = reason (truncated to fit)
-  if (isAgentComplete) {
-    const reason = extractSelectionReason(blocks)
-    if (reason) {
-      // Capitalize first letter and truncate to 2 lines (line 1 is the count)
-      const formattedReason = reason.charAt(0).toUpperCase() + reason.slice(1)
-      const lines = formattedReason.split('\n')
-      const truncatedReason =
-        lines.length > 2
-          ? lines.slice(0, 2).join('\n').trimEnd() + '...'
-          : formattedReason
-      return `${total} proposals evaluated\n${truncatedReason}`
-    }
-    return `${total} proposals evaluated`
-  }
-
-  // Selector completed but agent still running = applying phase
-  if (isSelectorComplete) {
-    return 'Applying selected changes...'
-  }
-
-  if (isSelecting) {
-    return `${total} proposals complete • Selecting best...`
-  }
-
-  if (finished === total && total > 0) {
-    if (failed > 0) {
-      return `${completed}/${total} proposals complete (${failed} failed)`
-    }
-    return `${total} proposals complete`
-  }
-
-  if (finished > 0) {
-    if (failed > 0) {
-      return `${completed}/${total} complete, ${failed} failed...`
-    }
-    return `${completed}/${total} proposals complete...`
-  }
-
-  return `Generating ${total} proposals...`
-}