@xortex/xcode 3.0.0

package/utils/cliHighlight.ts

@@ -0,0 +1,54 @@
+// highlight.js's type defs carry `/// <reference lib="dom" />`. SSETransport,
+// mcp/client, ssh, dumpPrompts use DOM types (TextDecodeOptions, RequestInfo)
+// that only typecheck because this file's `typeof import('highlight.js')` pulls
+// lib.dom in. tsconfig has lib: ["ESNext"] only — fixing the actual DOM-type
+// deps is a separate sweep; this ref preserves the status quo.
+/// <reference lib="dom" />
+
+import { extname } from 'path'
+
+export type CliHighlight = {
+  highlight: typeof import('cli-highlight').highlight
+  supportsLanguage: typeof import('cli-highlight').supportsLanguage
+}
+
+// One promise shared by Fallback.tsx, markdown.ts, events.ts, getLanguageName.
+// The highlight.js import piggybacks: cli-highlight has already pulled it into
+// the module cache, so the second import() is a cache hit — no extra bytes
+// faulted in.
+let cliHighlightPromise: Promise<CliHighlight | null> | undefined
+
+let loadedGetLanguage: typeof import('highlight.js').getLanguage | undefined
+
+async function loadCliHighlight(): Promise<CliHighlight | null> {
+  try {
+    const cliHighlight = await import('cli-highlight')
+    // cache hit — cli-highlight already loaded highlight.js
+    const highlightJs = await import('highlight.js')
+    loadedGetLanguage = highlightJs.getLanguage
+    return {
+      highlight: cliHighlight.highlight,
+      supportsLanguage: cliHighlight.supportsLanguage,
+    }
+  } catch {
+    return null
+  }
+}
+
+export function getCliHighlightPromise(): Promise<CliHighlight | null> {
+  cliHighlightPromise ??= loadCliHighlight()
+  return cliHighlightPromise
+}
+
+/**
+ * eg. "foo/bar.ts" → "TypeScript". Awaits the shared cli-highlight load,
+ * then reads highlight.js's language registry. All callers are telemetry
+ * (OTel counter attributes, permission-dialog unary events) — none block
+ * on this, they fire-and-forget or the consumer already handles Promise<string>.
+ */
+export async function getLanguageName(file_path: string): Promise<string> {
+  await getCliHighlightPromise()
+  const ext = extname(file_path).slice(1)
+  if (!ext) return 'unknown'
+  return loadedGetLanguage?.(ext)?.name ?? 'unknown'
+}

package/utils/codeIndexing.ts

