@xortex/xcode 3.0.0

package/utils/tempfile.ts

@@ -0,0 +1,31 @@
+import { createHash, randomUUID } from 'crypto'
+import { tmpdir } from 'os'
+import { join } from 'path'
+
+/**
+ * Generate a temporary file path.
+ *
+ * @param prefix Optional prefix for the temp file name
+ * @param extension Optional file extension (defaults to '.md')
+ * @param options.contentHash When provided, the identifier is derived from a
+ *   SHA-256 hash of this string (first 16 hex chars). This produces a path
+ *   that is stable across process boundaries — any process with the same
+ *   content will get the same path. Use this when the path ends up in content
+ *   sent to the Anthropic API (e.g., sandbox deny lists in tool descriptions),
+ *   because a random UUID would change on every subprocess spawn and
+ *   invalidate the prompt cache prefix.
+ * @returns Temp file path
+ */
+export function generateTempFilePath(
+  prefix: string = 'claude-prompt',
+  extension: string = '.md',
+  options?: { contentHash?: string },
+): string {
+  const id = options?.contentHash
+    ? createHash('sha256')
+        .update(options.contentHash)
+        .digest('hex')
+        .slice(0, 16)
+    : randomUUID()
+  return join(tmpdir(), `${prefix}-${id}${extension}`)
+}

package/utils/terminal.ts

@@ -0,0 +1,131 @@
+import chalk from 'chalk'
+import { ctrlOToExpand } from '../components/CtrlOToExpand.js'
+import { stringWidth } from '../ink/stringWidth.js'
+import sliceAnsi from './sliceAnsi.js'
+
+// Text rendering utilities for terminal display
+const MAX_LINES_TO_SHOW = 3
+// Account for MessageResponse prefix ("  ⎿ " = 5 chars) + parent width
+// reduction (columns - 5 in tool result rendering)
+const PADDING_TO_PREVENT_OVERFLOW = 10
+
+/**
+ * Inserts newlines in a string to wrap it at the specified width.
+ * Uses ANSI-aware slicing to avoid splitting escape sequences.
+ * @param text The text to wrap.
+ * @param wrapWidth The width at which to wrap lines (in visible characters).
+ * @returns The wrapped text.
+ */
+function wrapText(
+  text: string,
+  wrapWidth: number,
+): { aboveTheFold: string; remainingLines: number } {
+  const lines = text.split('\n')
+  const wrappedLines: string[] = []
+
+  for (const line of lines) {
+    const visibleWidth = stringWidth(line)
+    if (visibleWidth <= wrapWidth) {
+      wrappedLines.push(line.trimEnd())
+    } else {
+      // Break long lines into chunks of wrapWidth visible characters
+      // using ANSI-aware slicing to preserve escape sequences
+      let position = 0
+      while (position < visibleWidth) {
+        const chunk = sliceAnsi(line, position, position + wrapWidth)
+        wrappedLines.push(chunk.trimEnd())
+        position += wrapWidth
+      }
+    }
+  }
+
+  const remainingLines = wrappedLines.length - MAX_LINES_TO_SHOW
+
+  // If there's only 1 line after the fold, show it directly
+  // instead of showing "... +1 line (ctrl+o to expand)"
+  if (remainingLines === 1) {
+    return {
+      aboveTheFold: wrappedLines
+        .slice(0, MAX_LINES_TO_SHOW + 1)
+        .join('\n')
+        .trimEnd(),
+      remainingLines: 0, // All lines are shown, nothing remaining
+    }
+  }
+
+  // Otherwise show the standard MAX_LINES_TO_SHOW
+  return {
+    aboveTheFold: wrappedLines.slice(0, MAX_LINES_TO_SHOW).join('\n').trimEnd(),
+    remainingLines: Math.max(0, remainingLines),
+  }
+}
+
+/**
+ * Renders the content with line-based truncation for terminal display.
+ * If the content exceeds the maximum number of lines, it truncates the content
+ * and adds a message indicating the number of additional lines.
+ * @param content The content to render.
+ * @param terminalWidth Terminal width for wrapping lines.
+ * @returns The rendered content with truncation if needed.
+ */
+export function renderTruncatedContent(
+  content: string,
+  terminalWidth: number,
+  suppressExpandHint = false,
+): string {
+  const trimmedContent = content.trimEnd()
+  if (!trimmedContent) {
+    return ''
+  }
+
+  const wrapWidth = Math.max(terminalWidth - PADDING_TO_PREVENT_OVERFLOW, 10)
+
+  // Only process enough content for the visible lines. Avoids O(n) wrapping
+  // on huge outputs (e.g. 64MB binary dumps that cause 382K-row screens).
+  const maxChars = MAX_LINES_TO_SHOW * wrapWidth * 4
+  const preTruncated = trimmedContent.length > maxChars
+  const contentForWrapping = preTruncated
+    ? trimmedContent.slice(0, maxChars)
+    : trimmedContent
+
+  const { aboveTheFold, remainingLines } = wrapText(
+    contentForWrapping,
+    wrapWidth,
+  )
+
+  const estimatedRemaining = preTruncated
+    ? Math.max(
+        remainingLines,
+        Math.ceil(trimmedContent.length / wrapWidth) - MAX_LINES_TO_SHOW,
+      )
+    : remainingLines
+
+  return [
+    aboveTheFold,
+    estimatedRemaining > 0
+      ? chalk.dim(
+          `… +${estimatedRemaining} lines${suppressExpandHint ? '' : ` ${ctrlOToExpand()}`}`,
+        )
+      : '',
+  ]
+    .filter(Boolean)
+    .join('\n')
+}
+
+/** Fast check: would OutputLine truncate this content? Counts raw newlines
+ *  only (ignores terminal-width wrapping), so it may return false for a single
+ *  very long line that wraps past 3 visual rows — acceptable, since the common
+ *  case is multi-line output. */
+export function isOutputLineTruncated(content: string): boolean {
+  let pos = 0
+  // Need more than MAX_LINES_TO_SHOW newlines (content fills > 3 lines).
+  // The +1 accounts for wrapText showing an extra line when remainingLines==1.
+  for (let i = 0; i <= MAX_LINES_TO_SHOW; i++) {
+    pos = content.indexOf('\n', pos)
+    if (pos === -1) return false
+    pos++
+  }
+  // A trailing newline is a terminator, not a new line — match
+  // renderTruncatedContent's trimEnd() behavior.
+  return pos < content.length
+}

