@iaforged/context-code 1.1.3 → 1.1.5

package/dist/src/hooks/useVoiceEnabled.js

@@ -1,21 +1,9 @@
-import { useMemo } from 'react';
 import { useAppState } from '../state/AppState.js';
-import { hasVoiceAuth, isVoiceGrowthBookEnabled, } from '../voice/voiceModeEnabled.js';
+import { isVoiceGrowthBookEnabled } from '../voice/voiceModeEnabled.js';
 /**
- * Combines user intent (settings.voiceEnabled) with auth + GB kill-switch.
- * Only the auth half is memoized on authVersion — it's the expensive one
- * (cold getClaudeAIOAuthTokens memoize → sync `security` spawn, ~60ms/call,
- * ~180ms total in profile v5 when token refresh cleared the cache mid-session).
- * GB is a cheap cached-map lookup and stays outside the memo so a mid-session
- * kill-switch flip still takes effect on the next render.
- *
- * authVersion bumps on /login only. Background token refresh leaves it alone
- * (user is still authed), so the auth memo stays correct without re-eval.
+ * Combines user intent (settings.voiceEnabled) with the runtime feature gate.
  */
 export function useVoiceEnabled() {
     const userIntent = useAppState(s => s.settings.voiceEnabled === true);
-    const authVersion = useAppState(s => s.authVersion);
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    const authed = useMemo(hasVoiceAuth, [authVersion]);
-    return userIntent && authed && isVoiceGrowthBookEnabled();
+    return userIntent && isVoiceGrowthBookEnabled();
 }

package/dist/src/hooks/useVoiceIntegration.js

@@ -17,12 +17,7 @@ import { useVoiceEnabled } from './useVoiceEnabled.js';
 // Capture the module namespace, not the function: spyOn() mutates the module
 // object, so `voiceNs.useVoice(...)` resolves to the spy even if this module
 // was loaded before the spy was installed (test ordering independence).
-const voiceNs = feature('VOICE_MODE') ? require('./useVoice.js') : {
-    useVoice: ({ enabled: _e }) => ({
-        state: 'idle',
-        handleKeyEvent: (_fallbackMs) => { }
-    })
-};
+const voiceNs = require('./useVoice.js');
 /* eslint-enable @typescript-eslint/no-require-imports */
 // Maximum gap (ms) between key presses to count as held (auto-repeat).
 // Terminal auto-repeat fires every 30-80ms; 120ms covers jitter while
@@ -172,18 +167,12 @@ export function useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTex
     // auth + GB kill-switch, with the auth half memoized on authVersion so
     // render loops never hit a cold keychain spawn.
     // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-    const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
