@alumbwe/anvil 1.0.0

package/src/utils/collapse-helpers.ts

@@ -0,0 +1,256 @@
+/**
+ * Pure utility functions for collapse/expand all functionality.
+ */
+
+import type { ChatMessage, ContentBlock, TextContentBlock, ThinkingCollapseState } from '../types/chat'
+
+/**
+ * Type representing a block that supports collapsing.
+ * This includes: thinking blocks (text with thinkingId), agent blocks, tool blocks, and agent-list blocks.
+ */
+type CollapsibleBlock = ContentBlock & {
+  isCollapsed?: boolean
+  userOpened?: boolean
+}
+
+/**
+ * Checks if a block is a thinking text block (text with thinkingId).
+ * These use thinkingCollapseState instead of isCollapsed.
+ */
+function isThinkingTextBlock(block: ContentBlock): block is TextContentBlock {
+  return block.type === 'text' && 'thinkingId' in block && !!block.thinkingId
+}
+
+/**
+ * Checks if a content block is collapsible.
+ * Collapsible blocks are: thinking blocks (text with thinkingId), agent, tool, and agent-list blocks.
+ */
+function isCollapsibleBlock(block: ContentBlock): block is CollapsibleBlock {
+  if (block.type === 'text' && 'thinkingId' in block && block.thinkingId) {
+    return true
+  }
+  if (block.type === 'agent' || block.type === 'tool' || block.type === 'agent-list') {
+    return true
+  }
+  return false
+}
+
+/**
+ * Checks if a collapsible block is explicitly expanded.
+ * Thinking blocks use thinkingCollapseState; others use isCollapsed.
+ */
+function isBlockExpanded(block: CollapsibleBlock): boolean {
+  if (isThinkingTextBlock(block)) {
+    return block.thinkingCollapseState === 'expanded'
+  }
+  return block.isCollapsed === false
+}
+
+/**
+ * Gets the current collapsed state of a block.
+ * Thinking blocks use thinkingCollapseState; others use isCollapsed.
+ */
+function getBlockCollapsedState(block: CollapsibleBlock): boolean {
+  if (isThinkingTextBlock(block)) {
+    return block.thinkingCollapseState !== 'expanded'
+  }
+  return block.isCollapsed ?? true
+}
+
+/**
+ * Creates an updated block with new collapsed state if different from current.
+ * Returns null if no change is needed.
+ * Thinking blocks use thinkingCollapseState; others use isCollapsed.
+ */
+function createUpdatedBlock(
+  block: CollapsibleBlock,
+  collapsed: boolean,
+): CollapsibleBlock | null {
+  if (isThinkingTextBlock(block)) {
+    const targetState: ThinkingCollapseState = collapsed ? 'hidden' : 'expanded'
+    if (block.thinkingCollapseState === targetState) {
+      return null
+    }
+    return {
+      ...block,
+      thinkingCollapseState: targetState,
+      userOpened: !collapsed ? true : block.userOpened,
+    }
+  }
+  const currentCollapsed = getBlockCollapsedState(block)
+  if (currentCollapsed === collapsed) {
+    return null
+  }
+  return {
+    ...block,
+    isCollapsed: collapsed,
+    userOpened: !collapsed ? true : block.userOpened,
+  }
+}
+
+/**
+ * Checks if any collapsible block in the given blocks array is expanded.
+ * Recursively checks nested blocks within agent blocks.
+ */
+function hasAnyExpandedBlocksRecursive(blocks: ContentBlock[]): boolean {
+  for (const block of blocks) {
+    if (isCollapsibleBlock(block)) {
+      if (isBlockExpanded(block)) {
+        return true
+      }
+      // Recursively check nested blocks in agent blocks
+      if (block.type === 'agent' && block.blocks) {
+        if (hasAnyExpandedBlocksRecursive(block.blocks)) {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+/**
+ * Checks if any collapsible block in the messages array is expanded.
+ * Returns true if at least one block is not collapsed.
+ *
+ * @param messages - The messages array to check
+ * @returns true if any block is expanded, false if all are collapsed
+ */
+export function hasAnyExpandedBlocks(messages: ChatMessage[]): boolean {
+  for (const message of messages) {
+    // Handle agent variant messages
+    if (message.variant === 'agent') {
+      if (message.metadata?.isCollapsed === false) {
+        return true
+      }
+    }
+
+    // Handle blocks within messages
+    if (message.blocks && hasAnyExpandedBlocksRecursive(message.blocks)) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Result type for recursive block update operation.
+ */
+interface UpdateBlocksResult {
+  blocks: ContentBlock[]
+  changed: boolean
+}
+
+/**
+ * Recursively updates isCollapsed on all collapsible blocks.
+ * Returns both the updated blocks and whether any changes were made.
+ */
+function updateBlocksRecursively(
+  blocks: ContentBlock[],
+  collapsed: boolean,
+): UpdateBlocksResult {
+  let anyChanged = false
+  const result = blocks.map((block) => {
+    if (!isCollapsibleBlock(block)) {
+      return block
+    }
+
+    // Handle agent blocks specially due to nested blocks
+    if (block.type === 'agent') {
+      const currentCollapsed = getBlockCollapsedState(block)
+      let updatedBlock = block
+      let blockChanged = false
+
+      // Check if this block's state needs updating
+      if (currentCollapsed !== collapsed) {
+        blockChanged = true
+        updatedBlock = {
+          ...block,
+          isCollapsed: collapsed,
+          userOpened: !collapsed ? true : block.userOpened,
+        }
+      }
+
+      // Recursively update nested blocks
+      if (block.blocks) {
+        const nested = updateBlocksRecursively(block.blocks, collapsed)
+        if (nested.changed) {
+          blockChanged = true
+          updatedBlock = {
+            ...updatedBlock,
+            blocks: nested.blocks,
+          }
+        }
+      }
+
+      if (blockChanged) {
+        anyChanged = true
+        return updatedBlock
+      }
+      return block
+    }
+
+    // Handle all other collapsible blocks (tool, text with thinkingId, agent-list)
+    const updated = createUpdatedBlock(block, collapsed)
+    if (updated) {
+      anyChanged = true
+      return updated
+    }
+    return block
+  })
+
+  return { blocks: anyChanged ? result : blocks, changed: anyChanged }
+}
+
+/**
+ * Updates all collapsible blocks in all messages to the specified collapsed state.
+ * This is a pure function that returns new message objects when changes are made.
+ *
+ * @param messages - The messages array to update
+ * @param collapsed - Whether blocks should be collapsed (true) or expanded (false)
+ * @returns Updated messages array with all collapsible blocks set to the specified state
+ */
+export function setAllBlocksCollapsedState(
+  messages: ChatMessage[],
+  collapsed: boolean,
+): ChatMessage[] {
+  return messages.map((message) => {
+    let updatedMessage = message
+    let messageChanged = false
+
+    // Handle agent variant messages (message-level isCollapsed)
+    if (message.variant === 'agent') {
+      // Treat undefined as collapsed (true) to match hasAnyExpandedBlocks semantics
+      const currentCollapsed = message.metadata?.isCollapsed ?? true
+      if (currentCollapsed !== collapsed) {
+        messageChanged = true
+        updatedMessage = {
+          ...updatedMessage,
+          metadata: {
+            ...updatedMessage.metadata,
+            isCollapsed: collapsed,
+            userOpened: !collapsed ? true : updatedMessage.metadata?.userOpened,
+          },
+        }
+      }
+    }
+
+    // Handle blocks within messages (applies to all message variants)
+    if (message.blocks) {
+      const { blocks: updatedBlocks, changed } = updateBlocksRecursively(
+        message.blocks,
+        collapsed,
+      )
+      if (changed) {
+        messageChanged = true
+        updatedMessage = {
+          ...updatedMessage,
+          blocks: updatedBlocks,
+        }
+      }
+    }
+
+    return messageChanged ? updatedMessage : message
+  })
+}

package/src/utils/config-dir.ts

@@ -0,0 +1,24 @@
+import os from 'os'
+import path from 'path'
+
+import { env } from '@anvil/common/env'
+
+/**
+ * Resolve the on-disk config directory for the CLI.
+ *
+ * Lives in its own module (depending only on `env`) so that low-level helpers
+ * — e.g. the persistent analytics id — can read the config dir without pulling
+ * in `auth.ts`, which transitively imports the logger and analytics and would
+ * otherwise create an import cycle.
+ */
+export const getConfigDir = (): string => {
+  return path.join(
+    os.homedir(),
+    '.config',
+    'manicode' +
+      // on a development stack?
+      (env.NEXT_PUBLIC_CB_ENVIRONMENT !== 'prod'
+        ? `-${env.NEXT_PUBLIC_CB_ENVIRONMENT}`
+        : ''),
+  )
+}

package/src/utils/constants.ts

@@ -0,0 +1,190 @@
+import type { ToolName } from '@anvil/sdk'
+
+import { getCliEnv } from './env'
+
+/**
+ * Freebuff build-time flag. When true, the CLI is built as Freebuff (free-only variant).
+ * Injected via --define at compile time; enables dead-code elimination by the bundler.
+ */
+export const IS_FREEBUFF = getCliEnv().FREEBUFF_MODE === 'true'
+
+/** Message shown when the user ends a freebuff session early. */
+export const END_SESSION_MESSAGE =
+  'Ending session and returning to the model picker…'
+
+// Agent IDs that should not be rendered in the CLI UI. Matched as substrings
+// so both bundled ids ('context-pruner') and publisher-qualified ids
+// ('anvil/context-pruner@1.0.0') are covered.
+export const HIDDEN_AGENT_IDS = ['context-pruner'] as const
+
+// Tool names that should be collapsed by default when rendered
+// Uses ToolName type to ensure only valid tool names are added
+export const COLLAPSED_BY_DEFAULT_TOOL_NAMES: readonly ToolName[] = [
+  'set_output',
+] as const
+
+/**
+ * Check if a tool should be collapsed by default
+ */
+export const shouldCollapseToolByDefault = (toolName: string): boolean => {
+  return COLLAPSED_BY_DEFAULT_TOOL_NAMES.includes(toolName as ToolName)
+}
+
+/**
+ * Check if an agent ID should be hidden from rendering
+ */
+export const shouldHideAgent = (agentId: string): boolean => {
+  return HIDDEN_AGENT_IDS.some((hiddenId) => agentId.includes(hiddenId))
+}
+
+// Agent IDs that should be collapsed by default when they start
+export const COLLAPSED_BY_DEFAULT_AGENT_IDS = [
+  'file-picker',
+  'code-reviewer-selector',
+  'thinker-selector',
+  'best-of-n-selector',
+  'basher',
+  'code-searcher',
+  'directory-lister',
+  'glob-matcher',
+  'researcher-web',
+  'researcher-docs',
+] as const
+
+/**
+ * Check if an agent should be collapsed by default
+ */
+export const shouldCollapseByDefault = (agentType: string): boolean => {
+  return COLLAPSED_BY_DEFAULT_AGENT_IDS.some((collapsedId) =>
+    agentType.includes(collapsedId),
+  )
+}
+
+/**
+ * Rules for collapsing child agents when spawned by specific parent agents.
+ * Key: parent agent type pattern, Value: array of child agent type patterns to collapse
+ */
+export const PARENT_CHILD_COLLAPSE_RULES: Record<string, string[]> = {
+  'code-reviewer-multi-prompt': ['code-reviewer'],
+}
+
+/**
+ * Check if a child agent should be collapsed when spawned by a specific parent
+ */
+export const shouldCollapseForParent = (
+  childAgentType: string,
+  parentAgentType: string | undefined,
+): boolean => {
+  if (!parentAgentType) {
+    return false
+  }
+
+  for (const [parentPattern, childPatterns] of Object.entries(
+    PARENT_CHILD_COLLAPSE_RULES,
+  )) {
+    if (parentAgentType.includes(parentPattern)) {
+      for (const childPattern of childPatterns) {
+        if (childAgentType.includes(childPattern)) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+// Agent IDs that should render as simple text instead of full agent boxes
+export const SIMPLE_TEXT_AGENT_IDS = [
+  'best-of-n-selector',
+  'best-of-n-selector-gemini',
+  'best-of-n-selector2',
+] as const
+
+/**
+ * Check if an agent should render as simple text instead of a full agent box
+ */
+export const shouldRenderAsSimpleText = (agentType: string): boolean => {
+  return SIMPLE_TEXT_AGENT_IDS.some((simpleTextId) =>
+    agentType.includes(simpleTextId),
+  )
+}
+
+// Agent IDs that show progress-focused previews (multi-prompt editors)
+export const MULTI_PROMPT_EDITOR_IDS = ['editor-multi-prompt'] as const
+
+/**
+ * Check if an agent should show progress-focused preview when collapsed
+ */
+export const isMultiPromptEditor = (agentType: string): boolean => {
+  return MULTI_PROMPT_EDITOR_IDS.some((id) => agentType.includes(id))
+}
+
+/**
+ * The parent agent ID for all root-level agents
+ */
+export const MAIN_AGENT_ID = 'main-agent'
+
+/**
+ * Which harness the CLI's DEFAULT and LITE modes run.
+ *
+ * base3 runs Anvil DEFAULT and LITE plus every Freebuff picker model. MAX
+ * and PLAN remain on their purpose-built base2 roots below.
+ *
+ * Unlike Web and Cloud, the CLI has no server-side base3 kill switch: changing
+ * this routing after release requires another CLI release. The earlier Flash
+ * benchmark and rollback rationale remain documented in
+ * docs/freebuff-base3-harness.md so future harness changes preserve that
+ * context.
+ */
+export const CLI_HARNESS: 'base2' | 'base3' = 'base3'
+
+/** The only two modes that follow CLI_HARNESS. MAX and PLAN never moved, so
+ *  they are not in here — listing them per harness would invite editing one row
+ *  and not the other. */
+const HARNESS_MODE_IDS = {
+  base2: { DEFAULT: 'base2', LITE: 'base2-lite' },
+  base3: { DEFAULT: 'base3', LITE: 'base3-lite' },
+} as const
+
+/**
+ * Mapping from agent mode to agent ID.
+ * Single source of truth for all agent modes (order = cycling order).
+ *
+ * Freebuff resolves LITE through the selected freebuff model at send time;
+ * this fallback stays on base2-free for non-runtime callers. Regular
+ * Anvil maps LITE to a paid lite root which charges credits normally.
+ *
+ * MAX and PLAN never moved to base3 and are unaffected by CLI_HARNESS. MAX is
+ * the mode users pick when they want the multi-prompt editor and the reviewer
+ * fan-out — the ceremony IS the product there. PLAN never touches a file, so
+ * windowed reads and single-loop-instead-of-subagents buy it nothing, and its
+ * `<PLAN>` flow (see sdk-event-handlers.ts) is tuned against base2's plan-only
+ * prompt. Same reasoning that kept the Freebuff Cloud planner on base2.
+ */
+export const AGENT_MODE_TO_ID = {
+  DEFAULT: HARNESS_MODE_IDS[CLI_HARNESS].DEFAULT,
+  LITE: IS_FREEBUFF ? 'base2-free' : HARNESS_MODE_IDS[CLI_HARNESS].LITE,
+  MAX: 'base2-max',
+  PLAN: 'base2-plan',
+} as const
+
+export type AgentMode = keyof typeof AGENT_MODE_TO_ID
+export const AGENT_MODES = Object.keys(AGENT_MODE_TO_ID) as AgentMode[]
+
+/**
+ * Maps CLI agent mode to cost mode for billing.
+ *
+ * Freebuff's LITE maps to 'free' cost mode (session gate, rate limits, 0 credits
+ * for allowlisted agent+model combos). Regular Anvil's LITE maps to 'lite' —
+ * a normal paid mode (charges credits, no session gate, no country restrictions).
+ */
+export const AGENT_MODE_TO_COST_MODE = {
+  DEFAULT: 'normal',
+  LITE: IS_FREEBUFF ? 'free' : 'lite',
+  MAX: 'max',
+  PLAN: 'normal',
+} as const satisfies Record<
+  AgentMode,
+  'free' | 'lite' | 'normal' | 'max' | 'experimental' | 'ask'
+>

package/src/utils/create-event-handler-state.ts

@@ -0,0 +1,73 @@
+import type { AgentMode } from './constants'
+import type { MessageUpdater } from './message-updater'
+import type {
+  EventHandlerState,
+  SetStreamingAgentsFn,
+  SetStreamStatusFn,
+} from './sdk-event-handlers'
+import type { StreamController } from '../hooks/stream-state'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+import type { MutableRefObject } from 'react'
+
+export type CreateEventHandlerStateParams = {
+  isActive?: () => boolean
+  streamRefs: StreamController
+  setStreamingAgents: SetStreamingAgentsFn
+  setStreamStatus: SetStreamStatusFn
+  aiMessageId: string
+  updater: MessageUpdater
+  hasReceivedContentRef: MutableRefObject<boolean>
+  addActiveSubagent: (id: string) => void
+  removeActiveSubagent: (id: string) => void
+  agentMode: AgentMode
+  setHasReceivedPlanResponse: (value: boolean) => void
+  logger: Logger
+  setIsRetrying: (retrying: boolean) => void
+  onTotalCost?: (cost: number) => void
+}
+
+export const createEventHandlerState = (
+  params: CreateEventHandlerStateParams,
+): EventHandlerState => {
+  const {
+    isActive,
+    streamRefs,
+    setStreamingAgents,
+    setStreamStatus,
+    aiMessageId,
+    updater,
+    hasReceivedContentRef,
+    addActiveSubagent,
+    removeActiveSubagent,
+    agentMode,
+    setHasReceivedPlanResponse,
+    logger,
+    setIsRetrying,
+    onTotalCost,
+  } = params
+
+  return {
+    isActive,
+    streaming: {
+      streamRefs,
+      setStreamingAgents,
+      setStreamStatus,
+    },
+    message: {
+      aiMessageId,
+      updater,
+      hasReceivedContentRef,
+    },
+    subagents: {
+      addActiveSubagent,
+      removeActiveSubagent,
+    },
+    mode: {
+      agentMode,
+      setHasReceivedPlanResponse,
+    },
+    logger,
+    setIsRetrying,
+    onTotalCost,
+  }
+}

package/src/utils/create-run-config.ts

@@ -0,0 +1,121 @@
+import path from 'path'
+
+import { MAX_AGENT_STEPS_DEFAULT } from '@anvil/common/constants/agents'
+import { isSensitiveEnvFilePath } from '@anvil/common/util/env-file-path'
+
+import {
+  createEventHandler,
+  createStreamChunkHandler,
+} from './sdk-event-handlers'
+
+import type { EventHandlerState } from './sdk-event-handlers'
+import type { Logger } from '@anvil/common/types/contracts/logger'
+import type {
+  AgentDefinition,
+  FileFilter,
+  MessageContent,
+  RunState,
+} from '@anvil/sdk'
+
+export type CreateRunConfigParams = {
+  logger: Logger
+  agent: AgentDefinition | string
+  prompt: string
+  content: MessageContent[] | undefined
+  previousRunState: RunState | null
+  agentDefinitions: AgentDefinition[]
+  eventHandlerState: EventHandlerState
+  signal: AbortSignal
+  costMode?: 'free' | 'lite' | 'normal' | 'max' | 'experimental' | 'ask'
+  extraAnvilMetadata?: Record<string, string>
+  /** Periodic in-flight RunState checkpoints (see RunOptions.onStateSnapshot). */
+  onStateSnapshot?: (runState: RunState) => void
+}
+
+const SENSITIVE_EXTENSIONS = new Set([
+  '.pem',
+  '.key',
+  '.p12',
+  '.pfx',
+  '.jks',
+  '.keystore',
+  '.crt',
+  '.cer',
+])
+const SENSITIVE_BASENAMES = new Set([
+  '.htpasswd',
+  '.netrc',
+  'credentials',
+  '.npmrc',
+  '.yarnrc',
+  '.yarnrc.yml',
+  'auth.json',
+  '.pypirc',
+  'terraform.tfvars',
+  '.terraformrc',
+])
+
+// Pattern matches (grouped by match type)
+const SENSITIVE_PATTERNS = {
+  prefix: ['id_rsa', 'id_ed25519', 'id_dsa', 'id_ecdsa'], // SSH private keys
+  suffix: ['_credentials'],
+  substring: ['kubeconfig', '.tfstate'],
+}
+
+const matchesPattern = (str: string) =>
+  SENSITIVE_PATTERNS.prefix.some(
+    (p) => str.startsWith(p) && !str.endsWith('.pub'),
+  ) ||
+  SENSITIVE_PATTERNS.suffix.some((s) => str.endsWith(s)) ||
+  SENSITIVE_PATTERNS.substring.some((sub) => str.includes(sub))
+
+/**
+ * Check if a file is a sensitive file that should be blocked from reading.
+ */
+export function isSensitiveFile(filePath: string): boolean {
+  const basename = path.basename(filePath)
+  const basenameLower = basename.toLowerCase()
+  const ext = path.extname(filePath).toLowerCase()
+
+  return (
+    isSensitiveEnvFilePath(filePath) ||
+    SENSITIVE_EXTENSIONS.has(ext) ||
+    SENSITIVE_BASENAMES.has(basenameLower) ||
+    matchesPattern(basenameLower)
+  )
+}
+
+export const createRunConfig = (params: CreateRunConfigParams) => {
+  const {
+    logger,
+    agent,
+    prompt,
+    content,
+    previousRunState,
+    agentDefinitions,
+    eventHandlerState,
+    costMode,
+    extraAnvilMetadata,
+    onStateSnapshot,
+  } = params
+
+  return {
+    logger,
+    agent,
+    prompt,
+    content,
+    previousRun: previousRunState ?? undefined,
+    agentDefinitions,
+    maxAgentSteps: MAX_AGENT_STEPS_DEFAULT,
+    handleStreamChunk: createStreamChunkHandler(eventHandlerState),
+    handleEvent: createEventHandler(eventHandlerState),
+    signal: params.signal,
+    costMode,
+    extraAnvilMetadata,
+    onStateSnapshot,
+    fileFilter: ((filePath: string) => {
+      if (isSensitiveFile(filePath)) return { status: 'blocked' }
+      return { status: 'allow' }
+    }) satisfies FileFilter,
+  }
+}