@xortex/xcode 3.0.0

package/utils/transcriptSearch.ts

@@ -0,0 +1,202 @@
+import type { RenderableMessage } from '../types/message.js'
+import {
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+} from './messages.js'
+
+const SYSTEM_REMINDER_CLOSE = '</system-reminder>'
+
+// UserTextMessage.tsx:~84 replaces these with <InterruptedByUser />
+// (renders 'Interrupted · /issue...'). Raw text never appears on screen;
+// searching it yields phantom matches — /terr → in[terr]upted.
+const RENDERED_AS_SENTINEL = new Set([
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+])
+
+const searchTextCache = new WeakMap<RenderableMessage, string>()
+
+/** Flatten a RenderableMessage to lowercased searchable text. WeakMap-
+ *  cached — messages are append-only and immutable so a hit is always
+ *  valid. Lowercased at cache time: the only caller immediately
+ *  .toLowerCase()d the result, re-lowering ~1.5MB on every keystroke
+ *  (the backspace hang). Returns '' for non-searchable types. */
+export function renderableSearchText(msg: RenderableMessage): string {
+  const cached = searchTextCache.get(msg)
+  if (cached !== undefined) return cached
+  const result = computeSearchText(msg).toLowerCase()
+  searchTextCache.set(msg, result)
+  return result
+}
+
+function computeSearchText(msg: RenderableMessage): string {
+  let raw = ''
+  switch (msg.type) {
+    case 'user': {
+      const c = msg.message.content
+      if (typeof c === 'string') {
+        raw = RENDERED_AS_SENTINEL.has(c) ? '' : c
+      } else {
+        const parts: string[] = []
+        for (const b of c) {
+          if (b.type === 'text') {
+            if (!RENDERED_AS_SENTINEL.has(b.text)) parts.push(b.text)
+          } else if (b.type === 'tool_result') {
+            // b.content is the MODEL-facing serialization (from each tool's
+            // mapToolResultToToolResultBlockParam) — adds system-reminders,
+            // <persisted-output> wrappers, backgroundInfo strings,
+            // CYBER_RISK_MITIGATION_REMINDER. The UI
+            // renders msg.toolUseResult (the tool's native Out) via
+            // renderToolResultMessage — DIFFERENT text. Indexing b.content
+            // yields phantoms: /malware → matches the reminder, /background
+            // → matches the model-only ID string, none render.
+            //
+            // Duck-type the native Out instead. Covers the common shapes:
+            // Bash {stdout,stderr}, Grep {content,filenames}, Read
+            // {file.content}. Unknown shapes index empty — under-count is
+            // honest, phantom is a lie. Proper fix is per-tool
+            // extractSearchText(Out) on the Tool interface (TODO).
+            parts.push(toolResultSearchText(msg.toolUseResult))
+          }
+        }
+        raw = parts.join('\n')
+      }
+      break
+    }
+    case 'assistant': {
+      const c = msg.message.content
+      if (Array.isArray(c)) {
+        // text blocks + tool_use inputs. tool_use renders as "⏺ Bash(cmd)"
+        // — the command/pattern/path is visible and searchable-expected.
+        // Skip thinking (hidden by hidePastThinking in transcript mount).
+        raw = c
+          .flatMap(b => {
+            if (b.type === 'text') return [b.text]
+            if (b.type === 'tool_use') return [toolUseSearchText(b.input)]
+            return []
+          })
+          .join('\n')
+      }
+      break
+    }
+    case 'attachment': {
+      // relevant_memories renders full m.content in transcript mode
+      // (AttachmentMessage.tsx <Ansi>{m.content}</Ansi>). Visible but
+      // unsearchable without this — [ dump finds it, / doesn't.
+      if (msg.attachment.type === 'relevant_memories') {
+        raw = msg.attachment.memories.map(m => m.content).join('\n')
+      } else if (
+        // Mid-turn prompts — queued while an agent is running. Render via
+        // UserTextMessage (AttachmentMessage.tsx:~348). stickyPromptText
+        // (VirtualMessageList.tsx:~103) has the same guards — mirror here.
+        msg.attachment.type === 'queued_command' &&
+        msg.attachment.commandMode !== 'task-notification' &&
+        !msg.attachment.isMeta
+      ) {
+        const p = msg.attachment.prompt
+        raw =
+          typeof p === 'string'
+            ? p
+            : p.flatMap(b => (b.type === 'text' ? [b.text] : [])).join('\n')
+      }
+      break
+    }
+    case 'collapsed_read_search': {
+      // relevant_memories attachments are absorbed into collapse groups
+      // (collapseReadSearch.ts); their content is visible in transcript mode
+      // via CollapsedReadSearchContent, so mirror it here for / search.
+      if (msg.relevantMemories) {
+        raw = msg.relevantMemories.map(m => m.content).join('\n')
+      }
+      break
+    }
+    default:
+      // grouped_tool_use, system — no text content
+      break
+  }
+  // Strip <system-reminder> anywhere — Claude context, not user-visible.
+  // Mid-message on cc -c resumes (memory reminders between prompt lines).
+  let t = raw
+  let open = t.indexOf('<system-reminder>')
+  while (open >= 0) {
+    const close = t.indexOf(SYSTEM_REMINDER_CLOSE, open)
+    if (close < 0) break
+    t = t.slice(0, open) + t.slice(close + SYSTEM_REMINDER_CLOSE.length)
+    open = t.indexOf('<system-reminder>')
+  }
+  return t
+}
+
+/** Tool invocation display: renderToolUseMessage shows input fields like
+ *  command (Bash), pattern (Grep), file_path (Read/Edit), prompt (Agent).
+ *  Same duck-type strategy as toolResultSearchText — known field names,
+ *  unknown → empty. Under-count > phantom. */
+export function toolUseSearchText(input: unknown): string {
+  if (!input || typeof input !== 'object') return ''
+  const o = input as Record<string, unknown>
+  const parts: string[] = []
+  // renderToolUseMessage typically shows one or two of these as the
+  // primary argument. tool_name itself is in the "⏺ Bash(...)" chrome,
+  // handled by under-count (the overlay matches it but we don't count it).
+  for (const k of [
+    'command',
+    'pattern',
+    'file_path',
+    'path',
+    'prompt',
+    'description',
+    'query',
+    'url',
+    'skill', // SkillTool
+  ]) {
+    const v = o[k]
+    if (typeof v === 'string') parts.push(v)
+  }
+  // args[] (Tmux/TungstenTool), files[] (SendUserFile) — tool-use
+  // renders the joined array as the primary display. Under-count > skip.
+  for (const k of ['args', 'files']) {
+    const v = o[k]
+    if (Array.isArray(v) && v.every(x => typeof x === 'string')) {
+      parts.push((v as string[]).join(' '))
+    }
+  }
+  return parts.join('\n')
+}
+
+/** Duck-type the tool's native Out for searchable text. Known shapes:
+ *  {stdout,stderr} (Bash/Shell), {content} (Grep), {file:{content}} (Read),
+ *  {filenames:[]} (Grep/Glob), {output} (generic). Falls back to concating
+ *  all top-level string fields — crude but better than indexing model-chatter.
+ *  Empty for unknown shapes: under-count > phantom. */
+export function toolResultSearchText(r: unknown): string {
+  if (!r || typeof r !== 'object') return typeof r === 'string' ? r : ''
+  const o = r as Record<string, unknown>
+  // Known shapes first (common tools).
+  if (typeof o.stdout === 'string') {
+    const err = typeof o.stderr === 'string' ? o.stderr : ''
+    return o.stdout + (err ? '\n' + err : '')
+  }
+  if (
+    o.file &&
+    typeof o.file === 'object' &&
+    typeof (o.file as { content?: unknown }).content === 'string'
+  ) {
+    return (o.file as { content: string }).content
+  }
+  // Known output-field names only. A blind walk would index metadata
+  // the UI doesn't show (rawOutputPath, backgroundTaskId, filePath,
+  // durationMs-as-string). Allowlist the fields tools actually render.
+  // Tools not matching any shape index empty — add them here as found.
+  const parts: string[] = []
+  for (const k of ['content', 'output', 'result', 'text', 'message']) {
+    const v = o[k]
+    if (typeof v === 'string') parts.push(v)
+  }
+  for (const k of ['filenames', 'lines', 'results']) {
+    const v = o[k]
+    if (Array.isArray(v) && v.every(x => typeof x === 'string')) {
+      parts.push((v as string[]).join('\n'))
+    }
+  }
+  return parts.join('\n')
+}

