@xelauvas/xela-cli 0.1.0

package/src/components/TeleportResumeWrapper.tsx

@@ -0,0 +1,167 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useEffect } from 'react';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from 'src/services/analytics/index.js';
+import type { TeleportRemoteResponse } from 'src/utils/conversationRecovery.js';
+import type { CodeSession } from 'src/utils/teleport/api.js';
+import { type TeleportSource, useTeleportResume } from '../hooks/useTeleportResume.js';
+import { Box, Text } from '../ink.js';
+import { useKeybinding } from '../keybindings/useKeybinding.js';
+import { ResumeTask } from './ResumeTask.js';
+import { Spinner } from './Spinner.js';
+interface TeleportResumeWrapperProps {
+  onComplete: (result: TeleportRemoteResponse) => void;
+  onCancel: () => void;
+  onError?: (error: string, formattedMessage?: string) => void;
+  isEmbedded?: boolean;
+  source: TeleportSource;
+}
+
+/**
+ * Wrapper component that manages the full teleport resume flow,
+ * including session selection, loading state, and error handling
+ */
+export function TeleportResumeWrapper(t0) {
+  const $ = _c(25);
+  const {
+    onComplete,
+    onCancel,
+    onError,
+    isEmbedded: t1,
+    source
+  } = t0;
+  const isEmbedded = t1 === undefined ? false : t1;
+  const {
+    resumeSession,
+    isResuming,
+    error,
+    selectedSession
+  } = useTeleportResume(source);
+  let t2;
+  let t3;
+  if ($[0] !== source) {
+    t2 = () => {
+      logEvent("tengu_teleport_started", {
+        source: source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+      });
+    };
+    t3 = [source];
+    $[0] = source;
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t2 = $[1];
+    t3 = $[2];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[3] !== error || $[4] !== onComplete || $[5] !== onError || $[6] !== resumeSession) {
+    t4 = async session => {
+      const result = await resumeSession(session);
+      if (result) {
+        onComplete(result);
+      } else {
+        if (error) {
+          if (onError) {
+            onError(error.message, error.formattedMessage);
+          }
+        }
+      }
+    };
+    $[3] = error;
+    $[4] = onComplete;
+    $[5] = onError;
+    $[6] = resumeSession;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const handleSelect = t4;
+  let t5;
+  if ($[8] !== onCancel) {
+    t5 = () => {
+      logEvent("tengu_teleport_cancelled", {});
+      onCancel();
+    };
+    $[8] = onCancel;
+    $[9] = t5;
+  } else {
+    t5 = $[9];
+  }
+  const handleCancel = t5;
+  const t6 = !!error && !onError;
+  let t7;
+  if ($[10] !== t6) {
+    t7 = {
+      context: "Global",
+      isActive: t6
+    };
+    $[10] = t6;
+    $[11] = t7;
+  } else {
+    t7 = $[11];
+  }
+  useKeybinding("app:interrupt", handleCancel, t7);
+  if (isResuming && selectedSession) {
+    let t8;
+    if ($[12] === Symbol.for("react.memo_cache_sentinel")) {
+      t8 = <Box flexDirection="row"><Spinner /><Text bold={true}>Resuming session…</Text></Box>;
+      $[12] = t8;
+    } else {
+      t8 = $[12];
+    }
+    let t9;
+    if ($[13] !== selectedSession.title) {
+      t9 = <Box flexDirection="column" padding={1}>{t8}<Text dimColor={true}>Loading "{selectedSession.title}"…</Text></Box>;
+      $[13] = selectedSession.title;
+      $[14] = t9;
+    } else {
+      t9 = $[14];
+    }
+    return t9;
+  }
+  if (error && !onError) {
+    let t8;
+    if ($[15] === Symbol.for("react.memo_cache_sentinel")) {
+      t8 = <Text bold={true} color="error">Failed to resume session</Text>;
+      $[15] = t8;
+    } else {
+      t8 = $[15];
+    }
+    let t9;
+    if ($[16] !== error.message) {
+      t9 = <Text dimColor={true}>{error.message}</Text>;
+      $[16] = error.message;
+      $[17] = t9;
+    } else {
+      t9 = $[17];
+    }
+    let t10;
+    if ($[18] === Symbol.for("react.memo_cache_sentinel")) {
+      t10 = <Box marginTop={1}><Text dimColor={true}>Press <Text bold={true}>Esc</Text> to cancel</Text></Box>;
+      $[18] = t10;
+    } else {
+      t10 = $[18];
+    }
+    let t11;
+    if ($[19] !== t9) {
+      t11 = <Box flexDirection="column" padding={1}>{t8}{t9}{t10}</Box>;
+      $[19] = t9;
+      $[20] = t11;
+    } else {
+      t11 = $[20];
+    }
+    return t11;
+  }
+  let t8;
+  if ($[21] !== handleCancel || $[22] !== handleSelect || $[23] !== isEmbedded) {
+    t8 = <ResumeTask onSelect={handleSelect} onCancel={handleCancel} isEmbedded={isEmbedded} />;
+    $[21] = handleCancel;
+    $[22] = handleSelect;
+    $[23] = isEmbedded;
+    $[24] = t8;
+  } else {
+    t8 = $[24];
+  }
+  return t8;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS","logEvent","TeleportRemoteResponse","CodeSession","TeleportSource","useTeleportResume","Box","Text","useKeybinding","ResumeTask","Spinner","TeleportResumeWrapperProps","onComplete","result","onCancel","onError","error","formattedMessage","isEmbedded","source","TeleportResumeWrapper","t0","$","_c","t1","undefined","resumeSession","isResuming","selectedSession","t2","t3","t4","session","message","handleSelect","t5","handleCancel","t6","t7","context","isActive","t8","Symbol","for","t9","title","t10","t11"],"sources":["TeleportResumeWrapper.tsx"],"sourcesContent":["import React, { useEffect } from 'react'\nimport {\n  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n  logEvent,\n} from 'src/services/analytics/index.js'\nimport type { TeleportRemoteResponse } from 'src/utils/conversationRecovery.js'\nimport type { CodeSession } from 'src/utils/teleport/api.js'\nimport {\n  type TeleportSource,\n  useTeleportResume,\n} from '../hooks/useTeleportResume.js'\nimport { Box, Text } from '../ink.js'\nimport { useKeybinding } from '../keybindings/useKeybinding.js'\nimport { ResumeTask } from './ResumeTask.js'\nimport { Spinner } from './Spinner.js'\n\ninterface TeleportResumeWrapperProps {\n  onComplete: (result: TeleportRemoteResponse) => void\n  onCancel: () => void\n  onError?: (error: string, formattedMessage?: string) => void\n  isEmbedded?: boolean\n  source: TeleportSource\n}\n\n/**\n * Wrapper component that manages the full teleport resume flow,\n * including session selection, loading state, and error handling\n */\nexport function TeleportResumeWrapper({\n  onComplete,\n  onCancel,\n  onError,\n  isEmbedded = false,\n  source,\n}: TeleportResumeWrapperProps): React.ReactNode {\n  const { resumeSession, isResuming, error, selectedSession } =\n    useTeleportResume(source)\n\n  // Log when teleport flow starts (for funnel tracking)\n  useEffect(() => {\n    logEvent('tengu_teleport_started', {\n      source:\n        source as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,\n    })\n  }, [source])\n\n  const handleSelect = async (session: CodeSession) => {\n    const result = await resumeSession(session)\n    if (result) {\n      onComplete(result)\n    } else if (error) {\n      // If there's an error handler provided, use it\n      if (onError) {\n        onError(error.message, error.formattedMessage)\n      }\n      // Otherwise the error will be displayed in the UI\n    }\n  }\n\n  const handleCancel = () => {\n    logEvent('tengu_teleport_cancelled', {})\n    onCancel()\n  }\n\n  // Allow Esc to dismiss the error state\n  useKeybinding('app:interrupt', handleCancel, {\n    context: 'Global',\n    isActive: !!error && !onError,\n  })\n\n  // Show loading spinner when resuming\n  if (isResuming && selectedSession) {\n    return (\n      <Box flexDirection=\"column\" padding={1}>\n        <Box flexDirection=\"row\">\n          <Spinner />\n          <Text bold>Resuming session…</Text>\n        </Box>\n        <Text dimColor>Loading &quot;{selectedSession.title}&quot;…</Text>\n      </Box>\n    )\n  }\n\n  // Show error if there was a problem resuming\n  if (error && !onError) {\n    return (\n      <Box flexDirection=\"column\" padding={1}>\n        <Text bold color=\"error\">\n          Failed to resume session\n        </Text>\n        <Text dimColor>{error.message}</Text>\n        <Box marginTop={1}>\n          <Text dimColor>\n            Press <Text bold>Esc</Text> to cancel\n          </Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  return (\n    <ResumeTask\n      onSelect={handleSelect}\n      onCancel={handleCancel}\n      isEmbedded={isEmbedded}\n    />\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/TeleportStash.tsx

@@ -0,0 +1,116 @@
+import figures from 'figures';
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from '../ink.js';
+import { logForDebugging } from '../utils/debug.js';
+import type { GitFileStatus } from '../utils/git.js';
+import { getFileStatus, stashToCleanState } from '../utils/git.js';
+import { Select } from './CustomSelect/index.js';
+import { Dialog } from './design-system/Dialog.js';
+import { Spinner } from './Spinner.js';
+type TeleportStashProps = {
+  onStashAndContinue: () => void;
+  onCancel: () => void;
+};
+export function TeleportStash({
+  onStashAndContinue,
+  onCancel
+}: TeleportStashProps): React.ReactNode {
+  const [gitFileStatus, setGitFileStatus] = useState<GitFileStatus | null>(null);
+  const changedFiles = gitFileStatus !== null ? [...gitFileStatus.tracked, ...gitFileStatus.untracked] : [];
+  const [loading, setLoading] = useState(true);
+  const [stashing, setStashing] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Load changed files on mount
+  useEffect(() => {
+    const loadChangedFiles = async () => {
+      try {
+        const fileStatus = await getFileStatus();
+        setGitFileStatus(fileStatus);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        logForDebugging(`Error getting changed files: ${errorMessage}`, {
+          level: 'error'
+        });
+        setError('Failed to get changed files');
+      } finally {
+        setLoading(false);
+      }
+    };
+    void loadChangedFiles();
+  }, []);
+  const handleStash = async () => {
+    setStashing(true);
+    try {
+      logForDebugging('Stashing changes before teleport...');
+      const success = await stashToCleanState('Teleport auto-stash');
+      if (success) {
+        logForDebugging('Successfully stashed changes');
+        onStashAndContinue();
+      } else {
+        setError('Failed to stash changes');
+      }
+    } catch (err_0) {
+      const errorMessage_0 = err_0 instanceof Error ? err_0.message : String(err_0);
+      logForDebugging(`Error stashing changes: ${errorMessage_0}`, {
+        level: 'error'
+      });
+      setError('Failed to stash changes');
+    } finally {
+      setStashing(false);
+    }
+  };
+  const handleSelectChange = (value: string) => {
+    if (value === 'stash') {
+      void handleStash();
+    } else {
+      onCancel();
+    }
+  };
+  if (loading) {
+    return <Box flexDirection="column" padding={1}>
+        <Box marginBottom={1}>
+          <Spinner />
+          <Text> Checking git status{figures.ellipsis}</Text>
+        </Box>
+      </Box>;
+  }
+  if (error) {
+    return <Box flexDirection="column" padding={1}>
+        <Text bold color="error">
+          Error: {error}
+        </Text>
+        <Box marginTop={1}>
+          <Text dimColor>Press </Text>
+          <Text bold>Escape</Text>
+          <Text dimColor> to cancel</Text>
+        </Box>
+      </Box>;
+  }
+  const showFileCount = changedFiles.length > 8;
+  return <Dialog title="Working Directory Has Changes" onCancel={onCancel}>
+      <Text>
+        Teleport will switch git branches. The following changes were found:
+      </Text>
+
+      <Box flexDirection="column" paddingLeft={2}>
+        {changedFiles.length > 0 ? showFileCount ? <Text>{changedFiles.length} files changed</Text> : changedFiles.map((file: string, index: number) => <Text key={index}>{file}</Text>) : <Text dimColor>No changes detected</Text>}
+      </Box>
+
+      <Text>
+        Would you like to stash these changes and continue with teleport?
+      </Text>
+
+      {stashing ? <Box>
+          <Spinner />
+          <Text> Stashing changes...</Text>
+        </Box> : <Select options={[{
+      label: 'Stash changes and continue',
+      value: 'stash'
+    }, {
+      label: 'Exit',
+      value: 'exit'
+    }]} onChange={handleSelectChange} />}
+    </Dialog>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["figures","React","useEffect","useState","Box","Text","logForDebugging","GitFileStatus","getFileStatus","stashToCleanState","Select","Dialog","Spinner","TeleportStashProps","onStashAndContinue","onCancel","TeleportStash","ReactNode","gitFileStatus","setGitFileStatus","changedFiles","tracked","untracked","loading","setLoading","stashing","setStashing","error","setError","loadChangedFiles","fileStatus","err","errorMessage","Error","message","String","level","handleStash","success","handleSelectChange","value","ellipsis","showFileCount","length","map","file","index","label"],"sources":["TeleportStash.tsx"],"sourcesContent":["import figures from 'figures'\nimport React, { useEffect, useState } from 'react'\nimport { Box, Text } from '../ink.js'\nimport { logForDebugging } from '../utils/debug.js'\nimport type { GitFileStatus } from '../utils/git.js'\nimport { getFileStatus, stashToCleanState } from '../utils/git.js'\nimport { Select } from './CustomSelect/index.js'\nimport { Dialog } from './design-system/Dialog.js'\nimport { Spinner } from './Spinner.js'\n\ntype TeleportStashProps = {\n  onStashAndContinue: () => void\n  onCancel: () => void\n}\n\nexport function TeleportStash({\n  onStashAndContinue,\n  onCancel,\n}: TeleportStashProps): React.ReactNode {\n  const [gitFileStatus, setGitFileStatus] = useState<GitFileStatus | null>(null)\n  const changedFiles =\n    gitFileStatus !== null\n      ? [...gitFileStatus.tracked, ...gitFileStatus.untracked]\n      : []\n  const [loading, setLoading] = useState(true)\n  const [stashing, setStashing] = useState(false)\n  const [error, setError] = useState<string | null>(null)\n\n  // Load changed files on mount\n  useEffect(() => {\n    const loadChangedFiles = async () => {\n      try {\n        const fileStatus = await getFileStatus()\n        setGitFileStatus(fileStatus)\n      } catch (err) {\n        const errorMessage = err instanceof Error ? err.message : String(err)\n        logForDebugging(`Error getting changed files: ${errorMessage}`, {\n          level: 'error',\n        })\n        setError('Failed to get changed files')\n      } finally {\n        setLoading(false)\n      }\n    }\n\n    void loadChangedFiles()\n  }, [])\n\n  const handleStash = async () => {\n    setStashing(true)\n    try {\n      logForDebugging('Stashing changes before teleport...')\n      const success = await stashToCleanState('Teleport auto-stash')\n\n      if (success) {\n        logForDebugging('Successfully stashed changes')\n        onStashAndContinue()\n      } else {\n        setError('Failed to stash changes')\n      }\n    } catch (err) {\n      const errorMessage = err instanceof Error ? err.message : String(err)\n      logForDebugging(`Error stashing changes: ${errorMessage}`, {\n        level: 'error',\n      })\n      setError('Failed to stash changes')\n    } finally {\n      setStashing(false)\n    }\n  }\n\n  const handleSelectChange = (value: string) => {\n    if (value === 'stash') {\n      void handleStash()\n    } else {\n      onCancel()\n    }\n  }\n\n  if (loading) {\n    return (\n      <Box flexDirection=\"column\" padding={1}>\n        <Box marginBottom={1}>\n          <Spinner />\n          <Text> Checking git status{figures.ellipsis}</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  if (error) {\n    return (\n      <Box flexDirection=\"column\" padding={1}>\n        <Text bold color=\"error\">\n          Error: {error}\n        </Text>\n        <Box marginTop={1}>\n          <Text dimColor>Press </Text>\n          <Text bold>Escape</Text>\n          <Text dimColor> to cancel</Text>\n        </Box>\n      </Box>\n    )\n  }\n\n  const showFileCount = changedFiles.length > 8\n\n  return (\n    <Dialog title=\"Working Directory Has Changes\" onCancel={onCancel}>\n      <Text>\n        Teleport will switch git branches. The following changes were found:\n      </Text>\n\n      <Box flexDirection=\"column\" paddingLeft={2}>\n        {changedFiles.length > 0 ? (\n          showFileCount ? (\n            <Text>{changedFiles.length} files changed</Text>\n          ) : (\n            changedFiles.map((file: string, index: number) => (\n              <Text key={index}>{file}</Text>\n            ))\n          )\n        ) : (\n          <Text dimColor>No changes detected</Text>\n        )}\n      </Box>\n\n      <Text>\n        Would you like to stash these changes and continue with teleport?\n      </Text>\n\n      {stashing ? (\n        <Box>\n          <Spinner />\n          <Text> Stashing changes...</Text>\n        </Box>\n      ) : (\n        <Select\n          options={[\n            { label: 'Stash changes and continue', value: 'stash' },\n            { label: 'Exit', value: 'exit' },\n          ]}\n          onChange={handleSelectChange}\n        />\n      )}\n    </Dialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/TextInput.tsx

@@ -0,0 +1,124 @@
+import { feature } from 'bun:bundle';
+import chalk from 'chalk';
+import React, { useMemo, useRef } from 'react';
+import { useVoiceState } from '../context/voice.js';
+import { useClipboardImageHint } from '../hooks/useClipboardImageHint.js';
+import { useSettings } from '../hooks/useSettings.js';
+import { useTextInput } from '../hooks/useTextInput.js';
+import { Box, color, useAnimationFrame, useTerminalFocus, useTheme } from '../ink.js';
+import type { BaseTextInputProps } from '../types/textInputTypes.js';
+import { isEnvTruthy } from '../utils/envUtils.js';
+import type { TextHighlight } from '../utils/textHighlighting.js';
+import { BaseTextInput } from './BaseTextInput.js';
+import { hueToRgb } from './Spinner/utils.js';
+
+// Block characters for waveform bars: space (silent) + 8 rising block elements.
+const BARS = ' \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588';
+
+// Mini waveform cursor width
+const CURSOR_WAVEFORM_WIDTH = 1;
+
+// Smoothing factor (0 = instant, 1 = frozen). Applied as EMA to
+// smooth both rises and falls for a steady, non-jittery bar.
+const SMOOTH = 0.7;
+
+// Boost factor for audio levels — computeLevel normalizes with a
+// conservative divisor (rms/2000), so normal speech sits around
+// 0.3-0.5. This multiplier lets the bar use the full range.
+const LEVEL_BOOST = 1.8;
+
+// Raw audio level threshold (pre-boost) below which the cursor is
+// grey. computeLevel returns sqrt(rms/2000), so ambient mic noise
+// typically sits at 0.05-0.15. Speech starts around 0.2+.
+const SILENCE_THRESHOLD = 0.15;
+export type Props = BaseTextInputProps & {
+  highlights?: TextHighlight[];
+};
+export default function TextInput(props: Props): React.ReactNode {
+  const [theme] = useTheme();
+  const isTerminalFocused = useTerminalFocus();
+  // Hoisted to mount-time — this component re-renders on every keystroke.
+  const accessibilityEnabled = useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY), []);
+  const settings = useSettings();
+  const reducedMotion = settings.prefersReducedMotion ?? false;
+  const voiceState = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s => s.voiceState) : 'idle' as const;
+  const isVoiceRecording = voiceState === 'recording';
+  const audioLevels = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useVoiceState(s_0 => s_0.voiceAudioLevels) : [];
+  const smoothedRef = useRef<number[]>(new Array(CURSOR_WAVEFORM_WIDTH).fill(0));
+  const needsAnimation = isVoiceRecording && !reducedMotion;
+  const [animRef, animTime] = feature('VOICE_MODE') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useAnimationFrame(needsAnimation ? 50 : null) : [() => {}, 0];
+
+  // Show hint when terminal regains focus and clipboard has an image
+  useClipboardImageHint(isTerminalFocused, !!props.onImagePaste);
+
+  // Cursor invert function: mini waveform during voice recording,
+  // standard chalk.inverse otherwise. No warmup pulse — the ~120ms
+  // warmup window is too short for a 1s-period pulse to register, and
+  // driving TextInput re-renders at 50ms during warmup (while spaces
+  // are simultaneously arriving every 30-80ms) causes visible stutter.
+  const canShowCursor = isTerminalFocused && !accessibilityEnabled;
+  let invert: (text: string) => string;
+  if (!canShowCursor) {
+    invert = (text: string) => text;
+  } else if (isVoiceRecording && !reducedMotion) {
+    // Single-bar waveform from the latest audio level
+    const smoothed = smoothedRef.current;
+    const raw = audioLevels.length > 0 ? audioLevels[audioLevels.length - 1] ?? 0 : 0;
+    const target = Math.min(raw * LEVEL_BOOST, 1);
+    smoothed[0] = (smoothed[0] ?? 0) * SMOOTH + target * (1 - SMOOTH);
+    const displayLevel = smoothed[0] ?? 0;
+    const barIndex = Math.max(1, Math.min(Math.round(displayLevel * (BARS.length - 1)), BARS.length - 1));
+    const isSilent = raw < SILENCE_THRESHOLD;
+    const hue = animTime / 1000 * 90 % 360;
+    const {
+      r,
+      g,
+      b
+    } = isSilent ? {
+      r: 128,
+      g: 128,
+      b: 128
+    } : hueToRgb(hue);
+    invert = () => chalk.rgb(r, g, b)(BARS[barIndex]!);
+  } else {
+    invert = chalk.inverse;
+  }
+  const textInputState = useTextInput({
+    value: props.value,
+    onChange: props.onChange,
+    onSubmit: props.onSubmit,
+    onExit: props.onExit,
+    onExitMessage: props.onExitMessage,
+    onHistoryReset: props.onHistoryReset,
+    onHistoryUp: props.onHistoryUp,
+    onHistoryDown: props.onHistoryDown,
+    onClearInput: props.onClearInput,
+    focus: props.focus,
+    mask: props.mask,
+    multiline: props.multiline,
+    cursorChar: props.showCursor ? ' ' : '',
+    highlightPastedText: props.highlightPastedText,
+    invert,
+    themeText: color('text', theme),
+    columns: props.columns,
+    maxVisibleLines: props.maxVisibleLines,
+    onImagePaste: props.onImagePaste,
+    disableCursorMovementForUpDownKeys: props.disableCursorMovementForUpDownKeys,
+    disableEscapeDoublePress: props.disableEscapeDoublePress,
+    externalOffset: props.cursorOffset,
+    onOffsetChange: props.onChangeCursorOffset,
+    inputFilter: props.inputFilter,
+    inlineGhostText: props.inlineGhostText,
+    dim: chalk.dim
+  });
+  return <Box ref={animRef}>
+      <BaseTextInput inputState={textInputState} terminalFocus={isTerminalFocused} highlights={props.highlights} invert={invert} hidePlaceholderText={isVoiceRecording} {...props} />
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","chalk","React","useMemo","useRef","useVoiceState","useClipboardImageHint","useSettings","useTextInput","Box","color","useAnimationFrame","useTerminalFocus","useTheme","BaseTextInputProps","isEnvTruthy","TextHighlight","BaseTextInput","hueToRgb","BARS","CURSOR_WAVEFORM_WIDTH","SMOOTH","LEVEL_BOOST","SILENCE_THRESHOLD","Props","highlights","TextInput","props","ReactNode","theme","isTerminalFocused","accessibilityEnabled","process","env","CLAUDE_CODE_ACCESSIBILITY","settings","reducedMotion","prefersReducedMotion","voiceState","s","const","isVoiceRecording","audioLevels","voiceAudioLevels","smoothedRef","Array","fill","needsAnimation","animRef","animTime","onImagePaste","canShowCursor","invert","text","smoothed","current","raw","length","target","Math","min","displayLevel","barIndex","max","round","isSilent","hue","r","g","b","rgb","inverse","textInputState","value","onChange","onSubmit","onExit","onExitMessage","onHistoryReset","onHistoryUp","onHistoryDown","onClearInput","focus","mask","multiline","cursorChar","showCursor","highlightPastedText","themeText","columns","maxVisibleLines","disableCursorMovementForUpDownKeys","disableEscapeDoublePress","externalOffset","cursorOffset","onOffsetChange","onChangeCursorOffset","inputFilter","inlineGhostText","dim"],"sources":["TextInput.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport chalk from 'chalk'\nimport React, { useMemo, useRef } from 'react'\nimport { useVoiceState } from '../context/voice.js'\nimport { useClipboardImageHint } from '../hooks/useClipboardImageHint.js'\nimport { useSettings } from '../hooks/useSettings.js'\nimport { useTextInput } from '../hooks/useTextInput.js'\nimport {\n  Box,\n  color,\n  useAnimationFrame,\n  useTerminalFocus,\n  useTheme,\n} from '../ink.js'\nimport type { BaseTextInputProps } from '../types/textInputTypes.js'\nimport { isEnvTruthy } from '../utils/envUtils.js'\nimport type { TextHighlight } from '../utils/textHighlighting.js'\nimport { BaseTextInput } from './BaseTextInput.js'\nimport { hueToRgb } from './Spinner/utils.js'\n\n// Block characters for waveform bars: space (silent) + 8 rising block elements.\nconst BARS = ' \\u2581\\u2582\\u2583\\u2584\\u2585\\u2586\\u2587\\u2588'\n\n// Mini waveform cursor width\nconst CURSOR_WAVEFORM_WIDTH = 1\n\n// Smoothing factor (0 = instant, 1 = frozen). Applied as EMA to\n// smooth both rises and falls for a steady, non-jittery bar.\nconst SMOOTH = 0.7\n\n// Boost factor for audio levels — computeLevel normalizes with a\n// conservative divisor (rms/2000), so normal speech sits around\n// 0.3-0.5. This multiplier lets the bar use the full range.\nconst LEVEL_BOOST = 1.8\n\n// Raw audio level threshold (pre-boost) below which the cursor is\n// grey. computeLevel returns sqrt(rms/2000), so ambient mic noise\n// typically sits at 0.05-0.15. Speech starts around 0.2+.\nconst SILENCE_THRESHOLD = 0.15\n\nexport type Props = BaseTextInputProps & {\n  highlights?: TextHighlight[]\n}\n\nexport default function TextInput(props: Props): React.ReactNode {\n  const [theme] = useTheme()\n  const isTerminalFocused = useTerminalFocus()\n  // Hoisted to mount-time — this component re-renders on every keystroke.\n  const accessibilityEnabled = useMemo(\n    () => isEnvTruthy(process.env.CLAUDE_CODE_ACCESSIBILITY),\n    [],\n  )\n  const settings = useSettings()\n  const reducedMotion = settings.prefersReducedMotion ?? false\n\n  const voiceState = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceState)\n    : ('idle' as const)\n  const isVoiceRecording = voiceState === 'recording'\n\n  const audioLevels = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useVoiceState(s => s.voiceAudioLevels)\n    : []\n  const smoothedRef = useRef<number[]>(new Array(CURSOR_WAVEFORM_WIDTH).fill(0))\n\n  const needsAnimation = isVoiceRecording && !reducedMotion\n  const [animRef, animTime] = feature('VOICE_MODE')\n    ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n      useAnimationFrame(needsAnimation ? 50 : null)\n    : [() => {}, 0]\n\n  // Show hint when terminal regains focus and clipboard has an image\n  useClipboardImageHint(isTerminalFocused, !!props.onImagePaste)\n\n  // Cursor invert function: mini waveform during voice recording,\n  // standard chalk.inverse otherwise. No warmup pulse — the ~120ms\n  // warmup window is too short for a 1s-period pulse to register, and\n  // driving TextInput re-renders at 50ms during warmup (while spaces\n  // are simultaneously arriving every 30-80ms) causes visible stutter.\n  const canShowCursor = isTerminalFocused && !accessibilityEnabled\n  let invert: (text: string) => string\n  if (!canShowCursor) {\n    invert = (text: string) => text\n  } else if (isVoiceRecording && !reducedMotion) {\n    // Single-bar waveform from the latest audio level\n    const smoothed = smoothedRef.current\n    const raw =\n      audioLevels.length > 0 ? (audioLevels[audioLevels.length - 1] ?? 0) : 0\n    const target = Math.min(raw * LEVEL_BOOST, 1)\n    smoothed[0] = (smoothed[0] ?? 0) * SMOOTH + target * (1 - SMOOTH)\n    const displayLevel = smoothed[0] ?? 0\n    const barIndex = Math.max(\n      1,\n      Math.min(Math.round(displayLevel * (BARS.length - 1)), BARS.length - 1),\n    )\n    const isSilent = raw < SILENCE_THRESHOLD\n    const hue = ((animTime / 1000) * 90) % 360\n    const { r, g, b } = isSilent ? { r: 128, g: 128, b: 128 } : hueToRgb(hue)\n    invert = () => chalk.rgb(r, g, b)(BARS[barIndex]!)\n  } else {\n    invert = chalk.inverse\n  }\n\n  const textInputState = useTextInput({\n    value: props.value,\n    onChange: props.onChange,\n    onSubmit: props.onSubmit,\n    onExit: props.onExit,\n    onExitMessage: props.onExitMessage,\n    onHistoryReset: props.onHistoryReset,\n    onHistoryUp: props.onHistoryUp,\n    onHistoryDown: props.onHistoryDown,\n    onClearInput: props.onClearInput,\n    focus: props.focus,\n    mask: props.mask,\n    multiline: props.multiline,\n    cursorChar: props.showCursor ? ' ' : '',\n    highlightPastedText: props.highlightPastedText,\n    invert,\n    themeText: color('text', theme),\n    columns: props.columns,\n    maxVisibleLines: props.maxVisibleLines,\n    onImagePaste: props.onImagePaste,\n    disableCursorMovementForUpDownKeys:\n      props.disableCursorMovementForUpDownKeys,\n    disableEscapeDoublePress: props.disableEscapeDoublePress,\n    externalOffset: props.cursorOffset,\n    onOffsetChange: props.onChangeCursorOffset,\n    inputFilter: props.inputFilter,\n    inlineGhostText: props.inlineGhostText,\n    dim: chalk.dim,\n  })\n\n  return (\n    <Box ref={animRef}>\n      <BaseTextInput\n        inputState={textInputState}\n        terminalFocus={isTerminalFocused}\n        highlights={props.highlights}\n        invert={invert}\n        hidePlaceholderText={isVoiceRecording}\n        {...props}\n      />\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}