-    const voiceState = feature('VOICE_MODE') ?
-        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-        useVoiceState(s => s.voiceState) : 'idle';
-    const voiceInterimTranscript = feature('VOICE_MODE') ?
-        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-        useVoiceState(s_0 => s_0.voiceInterimTranscript) : '';
+    const voiceEnabled = useVoiceEnabled();
+    const voiceState = useVoiceState(s => s.voiceState);
+    const voiceInterimTranscript = useVoiceState(s_0 => s_0.voiceInterimTranscript);
     // Set the voice anchor for focus mode (where recording starts via terminal
     // focus, not key hold). Key-hold sets the anchor in stripTrailing.
     useEffect(() => {
-        if (!feature('VOICE_MODE'))
-            return;
         if (voiceState === 'recording' && voicePrefixRef.current === null) {
             const input = inputValueRef.current;
             const offset_0 = insertTextRef.current?.cursorOffset ?? input.length;
@@ -201,8 +190,6 @@ export function useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTex
     // transcribes speech. The prefix (user-typed text before the cursor) is
     // preserved and the transcript is inserted between prefix and suffix.
     useEffect(() => {
-        if (!feature('VOICE_MODE'))
-            return;
         if (voicePrefixRef.current === null)
             return;
         const prefix_0 = voicePrefixRef.current;
@@ -233,8 +220,6 @@ export function useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTex
         lastSetInputRef.current = newValue_0;
     }, [voiceInterimTranscript, setInputValueRaw, inputValueRef, insertTextRef]);
     const handleVoiceTranscript = useCallback((text) => {
-        if (!feature('VOICE_MODE'))
-            return;
         const prefix_1 = voicePrefixRef.current;
         // No voice anchor — voice was reset (or never started). Nothing to do.
         if (prefix_1 === null)
@@ -283,8 +268,6 @@ export function useVoiceIntegration({ setInputValueRaw, inputValueRef, insertTex
     // Compute the character range of interim (not-yet-finalized) transcript
     // text in the input value, so the UI can dim it.
     const interimRange = useMemo(() => {
-        if (!feature('VOICE_MODE'))
-            return null;
         if (voicePrefixRef.current === null)
             return null;
         if (voiceInterimTranscript.length === 0)
@@ -335,10 +318,8 @@ export function useVoiceKeybindingHandler({ voiceHandleKeyEvent, stripTrailing,
     const keybindingContext = useOptionalKeybindingContext();
     const isModalOverlayActive = useIsModalOverlayActive();
     // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-    const voiceEnabled = feature('VOICE_MODE') ? useVoiceEnabled() : false;
-    const voiceState = feature('VOICE_MODE') ?
-        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-        useVoiceState(s => s.voiceState) : 'idle';
+    const voiceEnabled = useVoiceEnabled();
+    const voiceState = useVoiceState(s => s.voiceState);
     // Find the configured key for voice:pushToTalk from keybinding context.
     // Forward iteration with last-wins (matching the resolver): if a later
     // Chat binding overrides the same chord with null or a different

package/dist/src/keybindings/defaultBindings.js

@@ -6,10 +6,13 @@ import { getPlatform } from '../utils/platform.js';
  * Default keybindings that match current Context Code behavior.
  * These are loaded first, then user keybindings.json overrides them.
  */
-// Platform-specific image paste shortcut:
-// - Windows: alt+v (ctrl+v is system paste)
+// Platform-specific image paste shortcuts:
+// - Windows: accept both ctrl+v and alt+v. Some terminals forward ctrl+v as a
+//   regular keybinding, while others reserve it for paste handling.
 // - Other platforms: ctrl+v
-const IMAGE_PASTE_KEY = getPlatform() === 'windows' ? 'alt+v' : 'ctrl+v';
+const IMAGE_PASTE_BINDINGS = getPlatform() === 'windows'
+    ? { 'ctrl+v': 'chat:imagePaste', 'alt+v': 'chat:imagePaste' }
+    : { 'ctrl+v': 'chat:imagePaste' };
 // Modifier-only chords (like shift+tab) may fail on Windows Terminal without VT mode
 // See: https://github.com/microsoft/terminal/issues/879#issuecomment-618801651
 // Node enabled VT mode in 24.2.0 / 22.17.0: https://github.com/nodejs/node/pull/58358
@@ -76,8 +79,8 @@ export const DEFAULT_BINDINGS = [
             'ctrl+x ctrl+e': 'chat:externalEditor',
             'ctrl+g': 'chat:externalEditor',
             'ctrl+s': 'chat:stash',
-            // Image paste shortcut (platform-specific key defined above)
-            [IMAGE_PASTE_KEY]: 'chat:imagePaste',
+            // Image paste shortcuts (platform-specific bindings defined above)
+            ...IMAGE_PASTE_BINDINGS,
             ...(feature('MESSAGE_ACTIONS')
                 ? { 'shift+up': 'chat:messageActions' }
                 : {}),
@@ -86,7 +89,7 @@ export const DEFAULT_BINDINGS = [
             // add a voice:pushToTalk entry (last wins); to disable, use /voice
             // — null-unbinding space hits a pre-existing useKeybinding.ts trap
             // where 'unbound' swallows the event (space dead for typing).
-            ...(feature('VOICE_MODE') ? { space: 'voice:pushToTalk' } : {}),
+            space: 'voice:pushToTalk',
         },
     },
     {

package/dist/src/screens/REPL.js

@@ -94,12 +94,8 @@ import { isHumanTurn } from '../utils/messagePredicates.js';
 import { logError } from '../utils/log.js';
 // Dead code elimination: conditional imports
 /* eslint-disable custom-rules/no-process-env-top-level, @typescript-eslint/no-require-imports */
-const useVoiceIntegration = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').useVoiceIntegration : () => ({
-    stripTrailing: () => 0,
-    handleKeyEvent: () => { },
-    resetAnchor: () => { }
-});
-const VoiceKeybindingHandler = feature('VOICE_MODE') ? require('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler : () => null;
+const useVoiceIntegration = require('../hooks/useVoiceIntegration.js').useVoiceIntegration;
+const VoiceKeybindingHandler = require('../hooks/useVoiceIntegration.js').VoiceKeybindingHandler;
 // Frustration detection is ant-only (dogfooding). Conditional require so external
 // builds eliminate the module entirely (including its two O(n) useMemos that run
 // on every messages change, plus the GrowthBook fetch).
@@ -3609,19 +3605,11 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
         void onQuery([userMessage], newAbortController, true, [], mainLoopModel);
         return true;
     }, [onQuery, mainLoopModel, store]);
-    // Voice input integration (VOICE_MODE builds only)
-    const voice = feature('VOICE_MODE') ?
-        // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
-        useVoiceIntegration({
-            setInputValueRaw,
-            inputValueRef,
-            insertTextRef
-        }) : {
-        stripTrailing: () => 0,
-        handleKeyEvent: () => { },
-        resetAnchor: () => { },
-        interimRange: null
-    };
+    const voice = useVoiceIntegration({
+        setInputValueRaw,
+        inputValueRef,
+        insertTextRef
+    });
     useInboxPoller({
         enabled: isAgentSwarmsEnabled(),
         isLoading,
@@ -3977,7 +3965,7 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
         const transcriptScrollRef = isFullscreenEnvEnabled() && !disableVirtualScroll && !dumpMode ? scrollRef : undefined;
         const transcriptMessagesElement = _jsx(Messages, { messages: transcriptMessages, tools: tools, commands: commands, verbose: true, toolJSX: null, toolUseConfirmQueue: [], inProgressToolUseIDs: inProgressToolUseIDs, isMessageSelectorVisible: false, conversationId: conversationId, screen: screen, agentDefinitions: agentDefinitions, streamingToolUses: transcriptStreamingToolUses, showAllInTranscript: showAllInTranscript, onOpenRateLimitOptions: handleOpenRateLimitOptions, isLoading: isLoading, hidePastThinking: true, streamingThinking: streamingThinking, scrollRef: transcriptScrollRef, jumpRef: jumpRef, onSearchMatchesChange: onSearchMatchesChange, scanElement: scanElement, setPositions: setPositions, disableRenderCap: dumpMode });
         const transcriptToolJSX = toolJSX && _jsx(Box, { flexDirection: "column", width: "100%", children: toolJSX.jsx });
-        const transcriptReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), feature('VOICE_MODE') ? _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }) : null, _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), transcriptScrollRef ?
+        const transcriptReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), transcriptScrollRef ?
                     _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, 
                         // Yield wheel/ctrl+u/d to UltraplanChoiceDialog's own scroll
                         // handler while the modal is showing.
@@ -4091,7 +4079,7 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
     // flexGrow in FullscreenLayout resolves against this Box. The transcript
     // early return above wraps its virtual-scroll branch the same way; only
     // the 30-cap dump branch stays unwrapped for native terminal scrollback.
-    const mainReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), feature('VOICE_MODE') ? _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }) : null, _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, isActive: isFullscreenEnvEnabled() && (centeredModal != null || !focusedInputDialog || focusedInputDialog === 'tool-permission'), onScroll: centeredModal || toolPermissionOverlay || viewedAgentTask ? undefined : composedOnScroll }), feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? _jsx(MessageActionsKeybindings, { handlers: messageActionHandlers, isActive: cursor !== null }) : null, _jsx(CancelRequestHandler, { ...cancelRequestProps }), _jsx(MCPConnectionManager, { dynamicMcpConfig: dynamicMcpConfig, isStrictMcpConfig: strictMcpConfig, children: _jsx(FullscreenLayout, { scrollRef: scrollRef, overlay: toolPermissionOverlay, bottomFloat: feature('BUDDY') && companionVisible && !companionNarrow ? _jsx(CompanionFloatingBubble, {}) : undefined, modal: centeredModal, modalScrollRef: modalScrollRef, dividerYRef: dividerYRef, hidePill: !!viewedAgentTask, hideSticky: !!viewedTeammateTask, newMessageCount: unseenDivider?.count ?? 0, onPillClick: () => {
+    const mainReturn = _jsxs(KeybindingSetup, { children: [_jsx(AnimatedTerminalTitle, { isAnimating: titleIsAnimating, title: terminalTitle, disabled: titleDisabled, noPrefix: showStatusInTerminalTab }), _jsx(GlobalKeybindingHandlers, { ...globalKeybindingProps }), _jsx(VoiceKeybindingHandler, { voiceHandleKeyEvent: voice.handleKeyEvent, stripTrailing: voice.stripTrailing, resetAnchor: voice.resetAnchor, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(CommandKeybindingHandlers, { onSubmit: onSubmit, isActive: !toolJSX?.isLocalJSXCommand }), _jsx(ScrollKeybindingHandler, { scrollRef: scrollRef, isActive: isFullscreenEnvEnabled() && (centeredModal != null || !focusedInputDialog || focusedInputDialog === 'tool-permission'), onScroll: centeredModal || toolPermissionOverlay || viewedAgentTask ? undefined : composedOnScroll }), feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? _jsx(MessageActionsKeybindings, { handlers: messageActionHandlers, isActive: cursor !== null }) : null, _jsx(CancelRequestHandler, { ...cancelRequestProps }), _jsx(MCPConnectionManager, { dynamicMcpConfig: dynamicMcpConfig, isStrictMcpConfig: strictMcpConfig, children: _jsx(FullscreenLayout, { scrollRef: scrollRef, overlay: toolPermissionOverlay, bottomFloat: feature('BUDDY') && companionVisible && !companionNarrow ? _jsx(CompanionFloatingBubble, {}) : undefined, modal: centeredModal, modalScrollRef: modalScrollRef, dividerYRef: dividerYRef, hidePill: !!viewedAgentTask, hideSticky: !!viewedTeammateTask, newMessageCount: unseenDivider?.count ?? 0, onPillClick: () => {
                         setCursor(null);
                         jumpToNew(scrollRef.current);
                     }, scrollable: _jsxs(_Fragment, { children: [_jsx(TeammateViewHeader, {}), _jsx(Messages, { messages: displayedMessages, tools: tools, commands: commands, verbose: verbose, toolJSX: toolJSX, toolUseConfirmQueue: toolUseConfirmQueue, inProgressToolUseIDs: viewedTeammateTask ? viewedTeammateTask.inProgressToolUseIDs ?? new Set() : inProgressToolUseIDs, isMessageSelectorVisible: isMessageSelectorVisible, conversationId: conversationId, screen: screen, streamingToolUses: streamingToolUses, showAllInTranscript: showAllInTranscript, agentDefinitions: agentDefinitions, onOpenRateLimitOptions: handleOpenRateLimitOptions, isLoading: isLoading, streamingText: isLoading && !viewedAgentTask ? visibleStreamingText : null, isBriefOnly: viewedAgentTask ? false : isBriefOnly, unseenDivider: viewedAgentTask ? undefined : unseenDivider, scrollRef: isFullscreenEnvEnabled() ? scrollRef : undefined, trackStickyPrompt: isFullscreenEnvEnabled() ? true : undefined, cursor: cursor, setCursor: setCursor, cursorNavRef: cursorNavRef }), _jsx(AwsAuthStatusBox, {}), !disabled && placeholderText && !centeredModal && _jsx(UserTextMessage, { param: {
@@ -4344,7 +4332,7 @@ export function REPL({ commands: initialCommands, debug, initialTools, initialMe
                                             }).then(appendStdout).catch(logError);
                                         } }) : null, mrRender(), !toolJSX?.shouldHidePromptInput && !focusedInputDialog && !isExiting && !disabled && !cursor && _jsxs(_Fragment, { children: [autoRunIssueReason && _jsx(AutoRunIssueNotification, { onRun: handleAutoRunIssue, onCancel: handleCancelAutoRunIssue, reason: getAutoRunIssueReasonText(autoRunIssueReason) }), postCompactSurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: postCompactSurvey.state, lastResponse: postCompactSurvey.lastResponse, handleSelect: postCompactSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback }) : memorySurvey.state !== 'closed' ? _jsx(FeedbackSurvey, { state: memorySurvey.state, lastResponse: memorySurvey.lastResponse, handleSelect: memorySurvey.handleSelect, handleTranscriptSelect: memorySurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: handleSurveyRequestFeedback, message: "How well did Claude use its memory? (optional)" }) : _jsx(FeedbackSurvey, { state: feedbackSurvey.state, lastResponse: feedbackSurvey.lastResponse, handleSelect: feedbackSurvey.handleSelect, handleTranscriptSelect: feedbackSurvey.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue, onRequestFeedback: didAutoRunIssueRef.current ? undefined : handleSurveyRequestFeedback }), frustrationDetection.state !== 'closed' && _jsx(FeedbackSurvey, { state: frustrationDetection.state, lastResponse: null, handleSelect: () => { }, handleTranscriptSelect: frustrationDetection.handleTranscriptSelect, inputValue: inputValue, setInputValue: setInputValue }), "external" === 'ant' && skillImprovementSurvey.suggestion && _jsx(SkillImprovementSurvey, { isOpen: skillImprovementSurvey.isOpen, skillName: skillImprovementSurvey.suggestion.skillName, updates: skillImprovementSurvey.suggestion.updates, handleSelect: skillImprovementSurvey.handleSelect, inputValue: inputValue, setInputValue: setInputValue }), showIssueFlagBanner && _jsx(IssueFlagBanner, {}), _jsx(PromptInput, { debug: debug, ideSelection: ideSelection, hasSuppressedDialogs: !!hasSuppressedDialogs, isLocalJSXCommandActive: isShowingLocalJSXCommand, getToolUseContext: getToolUseContext, toolPermissionContext: toolPermissionContext, setToolPermissionContext: setToolPermissionContext, apiKeyStatus: apiKeyStatus, commands: commands, agents: agentDefinitions.activeAgents, isLoading: isLoading, onExit: handleExit, verbose: verbose, messages: messages, onAutoUpdaterResult: setAutoUpdaterResult, autoUpdaterResult: autoUpdaterResult, input: inputValue, onInputChange: setInputValue, mode: inputMode, onModeChange: setInputMode, stashedPrompt: stashedPrompt, setStashedPrompt: setStashedPrompt, submitCount: submitCount, onShowMessageSelector: handleShowMessageSelector, onMessageActionsEnter: 
                                                 // Works during isLoading — edit cancels first; uuid selection survives appends.
-                                                feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? enterMessageActions : undefined, mcpClients: mcpClients, pastedContents: pastedContents, setPastedContents: setPastedContents, vimMode: vimMode, setVimMode: setVimMode, showBashesDialog: showBashesDialog, setShowBashesDialog: setShowBashesDialog, onSubmit: onSubmit, onAgentSubmit: onAgentSubmit, isSearchingHistory: isSearchingHistory, setIsSearchingHistory: setIsSearchingHistory, helpOpen: isHelpOpen, setHelpOpen: setIsHelpOpen, insertTextRef: feature('VOICE_MODE') ? insertTextRef : undefined, voiceInterimRange: voice.interimRange }), _jsx(SessionBackgroundHint, { onBackgroundSession: handleBackgroundSession, isLoading: isLoading })] }), cursor &&
+                                                feature('MESSAGE_ACTIONS') && isFullscreenEnvEnabled() && !disableMessageActions ? enterMessageActions : undefined, mcpClients: mcpClients, pastedContents: pastedContents, setPastedContents: setPastedContents, vimMode: vimMode, setVimMode: setVimMode, showBashesDialog: showBashesDialog, setShowBashesDialog: setShowBashesDialog, onSubmit: onSubmit, onAgentSubmit: onAgentSubmit, isSearchingHistory: isSearchingHistory, setIsSearchingHistory: setIsSearchingHistory, helpOpen: isHelpOpen, setHelpOpen: setIsHelpOpen, insertTextRef: insertTextRef, voiceInterimRange: voice.interimRange }), _jsx(SessionBackgroundHint, { onBackgroundSession: handleBackgroundSession, isLoading: isLoading })] }), cursor &&
                                         _jsx(MessageActionsBar, { cursor: cursor }), focusedInputDialog === 'message-selector' && _jsx(MessageSelector, { messages: messages, preselectedMessage: messageSelectorPreselect, onPreRestore: onCancel, onRestoreCode: async (message) => {
                                             await fileHistoryRewind((updater) => {
                                                 setAppState(prev => ({

package/dist/src/services/localDictation.js

@@ -0,0 +1,377 @@
+import { accessSync, constants } from 'fs';
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, join } from 'path';
+import { execa } from 'execa';
+import { saveGlobalConfig, getGlobalConfig } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getClaudeConfigHomeDir } from '../utils/envUtils.js';
+const SAMPLE_RATE = 16_000;
+const CHANNELS = 1;
+const BITS_PER_SAMPLE = 16;
+const DEFAULT_MODEL_NAME = 'base';
+const WHISPER_RELEASE_API = 'https://api.github.com/repos/ggml-org/whisper.cpp/releases/latest';
+const WHISPER_MODEL_BASE_URL = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main';
+function fileExists(path) {
+    try {
+        accessSync(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getStoredDictationConfig() {
+    return getGlobalConfig().dictationConfig;
+}
+function getConfiguredExecutable() {
+    const explicit = process.env.CONTEXT_CODE_DICTATION_EXECUTABLE ??
+        process.env.WHISPER_CPP_PATH;
+    if (explicit?.trim()) {
+        return explicit.trim();
+    }
+    const stored = getStoredDictationConfig()?.executablePath;
+    if (stored?.trim()) {
+        return stored.trim();
+    }
+    return process.platform === 'win32' ? 'whisper-cli.exe' : 'whisper-cli';
+}
+function getConfiguredModel() {
+    const model = process.env.CONTEXT_CODE_DICTATION_MODEL ??
+        process.env.WHISPER_MODEL_PATH;
+    if (model?.trim()) {
+        return model.trim();
+    }
+    const stored = getStoredDictationConfig()?.modelPath;
+    return stored?.trim() ? stored.trim() : null;
+}
+function getConfiguredLanguage() {
+    const language = process.env.CONTEXT_CODE_DICTATION_LANGUAGE ?? process.env.WHISPER_LANGUAGE;
+    if (language?.trim()) {
+        return language.trim();
+    }
+    const stored = getStoredDictationConfig()?.language;
+    return stored?.trim() ? stored.trim() : 'es';
+}
+function getDictationConfig() {
+    const executable = getConfiguredExecutable();
+    const model = getConfiguredModel();
+    if (!executable || !model) {
+        return null;
+    }
+    return {
+        executable,
+        model,
+        language: getConfiguredLanguage(),
+    };
+}
+function getInstallRoot() {
+    return join(getClaudeConfigHomeDir(), 'dictation', 'whisper.cpp');
+}
+function normalizeModelName(modelName) {
+    const raw = (modelName ?? DEFAULT_MODEL_NAME).trim();
+    if (!raw) {
+        return DEFAULT_MODEL_NAME;
+    }
+    return raw.endsWith('.bin')
+        ? raw.replace(/^ggml-/, '').replace(/\.bin$/i, '')
+        : raw;
+}
+function buildModelFileName(modelName) {
+    return `ggml-${normalizeModelName(modelName)}.bin`;
+}
+function getPlatformArchiveExtension() {
+    return process.platform === 'win32' ? '.zip' : '.tar.gz';
+}
+function escapePowerShellLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+async function fetchBuffer(url, label) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'ContextCode-DictationInstaller',
+            Accept: 'application/octet-stream, application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`No se pudo descargar ${label} (${response.status} ${response.statusText}).`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+async function fetchLatestRelease() {
+    const response = await fetch(WHISPER_RELEASE_API, {
+        headers: {
+            'User-Agent': 'ContextCode-DictationInstaller',
+            Accept: 'application/vnd.github+json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`No se pudo consultar la ultima version de whisper.cpp (${response.status} ${response.statusText}).`);
+    }
+    return (await response.json());
+}
+function scoreReleaseAsset(asset) {
+    const name = asset.name.toLowerCase();
+    if (name.includes('source code')) {
+        return -100;
+    }
+    let score = 0;
+    const expectedExt = getPlatformArchiveExtension();
+    if (name.endsWith(expectedExt))
+        score += 10;
+    if (name.includes('bin'))
+        score += 5;
+    if (name.includes('build'))
+        score += 2;
+    switch (process.platform) {
+        case 'win32':
+            if (name.includes('win') || name.includes('windows') || name.includes('msvc')) {
+                score += 5;
+            }
+            if (name.includes('x64') || name.includes('amd64'))
+                score += 4;
+            if (name.includes('arm64'))
+                score -= 4;
+            break;
+        case 'darwin':
+            if (name.includes('mac') || name.includes('darwin') || name.includes('apple')) {
+                score += 5;
+            }
+            if (process.arch === 'arm64') {
+                if (name.includes('arm64'))
+                    score += 4;
+                if (name.includes('x64') || name.includes('amd64'))
+                    score -= 4;
+            }
+            break;
+        default:
+            if (name.includes('linux'))
+                score += 5;
+            if (process.arch === 'x64' && (name.includes('x64') || name.includes('amd64'))) {
+                score += 4;
+            }
+            if (process.arch === 'arm64' && name.includes('arm64'))
+                score += 4;
+            break;
+    }
+    return score;
+}
+function pickReleaseAsset(assets) {
+    const ranked = [...assets]
+        .map(asset => ({ asset, score: scoreReleaseAsset(asset) }))
+        .filter(entry => entry.score > 0)
+        .sort((a, b) => b.score - a.score);
+    return ranked[0]?.asset ?? null;
+}
+async function extractArchive(archivePath, destination) {
+    if (archivePath.endsWith('.zip')) {
+        if (process.platform === 'win32') {
+            await execa('powershell', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `Expand-Archive -LiteralPath '${escapePowerShellLiteral(archivePath)}' -DestinationPath '${escapePowerShellLiteral(destination)}' -Force`,
+            ], { windowsHide: true });
+            return;
+        }
+        await execa('unzip', ['-o', archivePath, '-d', destination], {
+            windowsHide: true,
+        });
+        return;
+    }
+    if (archivePath.endsWith('.tar.gz') || archivePath.endsWith('.tgz')) {
+        await execa('tar', ['-xzf', archivePath, '-C', destination], {
+            windowsHide: true,
+        });
+        return;
+    }
+    throw new Error(`Formato de paquete no soportado: ${basename(archivePath)}`);
+}
+async function findFileRecursive(rootDir, predicate) {
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolutePath = join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findFileRecursive(absolutePath, predicate);
+            if (nested) {
+                return nested;
+            }
+            continue;
+        }
+        if (predicate(absolutePath)) {
+            return absolutePath;
+        }
+    }
+    return null;
+}
+async function findInstalledExecutable(installDir) {
+    const candidateNames = process.platform === 'win32'
+        ? ['whisper-cli.exe', 'main.exe']
+        : ['whisper-cli', 'main'];
+    return findFileRecursive(installDir, path => candidateNames.some(name => path.toLowerCase().endsWith(name.toLowerCase())));
+}
+function persistInstalledDictationConfig(config) {
+    saveGlobalConfig(current => ({
+        ...current,
+        dictationConfig: {
+            ...(current.dictationConfig ?? {}),
+            ...config,
+        },
+    }));
+}
+export function getLocalDictationSetupHint() {
+    return [
+        'Configura Whisper local antes de usar /dictar.',
+        'Opcion recomendada:',
+        '- Ejecuta /dictar install para descargar e instalar el backend automaticamente.',
+        'Tambien puedes configurarlo manualmente con estas variables:',
+        '- CONTEXT_CODE_DICTATION_EXECUTABLE o WHISPER_CPP_PATH',
+        '- CONTEXT_CODE_DICTATION_MODEL o WHISPER_MODEL_PATH',
+        'Ejemplo PowerShell:',
+        'setx CONTEXT_CODE_DICTATION_EXECUTABLE "C:\\whisper\\whisper-cli.exe"',
+        'setx CONTEXT_CODE_DICTATION_MODEL "C:\\whisper\\models\\ggml-base.bin"',
+    ].join('\n');
+}
+export async function checkLocalDictationConfiguration() {
+    const config = getDictationConfig();
+    if (!config) {
+        return { available: false, error: getLocalDictationSetupHint() };
+    }
+    if (!fileExists(config.model)) {
+        return {
+            available: false,
+            error: `No se encontro el modelo de dictado: ${config.model}\n` +
+                getLocalDictationSetupHint(),
+        };
+    }
+    try {
+        await execa(config.executable, ['--help'], {
+            timeout: 10_000,
+            windowsHide: true,
+            reject: false,
+        });
+        return { available: true };
+    }
+    catch (error) {
+        return {
+            available: false,
+            error: `No se pudo ejecutar el backend de dictado (${config.executable}).\n` +
+                `${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export async function getLocalDictationStatus() {
+    const config = getDictationConfig();
+    const check = await checkLocalDictationConfiguration();
+    const stored = getStoredDictationConfig();
+    if (!config || !check.available) {
+        return check.error ?? 'El dictado local no esta configurado.';
+    }
+    const lines = [
+        'Dictado local configurado.',
+        `Backend: ${config.executable}`,
+        `Modelo: ${config.model}`,
+    ];
+    if (stored?.releaseTag) {
+        lines.push(`Release instalada: ${stored.releaseTag}`);
+    }
+    if (stored?.installedAt) {
+        lines.push(`Instalado: ${stored.installedAt}`);
+    }
+    return lines.join('\n');
+}
+export async function installLocalDictation(modelName) {
+    const normalizedModelName = normalizeModelName(modelName);
+    const modelFileName = buildModelFileName(normalizedModelName);
+    const installDir = getInstallRoot();
+    const tempDir = await mkdtemp(join(tmpdir(), 'context-dictation-install-'));
+    try {
+        const release = await fetchLatestRelease();
+        const asset = pickReleaseAsset(release.assets);
+        if (!asset) {
+            throw new Error(`No encontre un binario compatible de whisper.cpp para ${process.platform}/${process.arch}.`);
+        }
+        const archivePath = join(tempDir, asset.name);
+        const modelPath = join(installDir, 'models', modelFileName);
+        await mkdir(installDir, { recursive: true });
+        await writeFile(archivePath, await fetchBuffer(asset.browser_download_url, `whisper.cpp (${asset.name})`));
+        await rm(installDir, { recursive: true, force: true });
+        await mkdir(installDir, { recursive: true });
+        await extractArchive(archivePath, installDir);
+        const executablePath = await findInstalledExecutable(installDir);
+        if (!executablePath) {
+            throw new Error('La descarga termino, pero no encontre whisper-cli dentro del paquete instalado.');
+        }
+        await mkdir(join(installDir, 'models'), { recursive: true });
+        await writeFile(modelPath, await fetchBuffer(`${WHISPER_MODEL_BASE_URL}/${modelFileName}?download=1`, `modelo ${modelFileName}`));
+        persistInstalledDictationConfig({
+            executablePath,
+            installDir,
+            installedAt: new Date().toISOString(),
+            modelName: normalizedModelName,
+            modelPath,
+            releaseTag: release.tag_name,
+        });
+        logForDebugging(`[dictation] Instalacion completada en ${installDir} usando ${asset.name}`);
+        return {
+            executablePath,
+            installDir,
+            modelPath,
+            releaseTag: release.tag_name,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+function buildWavBuffer(chunks) {
+    const pcmData = Buffer.concat(chunks);
+    const byteRate = SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8);
+    const blockAlign = CHANNELS * (BITS_PER_SAMPLE / 8);
+    const header = Buffer.alloc(44);
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + pcmData.length, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(CHANNELS, 22);
+    header.writeUInt32LE(SAMPLE_RATE, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(BITS_PER_SAMPLE, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(pcmData.length, 40);
+    return Buffer.concat([header, pcmData]);
+}
+export async function transcribePcmBuffers(chunks, opts) {
+    const config = getDictationConfig();
+    if (!config) {
+        throw new Error(getLocalDictationSetupHint());
+    }
+    const dir = await mkdtemp(join(tmpdir(), 'context-dictation-'));
+    const inputPath = join(dir, 'input.wav');
+    const outputPrefix = join(dir, 'result');
+    const outputTxtPath = `${outputPrefix}.txt`;
+    try {
+        await writeFile(inputPath, buildWavBuffer(chunks));
+        const args = ['-m', config.model, '-f', inputPath, '-otxt', '-of', outputPrefix];
+        const language = opts?.language || config.language;
+        if (language && language !== 'auto') {
+            args.push('-l', language);
+        }
+        logForDebugging(`[dictation] Running ${config.executable} ${args.map(part => JSON.stringify(part)).join(' ')}`);
+        const result = await execa(config.executable, args, {
+            timeout: 120_000,
+            windowsHide: true,
+            reject: false,
+        });
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr || result.stdout || 'Whisper finalizo con error.');
+        }
+        return (await readFile(outputTxtPath, 'utf8')).trim();
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/src/services/voice.js

@@ -16,7 +16,7 @@ let audioNapiPromise = null;
 function loadAudioNapi() {
     audioNapiPromise ??= (async () => {
         const t0 = Date.now();
-        const mod = await import('audio-capture-napi');
+        const mod = await import('../../vendor/audio-capture-src/index.js');
         // vendor/audio-capture-src/index.ts defers require(...node) until the
         // first function call — trigger it here so timing reflects real cost.
         mod.isNativeAudioAvailable();
@@ -146,7 +146,9 @@ export async function checkVoiceDependencies() {
     if (process.platform === 'win32') {
         return {
             available: false,
-            missing: ['Voice mode requires the native audio module (not loaded)'],
+            missing: [
+                'El dictado local requiere el modulo nativo de audio y no se pudo cargar.',
+            ],
             installCommand: null,
         };
     }
@@ -189,7 +191,7 @@ export async function checkRecordingAvailability() {
     if (isRunningOnHomespace() || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
         return {
             available: false,
-            reason: 'Voice mode requires microphone access, but no audio device is available in this environment.\n\nTo use voice mode, run Context Code locally instead.',
+            reason: 'El dictado local necesita acceso al microfono, pero este entorno no tiene un dispositivo de audio disponible.\n\nPara usar dictado, ejecuta Context Code de forma local.',
         };
     }
     // Native audio module (cpal) handles everything on macOS, Linux, and Windows
@@ -201,10 +203,10 @@ export async function checkRecordingAvailability() {
     if (process.platform === 'win32') {
         return {
             available: false,
-            reason: 'Voice recording requires the native audio module, which could not be loaded.',
+            reason: 'La grabacion para dictado requiere el modulo nativo de audio y no se pudo cargar.',
         };
     }
-    const wslNoAudioReason = 'Voice mode could not access an audio device in WSL.\n\nWSL2 with WSLg (Windows 11) provides audio via PulseAudio — if you are on Windows 10 or WSL1, run Context Code in native Windows instead.';
+    const wslNoAudioReason = 'El dictado local no pudo acceder a un dispositivo de audio en WSL.\n\nWSL2 con WSLg (Windows 11) expone audio mediante PulseAudio. Si estas en Windows 10 o WSL1, ejecuta Context Code directamente en Windows.';
     // On Linux (including WSL), probe arecord. hasCommand() is insufficient:
     // the binary can exist while the device open() fails (WSL1, Win10-WSL2,
     // headless Linux). WSL2+WSLg (Win11 default) works via PulseAudio RDP
@@ -239,8 +241,8 @@ export async function checkRecordingAvailability() {
         return {
             available: false,
             reason: pm
-                ? `Voice mode requires SoX for audio recording. Install it with: ${pm.displayCommand}`
-                : 'Voice mode requires SoX for audio recording. Install SoX manually:\n  macOS: brew install sox\n  Ubuntu/Debian: sudo apt-get install sox\n  Fedora: sudo dnf install sox',
+                ? `El dictado local requiere SoX para grabar audio. Instalalo con: ${pm.displayCommand}`
+                : 'El dictado local requiere SoX para grabar audio. Instalalo manualmente:\n  macOS: brew install sox\n  Ubuntu/Debian: sudo apt-get install sox\n  Fedora: sudo dnf install sox',
         };
     }
     return { available: true, reason: null };