@xelauvas/xela-cli 0.1.0

package/src/hooks/usePasteHandler.ts

@@ -0,0 +1,285 @@
+import { basename } from 'path'
+import React from 'react'
+import { logError } from 'src/utils/log.js'
+import { useDebounceCallback } from 'usehooks-ts'
+import type { InputEvent, Key } from '../ink.js'
+import {
+  getImageFromClipboard,
+  isImageFilePath,
+  PASTE_THRESHOLD,
+  tryReadImageFromPath,
+} from '../utils/imagePaste.js'
+import type { ImageDimensions } from '../utils/imageResizer.js'
+import { getPlatform } from '../utils/platform.js'
+
+const CLIPBOARD_CHECK_DEBOUNCE_MS = 50
+const PASTE_COMPLETION_TIMEOUT_MS = 100
+
+type PasteHandlerProps = {
+  onPaste?: (text: string) => void
+  onInput: (input: string, key: Key) => void
+  onImagePaste?: (
+    base64Image: string,
+    mediaType?: string,
+    filename?: string,
+    dimensions?: ImageDimensions,
+    sourcePath?: string,
+  ) => void
+}
+
+export function usePasteHandler({
+  onPaste,
+  onInput,
+  onImagePaste,
+}: PasteHandlerProps): {
+  wrappedOnInput: (input: string, key: Key, event: InputEvent) => void
+  pasteState: {
+    chunks: string[]
+    timeoutId: ReturnType<typeof setTimeout> | null
+  }
+  isPasting: boolean
+} {
+  const [pasteState, setPasteState] = React.useState<{
+    chunks: string[]
+    timeoutId: ReturnType<typeof setTimeout> | null
+  }>({ chunks: [], timeoutId: null })
+  const [isPasting, setIsPasting] = React.useState(false)
+  const isMountedRef = React.useRef(true)
+  // Mirrors pasteState.timeoutId but updated synchronously. When paste + a
+  // keystroke arrive in the same stdin chunk, both wrappedOnInput calls run
+  // in the same discreteUpdates batch before React commits — the second call
+  // reads stale pasteState.timeoutId (null) and takes the onInput path. If
+  // that key is Enter, it submits the old input and the paste is lost.
+  const pastePendingRef = React.useRef(false)
+
+  const isMacOS = React.useMemo(() => getPlatform() === 'macos', [])
+
+  React.useEffect(() => {
+    return () => {
+      isMountedRef.current = false
+    }
+  }, [])
+
+  const checkClipboardForImageImpl = React.useCallback(() => {
+    if (!onImagePaste || !isMountedRef.current) return
+
+    void getImageFromClipboard()
+      .then(imageData => {
+        if (imageData && isMountedRef.current) {
+          onImagePaste(
+            imageData.base64,
+            imageData.mediaType,
+            undefined, // no filename for clipboard images
+            imageData.dimensions,
+          )
+        }
+      })
+      .catch(error => {
+        if (isMountedRef.current) {
+          logError(error as Error)
+        }
+      })
+      .finally(() => {
+        if (isMountedRef.current) {
+          setIsPasting(false)
+        }
+      })
+  }, [onImagePaste])
+
+  const checkClipboardForImage = useDebounceCallback(
+    checkClipboardForImageImpl,
+    CLIPBOARD_CHECK_DEBOUNCE_MS,
+  )
+
+  const resetPasteTimeout = React.useCallback(
+    (currentTimeoutId: ReturnType<typeof setTimeout> | null) => {
+      if (currentTimeoutId) {
+        clearTimeout(currentTimeoutId)
+      }
+      return setTimeout(
+        (
+          setPasteState,
+          onImagePaste,
+          onPaste,
+          setIsPasting,
+          checkClipboardForImage,
+          isMacOS,
+          pastePendingRef,
+        ) => {
+          pastePendingRef.current = false
+          setPasteState(({ chunks }) => {
+            // Join chunks and filter out orphaned focus sequences
+            // These can appear when focus events split during paste
+            const pastedText = chunks
+              .join('')
+              .replace(/\[I$/, '')
+              .replace(/\[O$/, '')
+
+            // Check if the pasted text contains image file paths
+            // When dragging multiple images, they may come as:
+            // 1. Newline-separated paths (common in some terminals)
+            // 2. Space-separated paths (common when dragging from Finder)
+            // For space-separated paths, we split on spaces that precede absolute paths:
+            // - Unix: space followed by `/` (e.g., `/Users/...`)
+            // - Windows: space followed by drive letter and `:\` (e.g., `C:\Users\...`)
+            // This works because spaces within paths are escaped (e.g., `file\ name.png`)
+            const lines = pastedText
+              .split(/ (?=\/|[A-Za-z]:\\)/)
+              .flatMap(part => part.split('\n'))
+              .filter(line => line.trim())
+            const imagePaths = lines.filter(line => isImageFilePath(line))
+
+            if (onImagePaste && imagePaths.length > 0) {
+              const isTempScreenshot =
+                /\/TemporaryItems\/.*screencaptureui.*\/Screenshot/i.test(
+                  pastedText,
+                )
+
+              // Process all image paths
+              void Promise.all(
+                imagePaths.map(imagePath => tryReadImageFromPath(imagePath)),
+              ).then(results => {
+                const validImages = results.filter(
+                  (r): r is NonNullable<typeof r> => r !== null,
+                )
+
+                if (validImages.length > 0) {
+                  // Successfully read at least one image
+                  for (const imageData of validImages) {
+                    const filename = basename(imageData.path)
+                    onImagePaste(
+                      imageData.base64,
+                      imageData.mediaType,
+                      filename,
+                      imageData.dimensions,
+                      imageData.path,
+                    )
+                  }
+                  // If some paths weren't images, paste them as text
+                  const nonImageLines = lines.filter(
+                    line => !isImageFilePath(line),
+                  )
+                  if (nonImageLines.length > 0 && onPaste) {
+                    onPaste(nonImageLines.join('\n'))
+                  }
+                  setIsPasting(false)
+                } else if (isTempScreenshot && isMacOS) {
+                  // For temporary screenshot files that no longer exist, try clipboard
+                  checkClipboardForImage()
+                } else {
+                  if (onPaste) {
+                    onPaste(pastedText)
+                  }
+                  setIsPasting(false)
+                }
+              })
+              return { chunks: [], timeoutId: null }
+            }
+
+            // If paste is empty (common when trying to paste images with Cmd+V),
+            // check if clipboard has an image (macOS only)
+            if (isMacOS && onImagePaste && pastedText.length === 0) {
+              checkClipboardForImage()
+              return { chunks: [], timeoutId: null }
+            }
+
+            // Handle regular paste
+            if (onPaste) {
+              onPaste(pastedText)
+            }
+            // Reset isPasting state after paste is complete
+            setIsPasting(false)
+            return { chunks: [], timeoutId: null }
+          })
+        },
+        PASTE_COMPLETION_TIMEOUT_MS,
+        setPasteState,
+        onImagePaste,
+        onPaste,
+        setIsPasting,
+        checkClipboardForImage,
+        isMacOS,
+        pastePendingRef,
+      )
+    },
+    [checkClipboardForImage, isMacOS, onImagePaste, onPaste],
+  )
+
+  // Paste detection is now done via the InputEvent's keypress.isPasted flag,
+  // which is set by the keypress parser when it detects bracketed paste mode.
+  // This avoids the race condition caused by having multiple listeners on stdin.
+  // Previously, we had a stdin.on('data') listener here which competed with
+  // the 'readable' listener in App.tsx, causing dropped characters.
+
+  const wrappedOnInput = (input: string, key: Key, event: InputEvent): void => {
+    // Detect paste from the parsed keypress event.
+    // The keypress parser sets isPasted=true for content within bracketed paste.
+    const isFromPaste = event.keypress.isPasted
+
+    // If this is pasted content, set isPasting state for UI feedback
+    if (isFromPaste) {
+      setIsPasting(true)
+    }
+
+    // Handle large pastes (>PASTE_THRESHOLD chars)
+    // Usually we get one or two input characters at a time. If we
+    // get more than the threshold, the user has probably pasted.
+    // Unfortunately node batches long pastes, so it's possible
+    // that we would see e.g. 1024 characters and then just a few
+    // more in the next frame that belong with the original paste.
+    // This batching number is not consistent.
+
+    // Handle potential image filenames (even if they're shorter than paste threshold)
+    // When dragging multiple images, they may come as newline-separated or
+    // space-separated paths. Split on spaces preceding absolute paths:
+    // - Unix: ` /` - Windows: ` C:\` etc.
+    const hasImageFilePath = input
+      .split(/ (?=\/|[A-Za-z]:\\)/)
+      .flatMap(part => part.split('\n'))
+      .some(line => isImageFilePath(line.trim()))
+
+    // Handle empty paste (clipboard image on macOS)
+    // When the user pastes an image with Cmd+V, the terminal sends an empty
+    // bracketed paste sequence. The keypress parser emits this as isPasted=true
+    // with empty input.
+    if (isFromPaste && input.length === 0 && isMacOS && onImagePaste) {
+      checkClipboardForImage()
+      // Reset isPasting since there's no text content to process
+      setIsPasting(false)
+      return
+    }
+
+    // Check if we should handle as paste (from bracketed paste, large input, or continuation)
+    const shouldHandleAsPaste =
+      onPaste &&
+      (input.length > PASTE_THRESHOLD ||
+        pastePendingRef.current ||
+        hasImageFilePath ||
+        isFromPaste)
+
+    if (shouldHandleAsPaste) {
+      pastePendingRef.current = true
+      setPasteState(({ chunks, timeoutId }) => {
+        return {
+          chunks: [...chunks, input],
+          timeoutId: resetPasteTimeout(timeoutId),
+        }
+      })
+      return
+    }
+    onInput(input, key)
+    if (input.length > 10) {
+      // Ensure that setIsPasting is turned off on any other multicharacter
+      // input, because the stdin buffer may chunk at arbitrary points and split
+      // the closing escape sequence if the input length is too long for the
+      // stdin buffer.
+      setIsPasting(false)
+    }
+  }
+
+  return {
+    wrappedOnInput,
+    pasteState,
+    isPasting,
+  }
+}

package/src/hooks/usePluginRecommendationBase.tsx

@@ -0,0 +1,105 @@
+import { c as _c } from "react/compiler-runtime";
+/**
+ * Shared state machine + install helper for plugin-recommendation hooks
+ * (LSP, claude-code-hint). Centralizes the gate chain, async-guard,
+ * and success/failure notification JSX so new sources stay small.
+ */
+
+import figures from 'figures';
+import * as React from 'react';
+import { getIsRemoteMode } from '../bootstrap/state.js';
+import type { useNotifications } from '../context/notifications.js';
+import { Text } from '../ink.js';
+import { logError } from '../utils/log.js';
+import { getPluginById } from '../utils/plugins/marketplaceManager.js';
+type AddNotification = ReturnType<typeof useNotifications>['addNotification'];
+type PluginData = NonNullable<Awaited<ReturnType<typeof getPluginById>>>;
+
+/**
+ * Call tryResolve inside a useEffect; it applies standard gates (remote
+ * mode, already-showing, in-flight) then runs resolve(). Non-null return
+ * becomes the recommendation. Include tryResolve in effect deps — its
+ * identity tracks recommendation, so clearing re-triggers resolution.
+ */
+export function usePluginRecommendationBase() {
+  const $ = _c(6);
+  const [recommendation, setRecommendation] = React.useState(null);
+  const isCheckingRef = React.useRef(false);
+  let t0;
+  if ($[0] !== recommendation) {
+    t0 = resolve => {
+      if (getIsRemoteMode()) {
+        return;
+      }
+      if (recommendation) {
+        return;
+      }
+      if (isCheckingRef.current) {
+        return;
+      }
+      isCheckingRef.current = true;
+      resolve().then(rec => {
+        if (rec) {
+          setRecommendation(rec);
+        }
+      }).catch(logError).finally(() => {
+        isCheckingRef.current = false;
+      });
+    };
+    $[0] = recommendation;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const tryResolve = t0;
+  let t1;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => setRecommendation(null);
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const clearRecommendation = t1;
+  let t2;
+  if ($[3] !== recommendation || $[4] !== tryResolve) {
+    t2 = {
+      recommendation,
+      clearRecommendation,
+      tryResolve
+    };
+    $[3] = recommendation;
+    $[4] = tryResolve;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  return t2;
+}
+
+/** Look up plugin, run install(), emit standard success/failure notification. */
+export async function installPluginAndNotify(pluginId: string, pluginName: string, keyPrefix: string, addNotification: AddNotification, install: (pluginData: PluginData) => Promise<void>): Promise<void> {
+  try {
+    const pluginData = await getPluginById(pluginId);
+    if (!pluginData) {
+      throw new Error(`Plugin ${pluginId} not found in marketplace`);
+    }
+    await install(pluginData);
+    addNotification({
+      key: `${keyPrefix}-installed`,
+      jsx: <Text color="success">
+          {figures.tick} {pluginName} installed · restart to apply
+        </Text>,
+      priority: 'immediate',
+      timeoutMs: 5000
+    });
+  } catch (error) {
+    logError(error);
+    addNotification({
+      key: `${keyPrefix}-install-failed`,
+      jsx: <Text color="error">Failed to install {pluginName}</Text>,
+      priority: 'immediate',
+      timeoutMs: 5000
+    });
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","getIsRemoteMode","useNotifications","Text","logError","getPluginById","AddNotification","ReturnType","PluginData","NonNullable","Awaited","usePluginRecommendationBase","$","_c","recommendation","setRecommendation","useState","isCheckingRef","useRef","t0","resolve","current","then","rec","catch","finally","tryResolve","t1","Symbol","for","clearRecommendation","t2","installPluginAndNotify","pluginId","pluginName","keyPrefix","addNotification","install","pluginData","Promise","Error","key","jsx","tick","priority","timeoutMs","error"],"sources":["usePluginRecommendationBase.tsx"],"sourcesContent":["/**\n * Shared state machine + install helper for plugin-recommendation hooks\n * (LSP, claude-code-hint). Centralizes the gate chain, async-guard,\n * and success/failure notification JSX so new sources stay small.\n */\n\nimport figures from 'figures'\nimport * as React from 'react'\nimport { getIsRemoteMode } from '../bootstrap/state.js'\nimport type { useNotifications } from '../context/notifications.js'\nimport { Text } from '../ink.js'\nimport { logError } from '../utils/log.js'\nimport { getPluginById } from '../utils/plugins/marketplaceManager.js'\n\ntype AddNotification = ReturnType<typeof useNotifications>['addNotification']\ntype PluginData = NonNullable<Awaited<ReturnType<typeof getPluginById>>>\n\n/**\n * Call tryResolve inside a useEffect; it applies standard gates (remote\n * mode, already-showing, in-flight) then runs resolve(). Non-null return\n * becomes the recommendation. Include tryResolve in effect deps — its\n * identity tracks recommendation, so clearing re-triggers resolution.\n */\nexport function usePluginRecommendationBase<T>(): {\n  recommendation: T | null\n  clearRecommendation: () => void\n  tryResolve: (resolve: () => Promise<T | null>) => void\n} {\n  const [recommendation, setRecommendation] = React.useState<T | null>(null)\n  const isCheckingRef = React.useRef(false)\n\n  const tryResolve = React.useCallback(\n    (resolve: () => Promise<T | null>) => {\n      if (getIsRemoteMode()) return\n      if (recommendation) return\n      if (isCheckingRef.current) return\n\n      isCheckingRef.current = true\n      void resolve()\n        .then(rec => {\n          if (rec) setRecommendation(rec)\n        })\n        .catch(logError)\n        .finally(() => {\n          isCheckingRef.current = false\n        })\n    },\n    [recommendation],\n  )\n\n  const clearRecommendation = React.useCallback(\n    () => setRecommendation(null),\n    [],\n  )\n\n  return { recommendation, clearRecommendation, tryResolve }\n}\n\n/** Look up plugin, run install(), emit standard success/failure notification. */\nexport async function installPluginAndNotify(\n  pluginId: string,\n  pluginName: string,\n  keyPrefix: string,\n  addNotification: AddNotification,\n  install: (pluginData: PluginData) => Promise<void>,\n): Promise<void> {\n  try {\n    const pluginData = await getPluginById(pluginId)\n    if (!pluginData) {\n      throw new Error(`Plugin ${pluginId} not found in marketplace`)\n    }\n    await install(pluginData)\n    addNotification({\n      key: `${keyPrefix}-installed`,\n      jsx: (\n        <Text color=\"success\">\n          {figures.tick} {pluginName} installed · restart to apply\n        </Text>\n      ),\n      priority: 'immediate',\n      timeoutMs: 5000,\n    })\n  } catch (error) {\n    logError(error)\n    addNotification({\n      key: `${keyPrefix}-install-failed`,\n      jsx: <Text color=\"error\">Failed to install {pluginName}</Text>,\n      priority: 'immediate',\n      timeoutMs: 5000,\n    })\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/src/hooks/usePrStatus.ts

@@ -0,0 +1,106 @@
+import { useEffect, useRef, useState } from 'react'
+import { getLastInteractionTime } from '../bootstrap/state.js'
+import { fetchPrStatus, type PrReviewState } from '../utils/ghPrStatus.js'
+
+const POLL_INTERVAL_MS = 60_000
+const SLOW_GH_THRESHOLD_MS = 4_000
+const IDLE_STOP_MS = 60 * 60_000 // stop polling after 60 min idle
+
+export type PrStatusState = {
+  number: number | null
+  url: string | null
+  reviewState: PrReviewState | null
+  lastUpdated: number
+}
+
+const INITIAL_STATE: PrStatusState = {
+  number: null,
+  url: null,
+  reviewState: null,
+  lastUpdated: 0,
+}
+
+/**
+ * Polls PR review status every 60s while the session is active.
+ * When no interaction is detected for 60 minutes, the loop stops — no
+ * timers remain. React re-runs the effect when isLoading changes
+ * (turn starts/ends), restarting the loop. Effect setup schedules
+ * the next poll relative to the last fetch time so turn boundaries
+ * don't spawn `gh` more than once per interval. Disables permanently
+ * if a fetch exceeds 4s.
+ *
+ * Pass `enabled: false` to skip polling entirely (hook still must be
+ * called unconditionally to satisfy the rules of hooks).
+ */
+export function usePrStatus(isLoading: boolean, enabled = true): PrStatusState {
+  const [prStatus, setPrStatus] = useState<PrStatusState>(INITIAL_STATE)
+  const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
+  const disabledRef = useRef(false)
+  const lastFetchRef = useRef(0)
+
+  useEffect(() => {
+    if (!enabled) return
+    if (disabledRef.current) return
+
+    let cancelled = false
+    let lastSeenInteractionTime = -1
+    let lastActivityTimestamp = Date.now()
+
+    async function poll() {
+      if (cancelled) return
+
+      const currentInteractionTime = getLastInteractionTime()
+      if (lastSeenInteractionTime !== currentInteractionTime) {
+        lastSeenInteractionTime = currentInteractionTime
+        lastActivityTimestamp = Date.now()
+      } else if (Date.now() - lastActivityTimestamp >= IDLE_STOP_MS) {
+        return
+      }
+
+      const start = Date.now()
+      const result = await fetchPrStatus()
+      if (cancelled) return
+      lastFetchRef.current = start
+
+      setPrStatus(prev => {
+        const newNumber = result?.number ?? null
+        const newReviewState = result?.reviewState ?? null
+        if (prev.number === newNumber && prev.reviewState === newReviewState) {
+          return prev
+        }
+        return {
+          number: newNumber,
+          url: result?.url ?? null,
+          reviewState: newReviewState,
+          lastUpdated: Date.now(),
+        }
+      })
+
+      if (Date.now() - start > SLOW_GH_THRESHOLD_MS) {
+        disabledRef.current = true
+        return
+      }
+
+      if (!cancelled) {
+        timeoutRef.current = setTimeout(poll, POLL_INTERVAL_MS)
+      }
+    }
+
+    const elapsed = Date.now() - lastFetchRef.current
+    if (elapsed >= POLL_INTERVAL_MS) {
+      void poll()
+    } else {
+      timeoutRef.current = setTimeout(poll, POLL_INTERVAL_MS - elapsed)
+    }
+
+    return () => {
+      cancelled = true
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current)
+        timeoutRef.current = null
+      }
+    }
+  }, [isLoading, enabled])
+
+  return prStatus
+}

package/src/hooks/usePromptSuggestion.ts

@@ -0,0 +1,177 @@
+import { useCallback, useRef } from 'react'
+import { useTerminalFocus } from '../ink/hooks/use-terminal-focus.js'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from '../services/analytics/index.js'
+import { abortSpeculation } from '../services/PromptSuggestion/speculation.js'
+import { useAppState, useSetAppState } from '../state/AppState.js'
+
+type Props = {
+  inputValue: string
+  isAssistantResponding: boolean
+}
+
+export function usePromptSuggestion({
+  inputValue,
+  isAssistantResponding,
+}: Props): {
+  suggestion: string | null
+  markAccepted: () => void
+  markShown: () => void
+  logOutcomeAtSubmission: (
+    finalInput: string,
+    opts?: { skipReset: boolean },
+  ) => void
+} {
+  const promptSuggestion = useAppState(s => s.promptSuggestion)
+  const setAppState = useSetAppState()
+  const isTerminalFocused = useTerminalFocus()
+  const {
+    text: suggestionText,
+    promptId,
+    shownAt,
+    acceptedAt,
+    generationRequestId,
+  } = promptSuggestion
+
+  const suggestion =
+    isAssistantResponding || inputValue.length > 0 ? null : suggestionText
+
+  const isValidSuggestion = suggestionText && shownAt > 0
+
+  // Track engagement depth for telemetry
+  const firstKeystrokeAt = useRef<number>(0)
+  const wasFocusedWhenShown = useRef<boolean>(true)
+  const prevShownAt = useRef<number>(0)
+
+  // Capture focus state when a new suggestion appears (shownAt changes)
+  if (shownAt > 0 && shownAt !== prevShownAt.current) {
+    prevShownAt.current = shownAt
+    wasFocusedWhenShown.current = isTerminalFocused
+    firstKeystrokeAt.current = 0
+  } else if (shownAt === 0) {
+    prevShownAt.current = 0
+  }
+
+  // Record first keystroke while suggestion is visible
+  if (
+    inputValue.length > 0 &&
+    firstKeystrokeAt.current === 0 &&
+    isValidSuggestion
+  ) {
+    firstKeystrokeAt.current = Date.now()
+  }
+
+  const resetSuggestion = useCallback(() => {
+    abortSpeculation(setAppState)
+
+    setAppState(prev => ({
+      ...prev,
+      promptSuggestion: {
+        text: null,
+        promptId: null,
+        shownAt: 0,
+        acceptedAt: 0,
+        generationRequestId: null,
+      },
+    }))
+  }, [setAppState])
+
+  const markAccepted = useCallback(() => {
+    if (!isValidSuggestion) return
+    setAppState(prev => ({
+      ...prev,
+      promptSuggestion: {
+        ...prev.promptSuggestion,
+        acceptedAt: Date.now(),
+      },
+    }))
+  }, [isValidSuggestion, setAppState])
+
+  const markShown = useCallback(() => {
+    // Check shownAt inside setAppState callback to avoid depending on it
+    // (depending on shownAt causes infinite loop when this callback is called)
+    setAppState(prev => {
+      // Only mark shown if not already shown and suggestion exists
+      if (prev.promptSuggestion.shownAt !== 0 || !prev.promptSuggestion.text) {
+        return prev
+      }
+      return {
+        ...prev,
+        promptSuggestion: {
+          ...prev.promptSuggestion,
+          shownAt: Date.now(),
+        },
+      }
+    })
+  }, [setAppState])
+
+  const logOutcomeAtSubmission = useCallback(
+    (finalInput: string, opts?: { skipReset: boolean }) => {
+      if (!isValidSuggestion) return
+
+      // Determine if accepted: either Tab was pressed (acceptedAt set) OR
+      // final input matches suggestion (empty Enter case)
+      const tabWasPressed = acceptedAt > shownAt
+      const wasAccepted = tabWasPressed || finalInput === suggestionText
+      const timeMs = wasAccepted ? acceptedAt || Date.now() : Date.now()
+
+      logEvent('tengu_prompt_suggestion', {
+        source:
+          'cli' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        outcome: (wasAccepted
+          ? 'accepted'
+          : 'ignored') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        prompt_id:
+          promptId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        ...(generationRequestId && {
+          generationRequestId:
+            generationRequestId as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        }),
+        ...(wasAccepted && {
+          acceptMethod: (tabWasPressed
+            ? 'tab'
+            : 'enter') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        }),
+        ...(wasAccepted && {
+          timeToAcceptMs: timeMs - shownAt,
+        }),
+        ...(!wasAccepted && {
+          timeToIgnoreMs: timeMs - shownAt,
+        }),
+        ...(firstKeystrokeAt.current > 0 && {
+          timeToFirstKeystrokeMs: firstKeystrokeAt.current - shownAt,
+        }),
+        wasFocusedWhenShown: wasFocusedWhenShown.current,
+        similarity:
+          Math.round(
+            (finalInput.length / (suggestionText?.length || 1)) * 100,
+          ) / 100,
+        ...(process.env.USER_TYPE === 'ant' && {
+          suggestion:
+            suggestionText as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          userInput:
+            finalInput as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        }),
+      })
+      if (!opts?.skipReset) resetSuggestion()
+    },
+    [
+      isValidSuggestion,
+      acceptedAt,
+      shownAt,
+      suggestionText,
+      promptId,
+      generationRequestId,
+      resetSuggestion,
+    ],
+  )
+
+  return {
+    suggestion,
+    markAccepted,
+    markShown,
+    logOutcomeAtSubmission,
+  }
+}