@xortex/xcode 3.0.0

package/utils/highlightMatch.tsx

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { Text } from '../ink.js';
+
+/**
+ * Inverse-highlight every occurrence of `query` in `text` (case-insensitive).
+ * Used by search dialogs to show where the query matched in result rows
+ * and preview panes.
+ */
+export function highlightMatch(text: string, query: string): React.ReactNode {
+  if (!query) return text;
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  const parts: React.ReactNode[] = [];
+  let offset = 0;
+  let idx = textLower.indexOf(queryLower, offset);
+  if (idx === -1) return text;
+  while (idx !== -1) {
+    if (idx > offset) parts.push(text.slice(offset, idx));
+    parts.push(<Text key={idx} inverse>
+        {text.slice(idx, idx + query.length)}
+      </Text>);
+    offset = idx + query.length;
+    idx = textLower.indexOf(queryLower, offset);
+  }
+  if (offset < text.length) parts.push(text.slice(offset));
+  return <>{parts}</>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIlRleHQiLCJoaWdobGlnaHRNYXRjaCIsInRleHQiLCJxdWVyeSIsIlJlYWN0Tm9kZSIsInF1ZXJ5TG93ZXIiLCJ0b0xvd2VyQ2FzZSIsInRleHRMb3dlciIsInBhcnRzIiwib2Zmc2V0IiwiaWR4IiwiaW5kZXhPZiIsInB1c2giLCJzbGljZSIsImxlbmd0aCJdLCJzb3VyY2VzIjpbImhpZ2hsaWdodE1hdGNoLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBSZWFjdCBmcm9tICdyZWFjdCdcbmltcG9ydCB7IFRleHQgfSBmcm9tICcuLi9pbmsuanMnXG5cbi8qKlxuICogSW52ZXJzZS1oaWdobGlnaHQgZXZlcnkgb2NjdXJyZW5jZSBvZiBgcXVlcnlgIGluIGB0ZXh0YCAoY2FzZS1pbnNlbnNpdGl2ZSkuXG4gKiBVc2VkIGJ5IHNlYXJjaCBkaWFsb2dzIHRvIHNob3cgd2hlcmUgdGhlIHF1ZXJ5IG1hdGNoZWQgaW4gcmVzdWx0IHJvd3NcbiAqIGFuZCBwcmV2aWV3IHBhbmVzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaGlnaGxpZ2h0TWF0Y2godGV4dDogc3RyaW5nLCBxdWVyeTogc3RyaW5nKTogUmVhY3QuUmVhY3ROb2RlIHtcbiAgaWYgKCFxdWVyeSkgcmV0dXJuIHRleHRcbiAgY29uc3QgcXVlcnlMb3dlciA9IHF1ZXJ5LnRvTG93ZXJDYXNlKClcbiAgY29uc3QgdGV4dExvd2VyID0gdGV4dC50b0xvd2VyQ2FzZSgpXG4gIGNvbnN0IHBhcnRzOiBSZWFjdC5SZWFjdE5vZGVbXSA9IFtdXG4gIGxldCBvZmZzZXQgPSAwXG4gIGxldCBpZHggPSB0ZXh0TG93ZXIuaW5kZXhPZihxdWVyeUxvd2VyLCBvZmZzZXQpXG4gIGlmIChpZHggPT09IC0xKSByZXR1cm4gdGV4dFxuICB3aGlsZSAoaWR4ICE9PSAtMSkge1xuICAgIGlmIChpZHggPiBvZmZzZXQpIHBhcnRzLnB1c2godGV4dC5zbGljZShvZmZzZXQsIGlkeCkpXG4gICAgcGFydHMucHVzaChcbiAgICAgIDxUZXh0IGtleT17aWR4fSBpbnZlcnNlPlxuICAgICAgICB7dGV4dC5zbGljZShpZHgsIGlkeCArIHF1ZXJ5Lmxlbmd0aCl9XG4gICAgICA8L1RleHQ+LFxuICAgIClcbiAgICBvZmZzZXQgPSBpZHggKyBxdWVyeS5sZW5ndGhcbiAgICBpZHggPSB0ZXh0TG93ZXIuaW5kZXhPZihxdWVyeUxvd2VyLCBvZmZzZXQpXG4gIH1cbiAgaWYgKG9mZnNldCA8IHRleHQubGVuZ3RoKSBwYXJ0cy5wdXNoKHRleHQuc2xpY2Uob2Zmc2V0KSlcbiAgcmV0dXJuIDw+e3BhcnRzfTwvPlxufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUtBLEtBQUssTUFBTSxPQUFPO0FBQzlCLFNBQVNDLElBQUksUUFBUSxXQUFXOztBQUVoQztBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsT0FBTyxTQUFTQyxjQUFjQSxDQUFDQyxJQUFJLEVBQUUsTUFBTSxFQUFFQyxLQUFLLEVBQUUsTUFBTSxDQUFDLEVBQUVKLEtBQUssQ0FBQ0ssU0FBUyxDQUFDO0VBQzNFLElBQUksQ0FBQ0QsS0FBSyxFQUFFLE9BQU9ELElBQUk7RUFDdkIsTUFBTUcsVUFBVSxHQUFHRixLQUFLLENBQUNHLFdBQVcsQ0FBQyxDQUFDO0VBQ3RDLE1BQU1DLFNBQVMsR0FBR0wsSUFBSSxDQUFDSSxXQUFXLENBQUMsQ0FBQztFQUNwQyxNQUFNRSxLQUFLLEVBQUVULEtBQUssQ0FBQ0ssU0FBUyxFQUFFLEdBQUcsRUFBRTtFQUNuQyxJQUFJSyxNQUFNLEdBQUcsQ0FBQztFQUNkLElBQUlDLEdBQUcsR0FBR0gsU0FBUyxDQUFDSSxPQUFPLENBQUNOLFVBQVUsRUFBRUksTUFBTSxDQUFDO0VBQy9DLElBQUlDLEdBQUcsS0FBSyxDQUFDLENBQUMsRUFBRSxPQUFPUixJQUFJO0VBQzNCLE9BQU9RLEdBQUcsS0FBSyxDQUFDLENBQUMsRUFBRTtJQUNqQixJQUFJQSxHQUFHLEdBQUdELE1BQU0sRUFBRUQsS0FBSyxDQUFDSSxJQUFJLENBQUNWLElBQUksQ0FBQ1csS0FBSyxDQUFDSixNQUFNLEVBQUVDLEdBQUcsQ0FBQyxDQUFDO0lBQ3JERixLQUFLLENBQUNJLElBQUksQ0FDUixDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQ0YsR0FBRyxDQUFDLENBQUMsT0FBTztBQUM3QixRQUFRLENBQUNSLElBQUksQ0FBQ1csS0FBSyxDQUFDSCxHQUFHLEVBQUVBLEdBQUcsR0FBR1AsS0FBSyxDQUFDVyxNQUFNLENBQUM7QUFDNUMsTUFBTSxFQUFFLElBQUksQ0FDUixDQUFDO0lBQ0RMLE1BQU0sR0FBR0MsR0FBRyxHQUFHUCxLQUFLLENBQUNXLE1BQU07SUFDM0JKLEdBQUcsR0FBR0gsU0FBUyxDQUFDSSxPQUFPLENBQUNOLFVBQVUsRUFBRUksTUFBTSxDQUFDO0VBQzdDO0VBQ0EsSUFBSUEsTUFBTSxHQUFHUCxJQUFJLENBQUNZLE1BQU0sRUFBRU4sS0FBSyxDQUFDSSxJQUFJLENBQUNWLElBQUksQ0FBQ1csS0FBSyxDQUFDSixNQUFNLENBQUMsQ0FBQztFQUN4RCxPQUFPLEVBQUUsQ0FBQ0QsS0FBSyxDQUFDLEdBQUc7QUFDckIiLCJpZ25vcmVMaXN0IjpbXX0=

package/utils/hooks/AsyncHookRegistry.ts

@@ -0,0 +1,309 @@
+import type {
+  AsyncHookJSONOutput,
+  HookEvent,
+  SyncHookJSONOutput,
+} from 'src/entrypoints/agentSdkTypes.js'
+import { logForDebugging } from '../debug.js'
+import type { ShellCommand } from '../ShellCommand.js'
+import { invalidateSessionEnvCache } from '../sessionEnvironment.js'
+import { jsonParse, jsonStringify } from '../slowOperations.js'
+import { emitHookResponse, startHookProgressInterval } from './hookEvents.js'
+
+export type PendingAsyncHook = {
+  processId: string
+  hookId: string
+  hookName: string
+  hookEvent: HookEvent | 'StatusLine' | 'FileSuggestion'
+  toolName?: string
+  pluginId?: string
+  startTime: number
+  timeout: number
+  command: string
+  responseAttachmentSent: boolean
+  shellCommand?: ShellCommand
+  stopProgressInterval: () => void
+}
+
+// Global registry state
+const pendingHooks = new Map<string, PendingAsyncHook>()
+
+export function registerPendingAsyncHook({
+  processId,
+  hookId,
+  asyncResponse,
+  hookName,
+  hookEvent,
+  command,
+  shellCommand,
+  toolName,
+  pluginId,
+}: {
+  processId: string
+  hookId: string
+  asyncResponse: AsyncHookJSONOutput
+  hookName: string
+  hookEvent: HookEvent | 'StatusLine' | 'FileSuggestion'
+  command: string
+  shellCommand: ShellCommand
+  toolName?: string
+  pluginId?: string
+}): void {
+  const timeout = asyncResponse.asyncTimeout || 15000 // Default 15s
+  logForDebugging(
+    `Hooks: Registering async hook ${processId} (${hookName}) with timeout ${timeout}ms`,
+  )
+  const stopProgressInterval = startHookProgressInterval({
+    hookId,
+    hookName,
+    hookEvent,
+    getOutput: async () => {
+      const taskOutput = pendingHooks.get(processId)?.shellCommand?.taskOutput
+      if (!taskOutput) {
+        return { stdout: '', stderr: '', output: '' }
+      }
+      const stdout = await taskOutput.getStdout()
+      const stderr = taskOutput.getStderr()
+      return { stdout, stderr, output: stdout + stderr }
+    },
+  })
+  pendingHooks.set(processId, {
+    processId,
+    hookId,
+    hookName,
+    hookEvent,
+    toolName,
+    pluginId,
+    command,
+    startTime: Date.now(),
+    timeout,
+    responseAttachmentSent: false,
+    shellCommand,
+    stopProgressInterval,
+  })
+}
+
+export function getPendingAsyncHooks(): PendingAsyncHook[] {
+  return Array.from(pendingHooks.values()).filter(
+    hook => !hook.responseAttachmentSent,
+  )
+}
+
+async function finalizeHook(
+  hook: PendingAsyncHook,
+  exitCode: number,
+  outcome: 'success' | 'error' | 'cancelled',
+): Promise<void> {
+  hook.stopProgressInterval()
+  const taskOutput = hook.shellCommand?.taskOutput
+  const stdout = taskOutput ? await taskOutput.getStdout() : ''
+  const stderr = taskOutput?.getStderr() ?? ''
+  hook.shellCommand?.cleanup()
+  emitHookResponse({
+    hookId: hook.hookId,
+    hookName: hook.hookName,
+    hookEvent: hook.hookEvent,
+    output: stdout + stderr,
+    stdout,
+    stderr,
+    exitCode,
+    outcome,
+  })
+}
+
+export async function checkForAsyncHookResponses(): Promise<
+  Array<{
+    processId: string
+    response: SyncHookJSONOutput
+    hookName: string
+    hookEvent: HookEvent | 'StatusLine' | 'FileSuggestion'
+    toolName?: string
+    pluginId?: string
+    stdout: string
+    stderr: string
+    exitCode?: number
+  }>
+> {
+  const responses: {
+    processId: string
+    response: SyncHookJSONOutput
+    hookName: string
+    hookEvent: HookEvent | 'StatusLine' | 'FileSuggestion'
+    toolName?: string
+    pluginId?: string
+    stdout: string
+    stderr: string
+    exitCode?: number
+  }[] = []
+
+  const pendingCount = pendingHooks.size
+  logForDebugging(`Hooks: Found ${pendingCount} total hooks in registry`)
+
+  // Snapshot hooks before processing — we'll mutate the map after.
+  const hooks = Array.from(pendingHooks.values())
+
+  const settled = await Promise.allSettled(
+    hooks.map(async hook => {
+      const stdout = (await hook.shellCommand?.taskOutput.getStdout()) ?? ''
+      const stderr = hook.shellCommand?.taskOutput.getStderr() ?? ''
+      logForDebugging(
+        `Hooks: Checking hook ${hook.processId} (${hook.hookName}) - attachmentSent: ${hook.responseAttachmentSent}, stdout length: ${stdout.length}`,
+      )
+
+      if (!hook.shellCommand) {
+        logForDebugging(
+          `Hooks: Hook ${hook.processId} has no shell command, removing from registry`,
+        )
+        hook.stopProgressInterval()
+        return { type: 'remove' as const, processId: hook.processId }
+      }
+
+      logForDebugging(`Hooks: Hook shell status ${hook.shellCommand.status}`)
+
+      if (hook.shellCommand.status === 'killed') {
+        logForDebugging(
+          `Hooks: Hook ${hook.processId} is ${hook.shellCommand.status}, removing from registry`,
+        )
+        hook.stopProgressInterval()
+        hook.shellCommand.cleanup()
+        return { type: 'remove' as const, processId: hook.processId }
+      }
+
+      if (hook.shellCommand.status !== 'completed') {
+        return { type: 'skip' as const }
+      }
+
+      if (hook.responseAttachmentSent || !stdout.trim()) {
+        logForDebugging(
+          `Hooks: Skipping hook ${hook.processId} - already delivered/sent or no stdout`,
+        )
+        hook.stopProgressInterval()
+        return { type: 'remove' as const, processId: hook.processId }
+      }
+
+      const lines = stdout.split('\n')
+      logForDebugging(
+        `Hooks: Processing ${lines.length} lines of stdout for ${hook.processId}`,
+      )
+
+      const execResult = await hook.shellCommand.result
+      const exitCode = execResult.code
+
+      let response: SyncHookJSONOutput = {}
+      for (const line of lines) {
+        if (line.trim().startsWith('{')) {
+          logForDebugging(
+            `Hooks: Found JSON line: ${line.trim().substring(0, 100)}...`,
+          )
+          try {
+            const parsed = jsonParse(line.trim())
+            if (!('async' in parsed)) {
+              logForDebugging(
+                `Hooks: Found sync response from ${hook.processId}: ${jsonStringify(parsed)}`,
+              )
+              response = parsed
+              break
+            }
+          } catch {
+            logForDebugging(
+              `Hooks: Failed to parse JSON from ${hook.processId}: ${line.trim()}`,
+            )
+          }
+        }
+      }
+
+      hook.responseAttachmentSent = true
+      await finalizeHook(hook, exitCode, exitCode === 0 ? 'success' : 'error')
+
+      return {
+        type: 'response' as const,
+        processId: hook.processId,
+        isSessionStart: hook.hookEvent === 'SessionStart',
+        payload: {
+          processId: hook.processId,
+          response,
+          hookName: hook.hookName,
+          hookEvent: hook.hookEvent,
+          toolName: hook.toolName,
+          pluginId: hook.pluginId,
+          stdout,
+          stderr,
+          exitCode,
+        },
+      }
+    }),
+  )
+
+  // allSettled — isolate failures so one throwing callback doesn't orphan
+  // already-applied side effects (responseAttachmentSent, finalizeHook) from others.
+  let sessionStartCompleted = false
+  for (const s of settled) {
+    if (s.status !== 'fulfilled') {
+      logForDebugging(
+        `Hooks: checkForAsyncHookResponses callback rejected: ${s.reason}`,
+        { level: 'error' },
+      )
+      continue
+    }
+    const r = s.value
+    if (r.type === 'remove') {
+      pendingHooks.delete(r.processId)
+    } else if (r.type === 'response') {
+      responses.push(r.payload)
+      pendingHooks.delete(r.processId)
+      if (r.isSessionStart) sessionStartCompleted = true
+    }
+  }
+
+  if (sessionStartCompleted) {
+    logForDebugging(
+      `Invalidating session env cache after SessionStart hook completed`,
+    )
+    invalidateSessionEnvCache()
+  }
+
+  logForDebugging(
+    `Hooks: checkForNewResponses returning ${responses.length} responses`,
+  )
+  return responses
+}
+
+export function removeDeliveredAsyncHooks(processIds: string[]): void {
+  for (const processId of processIds) {
+    const hook = pendingHooks.get(processId)
+    if (hook && hook.responseAttachmentSent) {
+      logForDebugging(`Hooks: Removing delivered hook ${processId}`)
+      hook.stopProgressInterval()
+      pendingHooks.delete(processId)
+    }
+  }
+}
+
+export async function finalizePendingAsyncHooks(): Promise<void> {
+  const hooks = Array.from(pendingHooks.values())
+  await Promise.all(
+    hooks.map(async hook => {
+      if (hook.shellCommand?.status === 'completed') {
+        const result = await hook.shellCommand.result
+        await finalizeHook(
+          hook,
+          result.code,
+          result.code === 0 ? 'success' : 'error',
+        )
+      } else {
+        if (hook.shellCommand && hook.shellCommand.status !== 'killed') {
+          hook.shellCommand.kill()
+        }
+        await finalizeHook(hook, 1, 'cancelled')
+      }
+    }),
+  )
+  pendingHooks.clear()
+}
+
+// Test utility function to clear all hooks
+export function clearAllAsyncHooks(): void {
+  for (const hook of pendingHooks.values()) {
+    hook.stopProgressInterval()
+  }
+  pendingHooks.clear()
+}

package/utils/hooks/apiQueryHookHelper.ts

@@ -0,0 +1,141 @@
+import { randomUUID } from 'crypto'
+import type { QuerySource } from '../../constants/querySource.js'
+import { queryModelWithoutStreaming } from '../../services/api/gemini.js'
+import type { Message } from '../../types/message.js'
+import { createAbortController } from '../../utils/abortController.js'
+import { logError } from '../../utils/log.js'
+import { toError } from '../errors.js'
+import { extractTextContent } from '../messages.js'
+import { asSystemPrompt } from '../systemPromptType.js'
+import type { REPLHookContext } from './postSamplingHooks.js'
+
+export type ApiQueryHookContext = REPLHookContext & {
+  queryMessageCount?: number
+}
+
+export type ApiQueryHookConfig<TResult> = {
+  name: QuerySource
+  shouldRun: (context: ApiQueryHookContext) => Promise<boolean>
+
+  // Build the complete message list to send to the API
+  buildMessages: (context: ApiQueryHookContext) => Message[]
+
+  // Optional: override system prompt (defaults to context.systemPrompt)
+  systemPrompt?: string
+
+  // Optional: whether to use tools from context (defaults to true)
+  // Set to false to pass empty tools array
+  useTools?: boolean
+
+  parseResponse: (content: string, context: ApiQueryHookContext) => TResult
+  logResult: (
+    result: ApiQueryResult<TResult>,
+    context: ApiQueryHookContext,
+  ) => void
+  // Must be a function to ensure lazy loading (config is accessed before allowed)
+  // Receives context so callers can inherit the main loop model if desired.
+  getModel: (context: ApiQueryHookContext) => string
+}
+
+export type ApiQueryResult<TResult> =
+  | {
+      type: 'success'
+      queryName: string
+      result: TResult
+      messageId: string
+      model: string
+      uuid: string
+    }
+  | {
+      type: 'error'
+      queryName: string
+      error: Error
+      uuid: string
+    }
+
+export function createApiQueryHook<TResult>(
+  config: ApiQueryHookConfig<TResult>,
+) {
+  return async (context: ApiQueryHookContext): Promise<void> => {
+    try {
+      const shouldRun = await config.shouldRun(context)
+      if (!shouldRun) {
+        return
+      }
+
+      const uuid = randomUUID()
+
+      // Build messages using the config's buildMessages function
+      const messages = config.buildMessages(context)
+      context.queryMessageCount = messages.length
+
+      // Use config's system prompt if provided, otherwise use context's
+      const systemPrompt = config.systemPrompt
+        ? asSystemPrompt([config.systemPrompt])
+        : context.systemPrompt
+
+      // Use config's tools preference (defaults to true = use context tools)
+      const useTools = config.useTools ?? true
+      const tools = useTools ? context.toolUseContext.options.tools : []
+
+      // Get model (lazy loaded)
+      const model = config.getModel(context)
+
+      // Make API call
+      const response = await queryModelWithoutStreaming({
+        messages,
+        systemPrompt,
+        thinkingConfig: { type: 'disabled' as const },
+        tools,
+        signal: createAbortController().signal,
+        options: {
+          getToolPermissionContext: async () => {
+            const appState = context.toolUseContext.getAppState()
+            return appState.toolPermissionContext
+          },
+          model,
+          toolChoice: undefined,
+          isNonInteractiveSession:
+            context.toolUseContext.options.isNonInteractiveSession,
+          hasAppendSystemPrompt:
+            !!context.toolUseContext.options.appendSystemPrompt,
+          temperatureOverride: 0,
+          agents: context.toolUseContext.options.agentDefinitions.activeAgents,
+          querySource: config.name,
+          mcpTools: [],
+          agentId: context.toolUseContext.agentId,
+        },
+      })
+
+      // Parse response
+      const content = extractTextContent(response.message.content).trim()
+
+      try {
+        const result = config.parseResponse(content, context)
+        config.logResult(
+          {
+            type: 'success',
+            queryName: config.name,
+            result,
+            messageId: response.message.id,
+            model,
+            uuid,
+          },
+          context,
+        )
+      } catch (error) {
+        config.logResult(
+          {
+            type: 'error',
+            queryName: config.name,
+            error: error as Error,
+            uuid,
+          },
+          context,
+        )
+      }
+    } catch (error) {
+      logError(toError(error))
+    }
+  }
+}