package/utils/treeify.ts

@@ -0,0 +1,170 @@
+import figures from 'figures'
+import { color } from '../components/design-system/color.js'
+import type { Theme, ThemeName } from './theme.js'
+
+export type TreeNode = {
+  [key: string]: TreeNode | string | undefined
+}
+
+export type TreeifyOptions = {
+  showValues?: boolean
+  hideFunctions?: boolean
+  useColors?: boolean
+  themeName?: ThemeName
+  treeCharColors?: {
+    treeChar?: keyof Theme // Color for tree characters (├ └ │)
+    key?: keyof Theme // Color for property names
+    value?: keyof Theme // Color for values
+  }
+}
+
+type TreeCharacters = {
+  branch: string
+  lastBranch: string
+  line: string
+  empty: string
+}
+
+const DEFAULT_TREE_CHARS: TreeCharacters = {
+  branch: figures.lineUpDownRight, // '├'
+  lastBranch: figures.lineUpRight, // '└'
+  line: figures.lineVertical, // '│'
+  empty: ' ',
+}
+
+/**
+ * Custom treeify implementation with Ink theme color support
+ * Based on https://github.com/notatestuser/treeify
+ */
+export function treeify(obj: TreeNode, options: TreeifyOptions = {}): string {
+  const {
+    showValues = true,
+    hideFunctions = false,
+    themeName = 'dark',
+    treeCharColors = {},
+  } = options
+
+  const lines: string[] = []
+  const visited = new WeakSet<object>()
+
+  function colorize(text: string, colorKey?: keyof Theme): string {
+    if (!colorKey) return text
+    return color(colorKey, themeName)(text)
+  }
+
+  function growBranch(
+    node: TreeNode | string,
+    prefix: string,
+    _isLast: boolean,
+    depth: number = 0,
+  ): void {
+    if (typeof node === 'string') {
+      lines.push(prefix + colorize(node, treeCharColors.value))
+      return
+    }
+
+    if (typeof node !== 'object' || node === null) {
+      if (showValues) {
+        const valueStr = String(node)
+        lines.push(prefix + colorize(valueStr, treeCharColors.value))
+      }
+      return
+    }
+
+    // Check for circular references
+    if (visited.has(node)) {
+      lines.push(prefix + colorize('[Circular]', treeCharColors.value))
+      return
+    }
+    visited.add(node)
+
+    const keys = Object.keys(node).filter(key => {
+      const value = node[key]
+      if (hideFunctions && typeof value === 'function') return false
+      return true
+    })
+
+    keys.forEach((key, index) => {
+      const value = node[key]
+      const isLastKey = index === keys.length - 1
+      const nodePrefix = depth === 0 && index === 0 ? '' : prefix
+
+      // Determine which tree character to use
+      const treeChar = isLastKey
+        ? DEFAULT_TREE_CHARS.lastBranch
+        : DEFAULT_TREE_CHARS.branch
+      const coloredTreeChar = colorize(treeChar, treeCharColors.treeChar)
+      const coloredKey =
+        key.trim() === '' ? '' : colorize(key, treeCharColors.key)
+
+      let line =
+        nodePrefix + coloredTreeChar + (coloredKey ? ' ' + coloredKey : '')
+
+      // Check if we should add a colon (not for empty/whitespace keys)
+      const shouldAddColon = key.trim() !== ''
+
+      // Check for circular reference before recursing
+      if (value && typeof value === 'object' && visited.has(value)) {
+        const coloredValue = colorize('[Circular]', treeCharColors.value)
+        lines.push(
+          line + (shouldAddColon ? ': ' : line ? ' ' : '') + coloredValue,
+        )
+      } else if (value && typeof value === 'object' && !Array.isArray(value)) {
+        lines.push(line)
+        // Calculate the continuation prefix for nested items
+        const continuationChar = isLastKey
+          ? DEFAULT_TREE_CHARS.empty
+          : DEFAULT_TREE_CHARS.line
+        const coloredContinuation = colorize(
+          continuationChar,
+          treeCharColors.treeChar,
+        )
+        const nextPrefix = nodePrefix + coloredContinuation + ' '
+        growBranch(value, nextPrefix, isLastKey, depth + 1)
+      } else if (Array.isArray(value)) {
+        // Handle arrays
+        lines.push(
+          line +
+            (shouldAddColon ? ': ' : line ? ' ' : '') +
+            '[Array(' +
+            value.length +
+            ')]',
+        )
+      } else if (showValues) {
+        // Add value if showValues is true
+        const valueStr =
+          typeof value === 'function' ? '[Function]' : String(value)
+        const coloredValue = colorize(valueStr, treeCharColors.value)
+        line += (shouldAddColon ? ': ' : line ? ' ' : '') + coloredValue
+        lines.push(line)
+      } else {
+        lines.push(line)
+      }
+    })
+  }
+
+  // Start growing the tree
+  const keys = Object.keys(obj)
+  if (keys.length === 0) {
+    return colorize('(empty)', treeCharColors.value)
+  }
+
+  // Special case for single empty/whitespace string key
+  if (
+    keys.length === 1 &&
+    keys[0] !== undefined &&
+    keys[0].trim() === '' &&
+    typeof obj[keys[0]] === 'string'
+  ) {
+    const firstKey = keys[0]
+    const coloredTreeChar = colorize(
+      DEFAULT_TREE_CHARS.lastBranch,
+      treeCharColors.treeChar,
+    )
+    const coloredValue = colorize(obj[firstKey] as string, treeCharColors.value)
+    return coloredTreeChar + ' ' + coloredValue
+  }
+
+  growBranch(obj, '', true)
+  return lines.join('\n')
+}

