@xortex/xcode 3.0.0

package/utils/profilerBase.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared infrastructure for profiler modules (startupProfiler, queryProfiler,
+ * headlessProfiler). All three use the same perf_hooks timeline and the same
+ * line format for detailed reports.
+ */
+
+import type { performance as PerformanceType } from 'perf_hooks'
+import { formatFileSize } from './format.js'
+
+// Lazy-load performance API only when profiling is enabled.
+// Shared across all profilers — perf_hooks.performance is a process-wide singleton.
+let performance: typeof PerformanceType | null = null
+
+export function getPerformance(): typeof PerformanceType {
+  if (!performance) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    performance = require('perf_hooks').performance
+  }
+  return performance!
+}
+
+export function formatMs(ms: number): string {
+  return ms.toFixed(3)
+}
+
+/**
+ * Render a single timeline line in the shared profiler report format:
+ *   [+  total.ms] (+  delta.ms) name [extra] [| RSS: .., Heap: ..]
+ *
+ * totalPad/deltaPad control the padStart width so callers can align columns
+ * based on their expected magnitude (startup uses 8/7, query uses 10/9).
+ */
+export function formatTimelineLine(
+  totalMs: number,
+  deltaMs: number,
+  name: string,
+  memory: NodeJS.MemoryUsage | undefined,
+  totalPad: number,
+  deltaPad: number,
+  extra = '',
+): string {
+  const memInfo = memory
+    ? ` | RSS: ${formatFileSize(memory.rss)}, Heap: ${formatFileSize(memory.heapUsed)}`
+    : ''
+  return `[+${formatMs(totalMs).padStart(totalPad)}ms] (+${formatMs(deltaMs).padStart(deltaPad)}ms) ${name}${extra}${memInfo}`
+}

package/utils/promptCategory.ts

@@ -0,0 +1,49 @@
+import type { QuerySource } from 'src/constants/querySource.js'
+import {
+  DEFAULT_OUTPUT_STYLE_NAME,
+  OUTPUT_STYLE_CONFIG,
+} from '../constants/outputStyles.js'
+import { getSettings_DEPRECATED } from './settings/settings.js'
+
+/**
+ * Determines the prompt category for agent usage.
+ * Used for analytics to track different agent patterns.
+ *
+ * @param agentType - The type/name of the agent
+ * @param isBuiltInAgent - Whether this is a built-in agent or custom
+ * @returns The agent prompt category string
+ */
+export function getQuerySourceForAgent(
+  agentType: string | undefined,
+  isBuiltInAgent: boolean,
+): QuerySource {
+  if (isBuiltInAgent) {
+    // TODO: avoid this cast
+    return agentType
+      ? (`agent:builtin:${agentType}` as QuerySource)
+      : 'agent:default'
+  } else {
+    return 'agent:custom'
+  }
+}
+
+/**
+ * Determines the prompt category based on output style settings.
+ * Used for analytics to track different output style usage.
+ *
+ * @returns The prompt category string or undefined for default
+ */
+export function getQuerySourceForREPL(): QuerySource {
+  const settings = getSettings_DEPRECATED()
+  const style = settings?.outputStyle ?? DEFAULT_OUTPUT_STYLE_NAME
+
+  if (style === DEFAULT_OUTPUT_STYLE_NAME) {
+    return 'repl_main_thread'
+  }
+
+  // All styles in OUTPUT_STYLE_CONFIG are built-in
+  const isBuiltIn = style in OUTPUT_STYLE_CONFIG
+  return isBuiltIn
+    ? (`repl_main_thread:outputStyle:${style}` as QuerySource)
+    : 'repl_main_thread:outputStyle:custom'
+}

package/utils/promptEditor.ts

