@xortex/xcode 3.0.1 → 3.0.2

package/hooks/useHistorySearch.ts

@@ -0,0 +1,303 @@
+import { feature } from 'bun:bundle'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import {
+  getModeFromInput,
+  getValueFromInput,
+} from '../components/PromptInput/inputModes.js'
+import { makeHistoryReader } from '../history.js'
+import { KeyboardEvent } from '../ink/events/keyboard-event.js'
+// eslint-disable-next-line custom-rules/prefer-use-keybindings -- backward-compat bridge until consumers wire handleKeyDown to <Box onKeyDown>
+import { useInput } from '../ink.js'
+import { useKeybinding, useKeybindings } from '../keybindings/useKeybinding.js'
+import type { PromptInputMode } from '../types/textInputTypes.js'
+import type { HistoryEntry } from '../utils/config.js'
+
+export function useHistorySearch(
+  onAcceptHistory: (entry: HistoryEntry) => void,
+  currentInput: string,
+  onInputChange: (input: string) => void,
+  onCursorChange: (cursorOffset: number) => void,
+  currentCursorOffset: number,
+  onModeChange: (mode: PromptInputMode) => void,
+  currentMode: PromptInputMode,
+  isSearching: boolean,
+  setIsSearching: (isSearching: boolean) => void,
+  setPastedContents: (pastedContents: HistoryEntry['pastedContents']) => void,
+  currentPastedContents: HistoryEntry['pastedContents'],
+): {
+  historyQuery: string
+  setHistoryQuery: (query: string) => void
+  historyMatch: HistoryEntry | undefined
+  historyFailedMatch: boolean
+  handleKeyDown: (e: KeyboardEvent) => void
+} {
+  const [historyQuery, setHistoryQuery] = useState('')
+  const [historyFailedMatch, setHistoryFailedMatch] = useState(false)
+  const [originalInput, setOriginalInput] = useState('')
+  const [originalCursorOffset, setOriginalCursorOffset] = useState(0)
+  const [originalMode, setOriginalMode] = useState<PromptInputMode>('prompt')
+  const [originalPastedContents, setOriginalPastedContents] = useState<
+    HistoryEntry['pastedContents']
+  >({})
+  const [historyMatch, setHistoryMatch] = useState<HistoryEntry | undefined>(
+    undefined,
+  )
+  const historyReader = useRef<AsyncGenerator<HistoryEntry> | undefined>(
+    undefined,
+  )
+  const seenPrompts = useRef<Set<string>>(new Set())
+  const searchAbortController = useRef<AbortController | null>(null)
+
+  const closeHistoryReader = useCallback((): void => {
+    if (historyReader.current) {
+      // Must explicitly call .return() to trigger the finally block in readLinesReverse,
+      // which closes the file handle. Without this, file descriptors leak.
+      void historyReader.current.return(undefined)
+      historyReader.current = undefined
+    }
+  }, [])
+
+  const reset = useCallback((): void => {
+    setIsSearching(false)
+    setHistoryQuery('')
+    setHistoryFailedMatch(false)
+    setOriginalInput('')
+    setOriginalCursorOffset(0)
+    setOriginalMode('prompt')
+    setOriginalPastedContents({})
+    setHistoryMatch(undefined)
+    closeHistoryReader()
+    seenPrompts.current.clear()
+  }, [setIsSearching, closeHistoryReader])
+
+  const searchHistory = useCallback(
+    async (resume: boolean, signal?: AbortSignal): Promise<void> => {
+      if (!isSearching) {
+        return
+      }
+
+      if (historyQuery.length === 0) {
+        closeHistoryReader()
+        seenPrompts.current.clear()
+        setHistoryMatch(undefined)
+        setHistoryFailedMatch(false)
+        onInputChange(originalInput)
+        onCursorChange(originalCursorOffset)
+        onModeChange(originalMode)
+        setPastedContents(originalPastedContents)
+        return
+      }
+
+      if (!resume) {
+        closeHistoryReader()
+        historyReader.current = makeHistoryReader()
+        seenPrompts.current.clear()
+      }
+
+      if (!historyReader.current) {
+        return
+      }
+
+      while (true) {
+        if (signal?.aborted) {
+          return
+        }
+
+        const item = await historyReader.current.next()
+        if (item.done) {
+          // No match found - keep last match but mark as failed
+          setHistoryFailedMatch(true)
+          return
+        }
+
+        const display = item.value.display
+
+        const matchPosition = display.lastIndexOf(historyQuery)
+        if (matchPosition !== -1 && !seenPrompts.current.has(display)) {
+          seenPrompts.current.add(display)
+          setHistoryMatch(item.value)
+          setHistoryFailedMatch(false)
+          const mode = getModeFromInput(display)
+          onModeChange(mode)
+          onInputChange(display)
+          setPastedContents(item.value.pastedContents)
+
+          // Position cursor relative to the clean value, not the display
+          const value = getValueFromInput(display)
+          const cleanMatchPosition = value.lastIndexOf(historyQuery)
+          onCursorChange(
+            cleanMatchPosition !== -1 ? cleanMatchPosition : matchPosition,
+          )
+          return
+        }
+      }
+    },
+    [
+      isSearching,
+      historyQuery,
+      closeHistoryReader,
+      onInputChange,
+      onCursorChange,
+      onModeChange,
+      setPastedContents,
+      originalInput,
+      originalCursorOffset,
+      originalMode,
+      originalPastedContents,
+    ],
+  )
+
+  // Handler: Start history search (when not searching)
+  const handleStartSearch = useCallback(() => {
+    setIsSearching(true)
+    setOriginalInput(currentInput)
+    setOriginalCursorOffset(currentCursorOffset)
+    setOriginalMode(currentMode)
+    setOriginalPastedContents(currentPastedContents)
+    historyReader.current = makeHistoryReader()
+    seenPrompts.current.clear()
+  }, [
+    setIsSearching,
+    currentInput,
+    currentCursorOffset,
+    currentMode,
+    currentPastedContents,
+  ])
+
+  // Handler: Find next match (when searching)
+  const handleNextMatch = useCallback(() => {
+    void searchHistory(true)
+  }, [searchHistory])
+
+  // Handler: Accept current match and exit search
+  const handleAccept = useCallback(() => {
+    if (historyMatch) {
+      const mode = getModeFromInput(historyMatch.display)
+      const value = getValueFromInput(historyMatch.display)
+      onInputChange(value)
+      onModeChange(mode)
+      setPastedContents(historyMatch.pastedContents)
+    } else {
+      // No match - restore original pasted contents
+      setPastedContents(originalPastedContents)
+    }
+    reset()
+  }, [
+    historyMatch,
+    onInputChange,
+    onModeChange,
+    setPastedContents,
+    originalPastedContents,
+    reset,
+  ])
+
+  // Handler: Cancel search and restore original input
+  const handleCancel = useCallback(() => {
+    onInputChange(originalInput)
+    onCursorChange(originalCursorOffset)
+    setPastedContents(originalPastedContents)
+    reset()
+  }, [
+    onInputChange,
+    onCursorChange,
+    setPastedContents,
+    originalInput,
+    originalCursorOffset,
+    originalPastedContents,
+    reset,
+  ])
+
+  // Handler: Execute (accept and submit)
+  const handleExecute = useCallback(() => {
+    if (historyQuery.length === 0) {
+      onAcceptHistory({
+        display: originalInput,
+        pastedContents: originalPastedContents,
+      })
+    } else if (historyMatch) {
+      const mode = getModeFromInput(historyMatch.display)
+      const value = getValueFromInput(historyMatch.display)
+      onModeChange(mode)
+      onAcceptHistory({
+        display: value,
+        pastedContents: historyMatch.pastedContents,
+      })
+    }
+    reset()
+  }, [
+    historyQuery,
+    historyMatch,
+    onAcceptHistory,
+    onModeChange,
+    originalInput,
+    originalPastedContents,
+    reset,
+  ])
+
+  // Gated off under HISTORY_PICKER — the modal dialog owns ctrl+r there.
+  useKeybinding('history:search', handleStartSearch, {
+    context: 'Global',
+    isActive: feature('HISTORY_PICKER') ? false : !isSearching,
+  })
+
+  // History search context keybindings (only active when searching)
+  const historySearchHandlers = useMemo(
+    () => ({
+      'historySearch:next': handleNextMatch,
+      'historySearch:accept': handleAccept,
+      'historySearch:cancel': handleCancel,
+      'historySearch:execute': handleExecute,
+    }),
+    [handleNextMatch, handleAccept, handleCancel, handleExecute],
+  )
+
+  useKeybindings(historySearchHandlers, {
+    context: 'HistorySearch',
+    isActive: isSearching,
+  })
+
+  // Handle backspace when query is empty (cancels search)
+  // This is a conditional behavior that doesn't fit the keybinding model
+  // well (backspace only cancels when query is empty)
+  const handleKeyDown = (e: KeyboardEvent): void => {
+    if (!isSearching) return
+    if (e.key === 'backspace' && historyQuery === '') {
+      e.preventDefault()
+      handleCancel()
+    }
+  }
+
+  // Backward-compat bridge: PromptInput doesn't yet wire handleKeyDown to
+  // <Box onKeyDown>. Subscribe via useInput and adapt InputEvent →
+  // KeyboardEvent until the consumer is migrated (separate PR).
+  // TODO(onKeyDown-migration): remove once PromptInput passes handleKeyDown.
+  useInput(
+    (_input, _key, event) => {
+      handleKeyDown(new KeyboardEvent(event.keypress))
+    },
+    { isActive: isSearching },
+  )
+
+  // Keep a ref to searchHistory to avoid it being a dependency of useEffect
+  const searchHistoryRef = useRef(searchHistory)
+  searchHistoryRef.current = searchHistory
+
+  // Reset history search when query changes
+  useEffect(() => {
+    searchAbortController.current?.abort()
+    const controller = new AbortController()
+    searchAbortController.current = controller
+    void searchHistoryRef.current(false, controller.signal)
+    return () => {
+      controller.abort()
+    }
+  }, [historyQuery])
+
+  return {
+    historyQuery,
+    setHistoryQuery,
+    historyMatch,
+    historyFailedMatch,
+    handleKeyDown,
+  }
+}