@@ -0,0 +1,206 @@
+/**
+ * Utility functions for detecting code indexing tool usage.
+ *
+ * Tracks usage of common code indexing solutions like Sourcegraph, Cody, etc.
+ * both via CLI commands and MCP server integrations.
+ */
+
+/**
+ * Known code indexing tool identifiers.
+ * These are the normalized names used in analytics events.
+ */
+export type CodeIndexingTool =
+  // Code search engines
+  | 'sourcegraph'
+  | 'hound'
+  | 'seagoat'
+  | 'bloop'
+  | 'gitloop'
+  // AI coding assistants with indexing
+  | 'cody'
+  | 'aider'
+  | 'continue'
+  | 'github-copilot'
+  | 'cursor'
+  | 'tabby'
+  | 'codeium'
+  | 'tabnine'
+  | 'augment'
+  | 'windsurf'
+  | 'aide'
+  | 'pieces'
+  | 'qodo'
+  | 'amazon-q'
+  | 'gemini'
+  // MCP code indexing servers
+  | 'claude-context'
+  | 'code-index-mcp'
+  | 'local-code-search'
+  | 'autodev-codebase'
+  // Context providers
+  | 'openctx'
+
+/**
+ * Mapping of CLI command prefixes to code indexing tools.
+ * The key is the command name (first word of the command).
+ */
+const CLI_COMMAND_MAPPING: Record<string, CodeIndexingTool> = {
+  // Sourcegraph ecosystem
+  src: 'sourcegraph',
+  cody: 'cody',
+  // AI coding assistants
+  aider: 'aider',
+  tabby: 'tabby',
+  tabnine: 'tabnine',
+  augment: 'augment',
+  pieces: 'pieces',
+  qodo: 'qodo',
+  aide: 'aide',
+  // Code search tools
+  hound: 'hound',
+  seagoat: 'seagoat',
+  bloop: 'bloop',
+  gitloop: 'gitloop',
+  // Cloud provider AI assistants
+  q: 'amazon-q',
+  gemini: 'gemini',
+}
+
+/**
+ * Mapping of MCP server name patterns to code indexing tools.
+ * Patterns are matched case-insensitively against the server name.
+ */
+const MCP_SERVER_PATTERNS: Array<{
+  pattern: RegExp
+  tool: CodeIndexingTool
+}> = [
+  // Sourcegraph ecosystem
+  { pattern: /^sourcegraph$/i, tool: 'sourcegraph' },
+  { pattern: /^cody$/i, tool: 'cody' },
+  { pattern: /^openctx$/i, tool: 'openctx' },
+  // AI coding assistants
+  { pattern: /^aider$/i, tool: 'aider' },
+  { pattern: /^continue$/i, tool: 'continue' },
+  { pattern: /^github[-_]?copilot$/i, tool: 'github-copilot' },
+  { pattern: /^copilot$/i, tool: 'github-copilot' },
+  { pattern: /^cursor$/i, tool: 'cursor' },
+  { pattern: /^tabby$/i, tool: 'tabby' },
+  { pattern: /^codeium$/i, tool: 'codeium' },
+  { pattern: /^tabnine$/i, tool: 'tabnine' },
+  { pattern: /^augment[-_]?code$/i, tool: 'augment' },
+  { pattern: /^augment$/i, tool: 'augment' },
+  { pattern: /^windsurf$/i, tool: 'windsurf' },
+  { pattern: /^aide$/i, tool: 'aide' },
+  { pattern: /^codestory$/i, tool: 'aide' },
+  { pattern: /^pieces$/i, tool: 'pieces' },
+  { pattern: /^qodo$/i, tool: 'qodo' },
+  { pattern: /^amazon[-_]?q$/i, tool: 'amazon-q' },
+  { pattern: /^gemini[-_]?code[-_]?assist$/i, tool: 'gemini' },
+  { pattern: /^gemini$/i, tool: 'gemini' },
+  // Code search tools
+  { pattern: /^hound$/i, tool: 'hound' },
+  { pattern: /^seagoat$/i, tool: 'seagoat' },
+  { pattern: /^bloop$/i, tool: 'bloop' },
+  { pattern: /^gitloop$/i, tool: 'gitloop' },
+  // MCP code indexing servers
+  { pattern: /^claude[-_]?context$/i, tool: 'claude-context' },
+  { pattern: /^code[-_]?index[-_]?mcp$/i, tool: 'code-index-mcp' },
+  { pattern: /^code[-_]?index$/i, tool: 'code-index-mcp' },
+  { pattern: /^local[-_]?code[-_]?search$/i, tool: 'local-code-search' },
+  { pattern: /^codebase$/i, tool: 'autodev-codebase' },
+  { pattern: /^autodev[-_]?codebase$/i, tool: 'autodev-codebase' },
+  { pattern: /^code[-_]?context$/i, tool: 'claude-context' },
+]
+
+/**
+ * Detects if a bash command is using a code indexing CLI tool.
+ *
+ * @param command - The full bash command string
+ * @returns The code indexing tool identifier, or undefined if not a code indexing command
+ *
+ * @example
+ * detectCodeIndexingFromCommand('src search "pattern"') // returns 'sourcegraph'
+ * detectCodeIndexingFromCommand('cody chat --message "help"') // returns 'cody'
+ * detectCodeIndexingFromCommand('ls -la') // returns undefined
+ */
+export function detectCodeIndexingFromCommand(
+  command: string,
+): CodeIndexingTool | undefined {
+  // Extract the first word (command name)
+  const trimmed = command.trim()
+  const firstWord = trimmed.split(/\s+/)[0]?.toLowerCase()
+
+  if (!firstWord) {
+    return undefined
+  }
+
+  // Check for npx/bunx prefixed commands
+  if (firstWord === 'npx' || firstWord === 'bunx') {
+    const secondWord = trimmed.split(/\s+/)[1]?.toLowerCase()
+    if (secondWord && secondWord in CLI_COMMAND_MAPPING) {
+      return CLI_COMMAND_MAPPING[secondWord]
+    }
+  }
+
+  return CLI_COMMAND_MAPPING[firstWord]
+}
+
+/**
+ * Detects if an MCP tool is from a code indexing server.
+ *
+ * @param toolName - The MCP tool name (format: mcp__serverName__toolName)
+ * @returns The code indexing tool identifier, or undefined if not a code indexing tool
+ *
+ * @example
+ * detectCodeIndexingFromMcpTool('mcp__sourcegraph__search') // returns 'sourcegraph'
+ * detectCodeIndexingFromMcpTool('mcp__cody__chat') // returns 'cody'
+ * detectCodeIndexingFromMcpTool('mcp__filesystem__read') // returns undefined
+ */
+export function detectCodeIndexingFromMcpTool(
+  toolName: string,
+): CodeIndexingTool | undefined {
+  // MCP tool names follow the format: mcp__serverName__toolName
+  if (!toolName.startsWith('mcp__')) {
+    return undefined
+  }
+
+  const parts = toolName.split('__')
+  if (parts.length < 3) {
+    return undefined
+  }
+
+  const serverName = parts[1]
+  if (!serverName) {
+    return undefined
+  }
+
+  for (const { pattern, tool } of MCP_SERVER_PATTERNS) {
+    if (pattern.test(serverName)) {
+      return tool
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Detects if an MCP server name corresponds to a code indexing tool.
+ *
+ * @param serverName - The MCP server name
+ * @returns The code indexing tool identifier, or undefined if not a code indexing server
+ *
+ * @example
+ * detectCodeIndexingFromMcpServerName('sourcegraph') // returns 'sourcegraph'
+ * detectCodeIndexingFromMcpServerName('filesystem') // returns undefined
+ */
+export function detectCodeIndexingFromMcpServerName(
+  serverName: string,
+): CodeIndexingTool | undefined {
+  for (const { pattern, tool } of MCP_SERVER_PATTERNS) {
+    if (pattern.test(serverName)) {
+      return tool
+    }
+  }
+
+  return undefined
+}

package/utils/collapseBackgroundBashNotifications.ts

@@ -0,0 +1,84 @@
+import {
+  STATUS_TAG,
+  SUMMARY_TAG,
+  TASK_NOTIFICATION_TAG,
+} from '../constants/xml.js'
+import { BACKGROUND_BASH_SUMMARY_PREFIX } from '../tasks/LocalShellTask/LocalShellTask.js'
+import type {
+  NormalizedUserMessage,
+  RenderableMessage,
+} from '../types/message.js'
+import { isFullscreenEnvEnabled } from './fullscreen.js'
+import { extractTag } from './messages.js'
+
+function isCompletedBackgroundBash(
+  msg: RenderableMessage,
+): msg is NormalizedUserMessage {
+  if (msg.type !== 'user') return false
+  const content = msg.message.content[0]
+  if (content?.type !== 'text') return false
+  if (!content.text.includes(`<${TASK_NOTIFICATION_TAG}`)) return false
+  // Only collapse successful completions — failed/killed stay visible individually.
+  if (extractTag(content.text, STATUS_TAG) !== 'completed') return false
+  // The prefix constant distinguishes bash-kind LocalShellTask completions from
+  // agent/workflow/monitor notifications. Monitor-kind completions have their
+  // own summary wording and deliberately don't collapse here.
+  return (
+    extractTag(content.text, SUMMARY_TAG)?.startsWith(
+      BACKGROUND_BASH_SUMMARY_PREFIX,
+    ) ?? false
+  )
+}
+
+/**
+ * Collapses consecutive completed-background-bash task-notifications into a
+ * single synthetic "N background commands completed" notification. Failed/killed
+ * tasks and agent/workflow notifications are left alone. Monitor stream
+ * events (enqueueStreamEvent) have no <status> tag and never match.
+ *
+ * Pass-through in verbose mode so ctrl+O shows each completion.
+ */
+export function collapseBackgroundBashNotifications(
+  messages: RenderableMessage[],
+  verbose: boolean,
+): RenderableMessage[] {
+  if (!isFullscreenEnvEnabled()) return messages
+  if (verbose) return messages
+
+  const result: RenderableMessage[] = []
+  let i = 0
+
+  while (i < messages.length) {
+    const msg = messages[i]!
+    if (isCompletedBackgroundBash(msg)) {
+      let count = 0
+      while (i < messages.length && isCompletedBackgroundBash(messages[i]!)) {
+        count++
+        i++
+      }
+      if (count === 1) {
+        result.push(msg)
+      } else {
+        // Synthesize a task-notification that UserAgentNotificationMessage
+        // already knows how to render — no new renderer needed.
+        result.push({
+          ...msg,
+          message: {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: `<${TASK_NOTIFICATION_TAG}><${STATUS_TAG}>completed</${STATUS_TAG}><${SUMMARY_TAG}>${count} background commands completed</${SUMMARY_TAG}></${TASK_NOTIFICATION_TAG}>`,
+              },
+            ],
+          },
+        })
+      }
+    } else {
+      result.push(msg)
+      i++
+    }
+  }
+
+  return result
+}

package/utils/collapseHookSummaries.ts

@@ -0,0 +1,59 @@
+import type {
+  RenderableMessage,
+  SystemStopHookSummaryMessage,
+} from '../types/message.js'
+
+function isLabeledHookSummary(
+  msg: RenderableMessage,
+): msg is SystemStopHookSummaryMessage {
+  return (
+    msg.type === 'system' &&
+    msg.subtype === 'stop_hook_summary' &&
+    msg.hookLabel !== undefined
+  )
+}
+
+/**
+ * Collapses consecutive hook summary messages with the same hookLabel
+ * (e.g. PostToolUse) into a single summary. This happens when parallel
+ * tool calls each emit their own hook summary.
+ */
+export function collapseHookSummaries(
+  messages: RenderableMessage[],
+): RenderableMessage[] {
+  const result: RenderableMessage[] = []
+  let i = 0
+
+  while (i < messages.length) {
+    const msg = messages[i]!
+    if (isLabeledHookSummary(msg)) {
+      const label = msg.hookLabel
+      const group: SystemStopHookSummaryMessage[] = []
+      while (i < messages.length) {
+        const next = messages[i]!
+        if (!isLabeledHookSummary(next) || next.hookLabel !== label) break
+        group.push(next)
+        i++
+      }
+      if (group.length === 1) {
+        result.push(msg)
+      } else {
+        result.push({
+          ...msg,
+          hookCount: group.reduce((sum, m) => sum + m.hookCount, 0),
+          hookInfos: group.flatMap(m => m.hookInfos),
+          hookErrors: group.flatMap(m => m.hookErrors),
+          preventedContinuation: group.some(m => m.preventedContinuation),
+          hasOutput: group.some(m => m.hasOutput),
+          // Parallel tool calls' hooks overlap; max is closest to wall-clock.
+          totalDurationMs: Math.max(...group.map(m => m.totalDurationMs ?? 0)),
+        })
+      }
+    } else {
+      result.push(msg)
+      i++
+    }
+  }
+
+  return result
+}