@@ -0,0 +1,188 @@
+import {
+  expandPastedTextRefs,
+  formatPastedTextRef,
+  getPastedTextRefNumLines,
+} from '../history.js'
+import instances from '../ink/instances.js'
+import type { PastedContent } from './config.js'
+import { classifyGuiEditor, getExternalEditor } from './editor.js'
+import { execSync_DEPRECATED } from './execSyncWrapper.js'
+import { getFsImplementation } from './fsOperations.js'
+import { toIDEDisplayName } from './ide.js'
+import { writeFileSync_DEPRECATED } from './slowOperations.js'
+import { generateTempFilePath } from './tempfile.js'
+
+// Map of editor command overrides (e.g., to add wait flags)
+const EDITOR_OVERRIDES: Record<string, string> = {
+  code: 'code -w', // VS Code: wait for file to be closed
+  subl: 'subl --wait', // Sublime Text: wait for file to be closed
+}
+
+function isGuiEditor(editor: string): boolean {
+  return classifyGuiEditor(editor) !== undefined
+}
+
+export type EditorResult = {
+  content: string | null
+  error?: string
+}
+
+// sync IO: called from sync context (React components, sync command handlers)
+export function editFileInEditor(filePath: string): EditorResult {
+  const fs = getFsImplementation()
+  const inkInstance = instances.get(process.stdout)
+  if (!inkInstance) {
+    throw new Error('Ink instance not found - cannot pause rendering')
+  }
+
+  const editor = getExternalEditor()
+  if (!editor) {
+    return { content: null }
+  }
+
+  try {
+    fs.statSync(filePath)
+  } catch {
+    return { content: null }
+  }
+
+  const useAlternateScreen = !isGuiEditor(editor)
+
+  if (useAlternateScreen) {
+    // Terminal editors (vi, nano, etc.) take over the terminal. Delegate to
+    // Ink's alt-screen-aware handoff so fullscreen mode (where <AlternateScreen>
+    // already entered alt screen) doesn't get knocked back to the main buffer
+    // by a hardcoded ?1049l. enterAlternateScreen() internally calls pause()
+    // and suspendStdin(); exitAlternateScreen() undoes both and resets frame
+    // state so the next render writes from scratch.
+    inkInstance.enterAlternateScreen()
+  } else {
+    // GUI editors (code, subl, etc.) open in a separate window — just pause
+    // Ink and release stdin while they're open.
+    inkInstance.pause()
+    inkInstance.suspendStdin()
+  }
+
+  try {
+    // Use override command if available, otherwise use the editor as-is
+    const editorCommand = EDITOR_OVERRIDES[editor] ?? editor
+    execSync_DEPRECATED(`${editorCommand} "${filePath}"`, {
+      stdio: 'inherit',
+    })
+
+    // Read the edited content
+    const editedContent = fs.readFileSync(filePath, { encoding: 'utf-8' })
+    return { content: editedContent }
+  } catch (err) {
+    if (
+      typeof err === 'object' &&
+      err !== null &&
+      'status' in err &&
+      typeof (err as { status: unknown }).status === 'number'
+    ) {
+      const status = (err as { status: number }).status
+      if (status !== 0) {
+        const editorName = toIDEDisplayName(editor)
+        return {
+          content: null,
+          error: `${editorName} exited with code ${status}`,
+        }
+      }
+    }
+    return { content: null }
+  } finally {
+    if (useAlternateScreen) {
+      inkInstance.exitAlternateScreen()
+    } else {
+      inkInstance.resumeStdin()
+      inkInstance.resume()
+    }
+  }
+}
+
+/**
+ * Re-collapse expanded pasted text by finding content that matches
+ * pastedContents and replacing it with references.
+ */
+function recollapsePastedContent(
+  editedPrompt: string,
+  originalPrompt: string,
+  pastedContents: Record<number, PastedContent>,
+): string {
+  let collapsed = editedPrompt
+
+  // Find pasted content in the edited text and re-collapse it
+  for (const [id, content] of Object.entries(pastedContents)) {
+    if (content.type === 'text') {
+      const pasteId = parseInt(id)
+      const contentStr = content.content
+
+      // Check if this exact content exists in the edited prompt
+      const contentIndex = collapsed.indexOf(contentStr)
+      if (contentIndex !== -1) {
+        // Replace with reference
+        const numLines = getPastedTextRefNumLines(contentStr)
+        const ref = formatPastedTextRef(pasteId, numLines)
+        collapsed =
+          collapsed.slice(0, contentIndex) +
+          ref +
+          collapsed.slice(contentIndex + contentStr.length)
+      }
+    }
+  }
+
+  return collapsed
+}
+
+// sync IO: called from sync context (React components, sync command handlers)
+export function editPromptInEditor(
+  currentPrompt: string,
+  pastedContents?: Record<number, PastedContent>,
+): EditorResult {
+  const fs = getFsImplementation()
+  const tempFile = generateTempFilePath()
+
+  try {
+    // Expand any pasted text references before editing
+    const expandedPrompt = pastedContents
+      ? expandPastedTextRefs(currentPrompt, pastedContents)
+      : currentPrompt
+
+    // Write expanded prompt to temp file
+    writeFileSync_DEPRECATED(tempFile, expandedPrompt, {
+      encoding: 'utf-8',
+      flush: true,
+    })
+
+    // Delegate to editFileInEditor
+    const result = editFileInEditor(tempFile)
+
+    if (result.content === null) {
+      return result
+    }
+
+    // Trim a single trailing newline if present (common editor behavior)
+    let finalContent = result.content
+    if (finalContent.endsWith('\n') && !finalContent.endsWith('\n\n')) {
+      finalContent = finalContent.slice(0, -1)
+    }
+
+    // Re-collapse pasted content if it wasn't edited
+    if (pastedContents) {
+      finalContent = recollapsePastedContent(
+        finalContent,
+        currentPrompt,
+        pastedContents,
+      )
+    }
+
+    return { content: finalContent }
+  } finally {
+    // Clean up temp file
+    try {
+      fs.unlinkSync(tempFile)
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}

package/utils/promptShellExecution.ts

@@ -0,0 +1,183 @@
+import { randomUUID } from 'crypto'
+import type { Tool, ToolUseContext } from '../Tool.js'
+import { BashTool } from '../tools/BashTool/BashTool.js'
+import { logForDebugging } from './debug.js'
+import { errorMessage, MalformedCommandError, ShellError } from './errors.js'
+import type { FrontmatterShell } from './frontmatterParser.js'
+import { createAssistantMessage } from './messages.js'
+import { hasPermissionsToUseTool } from './permissions/permissions.js'
+import { processToolResultBlock } from './toolResultStorage.js'
+
+// Narrow structural slice both BashTool and PowerShellTool satisfy. We can't
+// use the base Tool type: it marks call()'s canUseTool/parentMessage as
+// required, but both concrete tools have them optional and the original code
+// called BashTool.call({ command }, ctx) with just 2 args. We can't use
+// `typeof BashTool` either: BashTool's input schema has fields (e.g.
+// _simulatedSedEdit) that PowerShellTool's does not.
+// NOTE: call() is invoked directly here, bypassing validateInput — any
+// load-bearing check must live in call() itself (see PR #23311).
+type ShellOut = { stdout: string; stderr: string; interrupted: boolean }
+type PromptShellTool = Tool & {
+  call(
+    input: { command: string },
+    context: ToolUseContext,
+  ): Promise<{ data: ShellOut }>
+}
+
+import { isPowerShellToolEnabled } from './shell/shellToolUtils.js'
+
+// Lazy: this file is on the startup import chain (main → commands →
+// loadSkillsDir → here). A static import would load PowerShellTool.ts
+// (and transitively parser.ts, validators, etc.) at startup on all
+// platforms, defeating tools.ts's lazy require. Deferred until the
+// first skill with `shell: powershell` actually runs.
+/* eslint-disable @typescript-eslint/no-require-imports */
+const getPowerShellTool = (() => {
+  let cached: PromptShellTool | undefined
+  return (): PromptShellTool => {
+    if (!cached) {
+      cached = (
+        require('../tools/PowerShellTool/PowerShellTool.js') as typeof import('../tools/PowerShellTool/PowerShellTool.js')
+      ).PowerShellTool
+    }
+    return cached
+  }
+})()
+/* eslint-enable @typescript-eslint/no-require-imports */
+
+// Pattern for code blocks: ```! command ```
+const BLOCK_PATTERN = /```!\s*\n?([\s\S]*?)\n?```/g
+
+// Pattern for inline: !`command`
+// Uses a positive lookbehind to require whitespace or start-of-line before !
+// This prevents false matches inside markdown inline code spans like `!!` or
+// adjacent spans like `foo`!`bar`, and shell variables like $!
+// eslint-disable-next-line custom-rules/no-lookbehind-regex -- gated by text.includes('!`') below (PR#22986)
+const INLINE_PATTERN = /(?<=^|\s)!`([^`]+)`/gm
+
+/**
+ * Parses prompt text and executes any embedded shell commands.
+ * Supports two syntaxes:
+ * - Code blocks: ```! command ```
+ * - Inline: !`command`
+ *
+ * @param shell - Shell to route commands through. Defaults to bash.
+ *   This is *never* read from settings.defaultShell — it comes from .md
+ *   frontmatter (author's choice) or is undefined for built-in commands.
+ *   See docs/design/ps-shell-selection.md §5.3.
+ */
+export async function executeShellCommandsInPrompt(
+  text: string,
+  context: ToolUseContext,
+  slashCommandName: string,
+  shell?: FrontmatterShell,
+): Promise<string> {
+  let result = text
+
+  // Resolve the tool once. `shell === undefined` and `shell === 'bash'` both
+  // hit BashTool. PowerShell only when the runtime gate allows — a skill
+  // author's frontmatter choice doesn't override the user's opt-in/out.
+  const shellTool: PromptShellTool =
+    shell === 'powershell' && isPowerShellToolEnabled()
+      ? getPowerShellTool()
+      : BashTool
+
+  // INLINE_PATTERN's lookbehind is ~100x slower than BLOCK_PATTERN on large
+  // skill content (265µs vs 2µs @ 17KB). 93% of skills have no !` at all,
+  // so gate the expensive scan on a cheap substring check. BLOCK_PATTERN
+  // (```!) doesn't require !` in the text, so it's always scanned.
+  const blockMatches = text.matchAll(BLOCK_PATTERN)
+  const inlineMatches = text.includes('!`') ? text.matchAll(INLINE_PATTERN) : []
+
+  await Promise.all(
+    [...blockMatches, ...inlineMatches].map(async match => {
+      const command = match[1]?.trim()
+      if (command) {
+        try {
+          // Check permissions before executing
+          const permissionResult = await hasPermissionsToUseTool(
+            shellTool,
+            { command },
+            context,
+            createAssistantMessage({ content: [] }),
+            '',
+          )
+
+          if (permissionResult.behavior !== 'allow') {
+            logForDebugging(
+              `Shell command permission check failed for command in ${slashCommandName}: ${command}. Error: ${permissionResult.message}`,
+            )
+            throw new MalformedCommandError(
+              `Shell command permission check failed for pattern "${match[0]}": ${permissionResult.message || 'Permission denied'}`,
+            )
+          }
+
+          const { data } = await shellTool.call({ command }, context)
+          // Reuse the same persistence flow as regular Bash tool calls
+          const toolResultBlock = await processToolResultBlock(
+            shellTool,
+            data,
+            randomUUID(),
+          )
+          // Extract the string content from the block
+          const output =
+            typeof toolResultBlock.content === 'string'
+              ? toolResultBlock.content
+              : formatBashOutput(data.stdout, data.stderr)
+          // Function replacer — String.replace interprets $$, $&, $`, $' in
+          // the replacement string even with a string search pattern. Shell
+          // output (especially PowerShell: $env:PATH, $$, $PSVersionTable)
+          // is arbitrary user data; a bare string arg would corrupt it.
+          result = result.replace(match[0], () => output)
+        } catch (e) {
+          if (e instanceof MalformedCommandError) {
+            throw e
+          }
+          formatBashError(e, match[0])
+        }
+      }
+    }),
+  )
+
+  return result
+}
+
+function formatBashOutput(
+  stdout: string,
+  stderr: string,
+  inline = false,
+): string {
+  const parts: string[] = []
+
+  if (stdout.trim()) {
+    parts.push(stdout.trim())
+  }
+
+  if (stderr.trim()) {
+    if (inline) {
+      parts.push(`[stderr: ${stderr.trim()}]`)
+    } else {
+      parts.push(`[stderr]\n${stderr.trim()}`)
+    }
+  }
+
+  return parts.join(inline ? ' ' : '\n')
+}
+
+function formatBashError(e: unknown, pattern: string, inline = false): never {
+  if (e instanceof ShellError) {
+    if (e.interrupted) {
+      throw new MalformedCommandError(
+        `Shell command interrupted for pattern "${pattern}": [Command interrupted]`,
+      )
+    }
+    const output = formatBashOutput(e.stdout, e.stderr, inline)
+    throw new MalformedCommandError(
+      `Shell command failed for pattern "${pattern}": ${output}`,
+    )
+  }
+
+  const message = errorMessage(e)
+  const formatted = inline ? `[Error: ${message}]` : `[Error]\n${message}`
+  throw new MalformedCommandError(formatted)
+}