package/utils/terminalPanel.ts

@@ -0,0 +1,191 @@
+/**
+ * Built-in terminal panel toggled with Meta+J.
+ *
+ * Uses tmux for shell persistence: a separate tmux server with a per-instance
+ * socket (e.g., "claude-panel-a1b2c3d4") holds the shell session. Each Claude
+ * Code instance gets its own isolated terminal panel that persists within the
+ * session but is destroyed when the instance exits.
+ *
+ * Meta+J is bound to detach-client inside tmux, so pressing it returns to
+ * Claude Code while the shell keeps running. Next toggle re-attaches to the
+ * same session.
+ *
+ * When tmux is not available, falls back to a non-persistent shell via spawnSync.
+ *
+ * Uses the same suspend-Ink pattern as the external editor (promptEditor.ts).
+ */
+
+import { spawn, spawnSync } from 'child_process'
+import { getSessionId } from '../bootstrap/state.js'
+import instances from '../ink/instances.js'
+import { registerCleanup } from './cleanupRegistry.js'
+import { pwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+
+const TMUX_SESSION = 'panel'
+
+/**
+ * Get the tmux socket name for the terminal panel.
+ * Uses a unique socket per Claude Code instance (based on session ID)
+ * so that each instance has its own isolated terminal panel.
+ */
+export function getTerminalPanelSocket(): string {
+  // Use first 8 chars of session UUID for uniqueness while keeping name short
+  const sessionId = getSessionId()
+  return `claude-panel-${sessionId.slice(0, 8)}`
+}
+
+let instance: TerminalPanel | undefined
+
+/**
+ * Return the singleton TerminalPanel, creating it lazily on first use.
+ */
+export function getTerminalPanel(): TerminalPanel {
+  if (!instance) {
+    instance = new TerminalPanel()
+  }
+  return instance
+}
+
+class TerminalPanel {
+  private hasTmux: boolean | undefined
+  private cleanupRegistered = false
+
+  // ── public API ────────────────────────────────────────────────────
+
+  toggle(): void {
+    this.showShell()
+  }
+
+  // ── tmux helpers ──────────────────────────────────────────────────
+
+  private checkTmux(): boolean {
+    if (this.hasTmux !== undefined) return this.hasTmux
+    const result = spawnSync('tmux', ['-V'], { encoding: 'utf-8' })
+    this.hasTmux = result.status === 0
+    if (!this.hasTmux) {
+      logForDebugging(
+        'Terminal panel: tmux not found, falling back to non-persistent shell',
+      )
+    }
+    return this.hasTmux
+  }
+
+  private hasSession(): boolean {
+    const result = spawnSync(
+      'tmux',
+      ['-L', getTerminalPanelSocket(), 'has-session', '-t', TMUX_SESSION],
+      { encoding: 'utf-8' },
+    )
+    return result.status === 0
+  }
+
+  private createSession(): boolean {
+    const shell = process.env.SHELL || '/bin/bash'
+    const cwd = pwd()
+    const socket = getTerminalPanelSocket()
+
+    const result = spawnSync(
+      'tmux',
+      [
+        '-L',
+        socket,
+        'new-session',
+        '-d',
+        '-s',
+        TMUX_SESSION,
+        '-c',
+        cwd,
+        shell,
+        '-l',
+      ],
+      { encoding: 'utf-8' },
+    )
+
+    if (result.status !== 0) {
+      logForDebugging(
+        `Terminal panel: failed to create tmux session: ${result.stderr}`,
+      )
+      return false
+    }
+
+    // Bind Meta+J (toggles back to Claude Code from inside the terminal)
+    // and configure the status bar hint. Chained with ';' to collapse
+    // 5 spawnSync calls into 1.
+    // biome-ignore format: one tmux command per line
+    spawnSync('tmux', [
+      '-L', socket,
+      'bind-key', '-n', 'M-j', 'detach-client', ';',
+      'set-option', '-g', 'status-style', 'bg=default', ';',
+      'set-option', '-g', 'status-left', '', ';',
+      'set-option', '-g', 'status-right', ' Alt+J to return to Claude ', ';',
+      'set-option', '-g', 'status-right-style', 'fg=brightblack',
+    ])
+
+    if (!this.cleanupRegistered) {
+      this.cleanupRegistered = true
+      registerCleanup(async () => {
+        // Detached async spawn — spawnSync here would block the event loop
+        // and serialize the entire cleanup Promise.all in gracefulShutdown.
+        // .on('error') swallows ENOENT if tmux disappears between session
+        // creation and cleanup — prevents spurious uncaughtException noise.
+        spawn('tmux', ['-L', socket, 'kill-server'], {
+          detached: true,
+          stdio: 'ignore',
+        })
+          .on('error', () => {})
+          .unref()
+      })
+    }
+
+    return true
+  }
+
+  private attachSession(): void {
+    spawnSync(
+      'tmux',
+      ['-L', getTerminalPanelSocket(), 'attach-session', '-t', TMUX_SESSION],
+      { stdio: 'inherit' },
+    )
+  }
+
+  // ── show shell ────────────────────────────────────────────────────
+
+  private showShell(): void {
+    const inkInstance = instances.get(process.stdout)
+    if (!inkInstance) {
+      logForDebugging('Terminal panel: no Ink instance found, aborting')
+      return
+    }
+
+    inkInstance.enterAlternateScreen()
+    try {
+      if (this.checkTmux() && this.ensureSession()) {
+        this.attachSession()
+      } else {
+        this.runShellDirect()
+      }
+    } finally {
+      inkInstance.exitAlternateScreen()
+    }
+  }
+
+  // ── helpers ───────────────────────────────────────────────────────
+
+  /** Ensure a tmux session exists, creating one if needed. */
+  private ensureSession(): boolean {
+    if (this.hasSession()) return true
+    return this.createSession()
+  }
+
+  /** Fallback when tmux is not available — runs a non-persistent shell. */
+  private runShellDirect(): void {
+    const shell = process.env.SHELL || '/bin/bash'
+    const cwd = pwd()
+    spawnSync(shell, ['-i', '-l'], {
+      stdio: 'inherit',
+      cwd,
+      env: process.env,
+    })
+  }
+}

package/utils/textHighlighting.ts

@@ -0,0 +1,166 @@
+import {
+  type AnsiCode,
+  ansiCodesToString,
+  reduceAnsiCodes,
+  type Token,
+  tokenize,
+  undoAnsiCodes,
+} from '@alcalzone/ansi-tokenize'
+import type { Theme } from './theme.js'
+
+export type TextHighlight = {
+  start: number
+  end: number
+  color: keyof Theme | undefined
+  dimColor?: boolean
+  inverse?: boolean
+  shimmerColor?: keyof Theme
+  priority: number
+}
+
+export type TextSegment = {
+  text: string
+  start: number
+  highlight?: TextHighlight
+}
+
+export function segmentTextByHighlights(
+  text: string,
+  highlights: TextHighlight[],
+): TextSegment[] {
+  if (highlights.length === 0) {
+    return [{ text, start: 0 }]
+  }
+
+  const sortedHighlights = [...highlights].sort((a, b) => {
+    if (a.start !== b.start) return a.start - b.start
+    return b.priority - a.priority
+  })
+
+  const resolvedHighlights: TextHighlight[] = []
+  const usedRanges: Array<{ start: number; end: number }> = []
+
+  for (const highlight of sortedHighlights) {
+    if (highlight.start === highlight.end) continue
+
+    const overlaps = usedRanges.some(
+      range =>
+        (highlight.start >= range.start && highlight.start < range.end) ||
+        (highlight.end > range.start && highlight.end <= range.end) ||
+        (highlight.start <= range.start && highlight.end >= range.end),
+    )
+
+    if (!overlaps) {
+      resolvedHighlights.push(highlight)
+      usedRanges.push({ start: highlight.start, end: highlight.end })
+    }
+  }
+
+  return new HighlightSegmenter(text).segment(resolvedHighlights)
+}
+
+class HighlightSegmenter {
+  private readonly tokens: Token[]
+  // Two position systems: "visible" (what the user sees, excluding ANSI codes)
+  // and "string" (raw positions including ANSI codes for substring extraction)
+  private visiblePos = 0
+  private stringPos = 0
+  private tokenIdx = 0
+  private charIdx = 0 // offset within current text token (for partial consumption)
+  private codes: AnsiCode[] = []
+
+  constructor(private readonly text: string) {
+    this.tokens = tokenize(text)
+  }
+
+  segment(highlights: TextHighlight[]): TextSegment[] {
+    const segments: TextSegment[] = []
+
+    for (const highlight of highlights) {
+      const before = this.segmentTo(highlight.start)
+      if (before) segments.push(before)
+
+      const highlighted = this.segmentTo(highlight.end)
+      if (highlighted) {
+        highlighted.highlight = highlight
+        segments.push(highlighted)
+      }
+    }
+
+    const after = this.segmentTo(Infinity)
+    if (after) segments.push(after)
+
+    return segments
+  }
+
+  private segmentTo(targetVisiblePos: number): TextSegment | null {
+    if (
+      this.tokenIdx >= this.tokens.length ||
+      targetVisiblePos <= this.visiblePos
+    ) {
+      return null
+    }
+
+    const visibleStart = this.visiblePos
+
+    // Consume leading ANSI codes before first visible char
+    while (this.tokenIdx < this.tokens.length) {
+      const token = this.tokens[this.tokenIdx]!
+      if (token.type !== 'ansi') break
+      this.codes.push(token)
+      this.stringPos += token.code.length
+      this.tokenIdx++
+    }
+
+    const stringStart = this.stringPos
+    const codesStart = [...this.codes]
+
+    // Advance through tokens until we reach target
+    while (
+      this.visiblePos < targetVisiblePos &&
+      this.tokenIdx < this.tokens.length
+    ) {
+      const token = this.tokens[this.tokenIdx]!
+
+      if (token.type === 'ansi') {
+        this.codes.push(token)
+        this.stringPos += token.code.length
+        this.tokenIdx++
+      } else {
+        const charsNeeded = targetVisiblePos - this.visiblePos
+        const charsAvailable = token.value.length - this.charIdx
+        const charsToTake = Math.min(charsNeeded, charsAvailable)
+
+        this.stringPos += charsToTake
+        this.visiblePos += charsToTake
+        this.charIdx += charsToTake
+
+        if (this.charIdx >= token.value.length) {
+          this.tokenIdx++
+          this.charIdx = 0
+        }
+      }
+    }
+
+    // Empty segment (can occur when only trailing ANSI codes remain)
+    if (this.stringPos === stringStart) {
+      return null
+    }
+
+    const prefixCodes = reduceCodes(codesStart)
+    const suffixCodes = reduceCodes(this.codes)
+    this.codes = suffixCodes
+
+    const prefix = ansiCodesToString(prefixCodes)
+    const suffix = ansiCodesToString(undoAnsiCodes(suffixCodes))
+
+    return {
+      text: prefix + this.text.substring(stringStart, this.stringPos) + suffix,
+      start: visibleStart,
+    }
+  }
+}
+
+function reduceCodes(codes: AnsiCode[]): AnsiCode[] {
+  return reduceAnsiCodes(codes).filter(c => c.code !== c.endCode)
+}