package/hooks/useIDEIntegration.tsx

@@ -0,0 +1,70 @@
+import { c as _c } from "react/compiler-runtime";
+import { useEffect } from 'react';
+import type { ScopedMcpServerConfig } from '../services/mcp/types.js';
+import { getGlobalConfig } from '../utils/config.js';
+import { isEnvDefinedFalsy, isEnvTruthy } from '../utils/envUtils.js';
+import type { DetectedIDEInfo } from '../utils/ide.js';
+import { type IDEExtensionInstallationStatus, type IdeType, initializeIdeIntegration, isSupportedTerminal } from '../utils/ide.js';
+type UseIDEIntegrationProps = {
+  autoConnectIdeFlag?: boolean;
+  ideToInstallExtension: IdeType | null;
+  setDynamicMcpConfig: React.Dispatch<React.SetStateAction<Record<string, ScopedMcpServerConfig> | undefined>>;
+  setShowIdeOnboarding: React.Dispatch<React.SetStateAction<boolean>>;
+  setIDEInstallationState: React.Dispatch<React.SetStateAction<IDEExtensionInstallationStatus | null>>;
+};
+export function useIDEIntegration(t0) {
+  const $ = _c(7);
+  const {
+    autoConnectIdeFlag,
+    ideToInstallExtension,
+    setDynamicMcpConfig,
+    setShowIdeOnboarding,
+    setIDEInstallationState
+  } = t0;
+  let t1;
+  let t2;
+  if ($[0] !== autoConnectIdeFlag || $[1] !== ideToInstallExtension || $[2] !== setDynamicMcpConfig || $[3] !== setIDEInstallationState || $[4] !== setShowIdeOnboarding) {
+    t1 = () => {
+      const addIde = function addIde(ide) {
+        if (!ide) {
+          return;
+        }
+        const globalConfig = getGlobalConfig();
+        const autoConnectEnabled = (globalConfig.autoConnectIde || autoConnectIdeFlag || isSupportedTerminal() || process.env.CLAUDE_CODE_SSE_PORT || ideToInstallExtension || isEnvTruthy(process.env.CLAUDE_CODE_AUTO_CONNECT_IDE)) && !isEnvDefinedFalsy(process.env.CLAUDE_CODE_AUTO_CONNECT_IDE);
+        if (!autoConnectEnabled) {
+          return;
+        }
+        setDynamicMcpConfig(prev => {
+          if (prev?.ide) {
+            return prev;
+          }
+          return {
+            ...prev,
+            ide: {
+              type: ide.url.startsWith("ws:") ? "ws-ide" : "sse-ide",
+              url: ide.url,
+              ideName: ide.name,
+              authToken: ide.authToken,
+              ideRunningInWindows: ide.ideRunningInWindows,
+              scope: "dynamic" as const
+            }
+          };
+        });
+      };
+      initializeIdeIntegration(addIde, ideToInstallExtension, () => setShowIdeOnboarding(true), status => setIDEInstallationState(status));
+    };
+    t2 = [autoConnectIdeFlag, ideToInstallExtension, setDynamicMcpConfig, setShowIdeOnboarding, setIDEInstallationState];
+    $[0] = autoConnectIdeFlag;
+    $[1] = ideToInstallExtension;
+    $[2] = setDynamicMcpConfig;
+    $[3] = setIDEInstallationState;
+    $[4] = setShowIdeOnboarding;
+    $[5] = t1;
+    $[6] = t2;
+  } else {
+    t1 = $[5];
+    t2 = $[6];
+  }
+  useEffect(t1, t2);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/hooks/useIdeAtMentioned.ts

@@ -0,0 +1,76 @@
+import { useEffect, useRef } from 'react'
+import { logError } from 'src/utils/log.js'
+import { z } from 'zod/v4'
+import type {
+  ConnectedMCPServer,
+  MCPServerConnection,
+} from '../services/mcp/types.js'
+import { getConnectedIdeClient } from '../utils/ide.js'
+import { lazySchema } from '../utils/lazySchema.js'
+export type IDEAtMentioned = {
+  filePath: string
+  lineStart?: number
+  lineEnd?: number
+}
+
+const NOTIFICATION_METHOD = 'at_mentioned'
+
+const AtMentionedSchema = lazySchema(() =>
+  z.object({
+    method: z.literal(NOTIFICATION_METHOD),
+    params: z.object({
+      filePath: z.string(),
+      lineStart: z.number().optional(),
+      lineEnd: z.number().optional(),
+    }),
+  }),
+)
+
+/**
+ * A hook that tracks IDE at-mention notifications by directly registering
+ * with MCP client notification handlers,
+ */
+export function useIdeAtMentioned(
+  mcpClients: MCPServerConnection[],
+  onAtMentioned: (atMentioned: IDEAtMentioned) => void,
+): void {
+  const ideClientRef = useRef<ConnectedMCPServer | undefined>(undefined)
+
+  useEffect(() => {
+    // Find the IDE client from the MCP clients list
+    const ideClient = getConnectedIdeClient(mcpClients)
+
+    if (ideClientRef.current !== ideClient) {
+      ideClientRef.current = ideClient
+    }
+
+    // If we found a connected IDE client, register our handler
+    if (ideClient) {
+      ideClient.client.setNotificationHandler(
+        AtMentionedSchema(),
+        notification => {
+          if (ideClientRef.current !== ideClient) {
+            return
+          }
+          try {
+            const data = notification.params
+            // Adjust line numbers to be 1-based instead of 0-based
+            const lineStart =
+              data.lineStart !== undefined ? data.lineStart + 1 : undefined
+            const lineEnd =
+              data.lineEnd !== undefined ? data.lineEnd + 1 : undefined
+            onAtMentioned({
+              filePath: data.filePath,
+              lineStart: lineStart,
+              lineEnd: lineEnd,
+            })
+          } catch (error) {
+            logError(error as Error)
+          }
+        },
+      )
+    }
+
+    // No cleanup needed as MCP clients manage their own lifecycle
+  }, [mcpClients, onAtMentioned])
+}

package/hooks/useIdeConnectionStatus.ts

@@ -0,0 +1,33 @@
+import { useMemo } from 'react'
+import type { MCPServerConnection } from '../services/mcp/types.js'
+
+export type IdeStatus = 'connected' | 'disconnected' | 'pending' | null
+
+type IdeConnectionResult = {
+  status: IdeStatus
+  ideName: string | null
+}
+
+export function useIdeConnectionStatus(
+  mcpClients?: MCPServerConnection[],
+): IdeConnectionResult {
+  return useMemo(() => {
+    const ideClient = mcpClients?.find(client => client.name === 'ide')
+    if (!ideClient) {
+      return { status: null, ideName: null }
+    }
+    // Extract IDE name from config if available
+    const config = ideClient.config
+    const ideName =
+      config.type === 'sse-ide' || config.type === 'ws-ide'
+        ? config.ideName
+        : null
+    if (ideClient.type === 'connected') {
+      return { status: 'connected', ideName }
+    }
+    if (ideClient.type === 'pending') {
+      return { status: 'pending', ideName }
+    }
+    return { status: 'disconnected', ideName }
+  }, [mcpClients])
+}

package/hooks/useIdeLogging.ts

@@ -0,0 +1,41 @@
+import { useEffect } from 'react'
+import { logEvent } from 'src/services/analytics/index.js'
+import { z } from 'zod/v4'
+import type { MCPServerConnection } from '../services/mcp/types.js'
+import { getConnectedIdeClient } from '../utils/ide.js'
+import { lazySchema } from '../utils/lazySchema.js'
+
+const LogEventSchema = lazySchema(() =>
+  z.object({
+    method: z.literal('log_event'),
+    params: z.object({
+      eventName: z.string(),
+      eventData: z.object({}).passthrough(),
+    }),
+  }),
+)
+
+export function useIdeLogging(mcpClients: MCPServerConnection[]): void {
+  useEffect(() => {
+    // Skip if there are no clients
+    if (!mcpClients.length) {
+      return
+    }
+
+    // Find the IDE client from the MCP clients list
+    const ideClient = getConnectedIdeClient(mcpClients)
+    if (ideClient) {
+      // Register the log event handler
+      ideClient.client.setNotificationHandler(
+        LogEventSchema(),
+        notification => {
+          const { eventName, eventData } = notification.params
+          logEvent(
+            `tengu_ide_${eventName}`,
+            eventData as { [key: string]: boolean | number | undefined },
+          )
+        },
+      )
+    }
+  }, [mcpClients])
+}

package/hooks/useIdeSelection.ts

@@ -0,0 +1,150 @@
+import { useEffect, useRef } from 'react'
+import { logError } from 'src/utils/log.js'
+import { z } from 'zod/v4'
+import type {
+  ConnectedMCPServer,
+  MCPServerConnection,
+} from '../services/mcp/types.js'
+import { getConnectedIdeClient } from '../utils/ide.js'
+import { lazySchema } from '../utils/lazySchema.js'
+export type SelectionPoint = {
+  line: number
+  character: number
+}
+
+export type SelectionData = {
+  selection: {
+    start: SelectionPoint
+    end: SelectionPoint
+  } | null
+  text?: string
+  filePath?: string
+}
+
+export type IDESelection = {
+  lineCount: number
+  lineStart?: number
+  text?: string
+  filePath?: string
+}
+
+// Define the selection changed notification schema
+const SelectionChangedSchema = lazySchema(() =>
+  z.object({
+    method: z.literal('selection_changed'),
+    params: z.object({
+      selection: z
+        .object({
+          start: z.object({
+            line: z.number(),
+            character: z.number(),
+          }),
+          end: z.object({
+            line: z.number(),
+            character: z.number(),
+          }),
+        })
+        .nullable()
+        .optional(),
+      text: z.string().optional(),
+      filePath: z.string().optional(),
+    }),
+  }),
+)
+
+/**
+ * A hook that tracks IDE text selection information by directly registering
+ * with MCP client notification handlers
+ */
+export function useIdeSelection(
+  mcpClients: MCPServerConnection[],
+  onSelect: (selection: IDESelection) => void,
+): void {
+  const handlersRegistered = useRef(false)
+  const currentIDERef = useRef<ConnectedMCPServer | null>(null)
+
+  useEffect(() => {
+    // Find the IDE client from the MCP clients list
+    const ideClient = getConnectedIdeClient(mcpClients)
+
+    // If the IDE client changed, we need to re-register handlers.
+    // Normalize undefined to null so the initial ref value (null) matches
+    // "no IDE found" (undefined), avoiding spurious resets on every MCP update.
+    if (currentIDERef.current !== (ideClient ?? null)) {
+      handlersRegistered.current = false
+      currentIDERef.current = ideClient || null
+      // Reset the selection when the IDE client changes.
+      onSelect({
+        lineCount: 0,
+        lineStart: undefined,
+        text: undefined,
+        filePath: undefined,
+      })
+    }
+
+    // Skip if we've already registered handlers for the current IDE or if there's no IDE client
+    if (handlersRegistered.current || !ideClient) {
+      return
+    }
+
+    // Handler function for selection changes
+    const selectionChangeHandler = (data: SelectionData) => {
+      if (data.selection?.start && data.selection?.end) {
+        const { start, end } = data.selection
+        let lineCount = end.line - start.line + 1
+        // If on the first character of the line, do not count the line
+        // as being selected.
+        if (end.character === 0) {
+          lineCount--
+        }
+        const selection = {
+          lineCount,
+          lineStart: start.line,
+          text: data.text,
+          filePath: data.filePath,
+        }
+
+        onSelect(selection)
+      }
+    }
+
+    // Register notification handler for selection_changed events
+    ideClient.client.setNotificationHandler(
+      SelectionChangedSchema(),
+      notification => {
+        if (currentIDERef.current !== ideClient) {
+          return
+        }
+
+        try {
+          // Get the selection data from the notification params
+          const selectionData = notification.params
+
+          // Process selection data - validate it has required properties
+          if (
+            selectionData.selection &&
+            selectionData.selection.start &&
+            selectionData.selection.end
+          ) {
+            // Handle selection changes
+            selectionChangeHandler(selectionData as SelectionData)
+          } else if (selectionData.text !== undefined) {
+            // Handle empty selection (when text is empty string)
+            selectionChangeHandler({
+              selection: null,
+              text: selectionData.text,
+              filePath: selectionData.filePath,
+            })
+          }
+        } catch (error) {
+          logError(error as Error)
+        }
+      },
+    )
+
+    // Mark that we've registered handlers
+    handlersRegistered.current = true
+
+    // No cleanup needed as MCP clients manage their own lifecycle
+  }, [mcpClients, onSelect])
+}