package/utils/truncate.ts

@@ -0,0 +1,179 @@
+// Width-aware truncation/wrapping — needs ink/stringWidth (not leaf-safe).
+
+import { stringWidth } from '../ink/stringWidth.js'
+import { getGraphemeSegmenter } from './intl.js'
+
+/**
+ * Truncates a file path in the middle to preserve both directory context and filename.
+ * Width-aware: uses stringWidth() for correct CJK/emoji measurement.
+ * For example: "src/components/deeply/nested/folder/MyComponent.tsx" becomes
+ * "src/components/…/MyComponent.tsx" when maxLength is 30.
+ *
+ * @param path The file path to truncate
+ * @param maxLength Maximum display width of the result in terminal columns (must be > 0)
+ * @returns The truncated path, or original if it fits within maxLength
+ */
+export function truncatePathMiddle(path: string, maxLength: number): string {
+  // No truncation needed
+  if (stringWidth(path) <= maxLength) {
+    return path
+  }
+
+  // Handle edge case of very small or non-positive maxLength
+  if (maxLength <= 0) {
+    return '…'
+  }
+
+  // Need at least room for "…" + something meaningful
+  if (maxLength < 5) {
+    return truncateToWidth(path, maxLength)
+  }
+
+  // Find the filename (last path segment)
+  const lastSlash = path.lastIndexOf('/')
+  // Include the leading slash in filename for display
+  const filename = lastSlash >= 0 ? path.slice(lastSlash) : path
+  const directory = lastSlash >= 0 ? path.slice(0, lastSlash) : ''
+  const filenameWidth = stringWidth(filename)
+
+  // If filename alone is too long, truncate from start
+  if (filenameWidth >= maxLength - 1) {
+    return truncateStartToWidth(path, maxLength)
+  }
+
+  // Calculate space available for directory prefix
+  // Result format: directory + "…" + filename
+  const availableForDir = maxLength - 1 - filenameWidth // -1 for ellipsis
+
+  if (availableForDir <= 0) {
+    // No room for directory, just show filename (truncated if needed)
+    return truncateStartToWidth(filename, maxLength)
+  }
+
+  // Truncate directory and combine
+  const truncatedDir = truncateToWidthNoEllipsis(directory, availableForDir)
+  return truncatedDir + '…' + filename
+}
+
+/**
+ * Truncates a string to fit within a maximum display width, measured in terminal columns.
+ * Splits on grapheme boundaries to avoid breaking emoji or surrogate pairs.
+ * Appends '…' when truncation occurs.
+ */
+export function truncateToWidth(text: string, maxWidth: number): string {
+  if (stringWidth(text) <= maxWidth) return text
+  if (maxWidth <= 1) return '…'
+  let width = 0
+  let result = ''
+  for (const { segment } of getGraphemeSegmenter().segment(text)) {
+    const segWidth = stringWidth(segment)
+    if (width + segWidth > maxWidth - 1) break
+    result += segment
+    width += segWidth
+  }
+  return result + '…'
+}
+
+/**
+ * Truncates from the start of a string, keeping the tail end.
+ * Prepends '…' when truncation occurs.
+ * Width-aware and grapheme-safe.
+ */
+export function truncateStartToWidth(text: string, maxWidth: number): string {
+  if (stringWidth(text) <= maxWidth) return text
+  if (maxWidth <= 1) return '…'
+  const segments = [...getGraphemeSegmenter().segment(text)]
+  let width = 0
+  let startIdx = segments.length
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const segWidth = stringWidth(segments[i]!.segment)
+    if (width + segWidth > maxWidth - 1) break // -1 for '…'
+    width += segWidth
+    startIdx = i
+  }
+  return (
+    '…' +
+    segments
+      .slice(startIdx)
+      .map(s => s.segment)
+      .join('')
+  )
+}
+
+/**
+ * Truncates a string to fit within a maximum display width, without appending an ellipsis.
+ * Useful when the caller adds its own separator (e.g. middle-truncation with '…' between parts).
+ * Width-aware and grapheme-safe.
+ */
+export function truncateToWidthNoEllipsis(
+  text: string,
+  maxWidth: number,
+): string {
+  if (stringWidth(text) <= maxWidth) return text
+  if (maxWidth <= 0) return ''
+  let width = 0
+  let result = ''
+  for (const { segment } of getGraphemeSegmenter().segment(text)) {
+    const segWidth = stringWidth(segment)
+    if (width + segWidth > maxWidth) break
+    result += segment
+    width += segWidth
+  }
+  return result
+}
+
+/**
+ * Truncates a string to fit within a maximum display width (terminal columns),
+ * splitting on grapheme boundaries to avoid breaking emoji, CJK, or surrogate pairs.
+ * Appends '…' when truncation occurs.
+ * @param str The string to truncate
+ * @param maxWidth Maximum display width in terminal columns
+ * @param singleLine If true, also truncates at the first newline
+ * @returns The truncated string with ellipsis if needed
+ */
+export function truncate(
+  str: string,
+  maxWidth: number,
+  singleLine: boolean = false,
+): string {
+  let result = str
+
+  // If singleLine is true, truncate at first newline
+  if (singleLine) {
+    const firstNewline = str.indexOf('\n')
+    if (firstNewline !== -1) {
+      result = str.substring(0, firstNewline)
+      // Ensure total width including ellipsis doesn't exceed maxWidth
+      if (stringWidth(result) + 1 > maxWidth) {
+        return truncateToWidth(result, maxWidth)
+      }
+      return `${result}…`
+    }
+  }
+
+  if (stringWidth(result) <= maxWidth) {
+    return result
+  }
+  return truncateToWidth(result, maxWidth)
+}
+
+export function wrapText(text: string, width: number): string[] {
+  const lines: string[] = []
+  let currentLine = ''
+  let currentWidth = 0
+
+  for (const { segment } of getGraphemeSegmenter().segment(text)) {
+    const segWidth = stringWidth(segment)
+    if (currentWidth + segWidth <= width) {
+      currentLine += segment
+      currentWidth += segWidth
+    } else {
+      if (currentLine) lines.push(currentLine)
+      currentLine = segment
+      currentWidth = segWidth
+    }
+  }
+
+  if (currentLine) lines.push(currentLine)
+  return lines
+}