@iaforged/context-code 1.2.12 → 1.3.5

package/dist/src/commands/orchestrate/orchestrate.js

@@ -6,6 +6,7 @@ import { createOrchestrationMessage, createOrchestrationRun, createOrchestration
 import { activityManager } from '../../utils/activityManager.js';
 import { manuallyExtractSessionMemory } from '../../services/sessionMemory/sessionMemory.js';
 import { createUserMessage, createAssistantMessage } from '../../utils/messages.js';
+import { logForDebugging } from '../../utils/debug.js';
 function parseArgs(args) {
     const trimmed = args.trim();
     if (!trimmed) {

package/dist/src/hooks/useAwaySummary.js

@@ -5,6 +5,8 @@ import { getTerminalFocusState, subscribeTerminalFocus, } from '../ink/terminal-
 import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
 import { generateAwaySummary } from '../services/awaySummary.js';
 import { createAwaySummaryMessage } from '../utils/messages.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getGlobalConfig } from '../utils/config.js';
 function hasSummarySinceLastUserTurn(messages) {
     for (let i = messages.length - 1; i >= 0; i--) {
         const m = messages[i];

package/dist/src/hooks/useDoublePress.js

@@ -17,7 +17,7 @@ export function useDoublePress(setPending, onDoublePress, onFirstPress) {
             clearTimeoutSafe();
         };
     }, [clearTimeoutSafe]);
-    return useCallback(() => {
+    return useCallback((...args) => {
         const now = Date.now();
         const timeSinceLastPress = now - lastPressRef.current;
         const isDoublePress = timeSinceLastPress <= DOUBLE_PRESS_TIMEOUT_MS &&
@@ -25,19 +25,19 @@ export function useDoublePress(setPending, onDoublePress, onFirstPress) {
         if (isDoublePress) {
             // Double press detected
             clearTimeoutSafe();
-            setPending(false);
-            onDoublePress();
+            setPending(false, ...args);
+            onDoublePress(...args);
         }
         else {
             // First press
-            onFirstPress?.();
-            setPending(true);
+            onFirstPress?.(...args);
+            setPending(true, ...args);
             // Clear any existing timeout and set new one
             clearTimeoutSafe();
-            timeoutRef.current = setTimeout((setPending, timeoutRef) => {
-                setPending(false);
+            timeoutRef.current = setTimeout((setPending, timeoutRef, ...args) => {
+                setPending(false, ...args);
                 timeoutRef.current = undefined;
-            }, DOUBLE_PRESS_TIMEOUT_MS, setPending, timeoutRef);
+            }, DOUBLE_PRESS_TIMEOUT_MS, setPending, timeoutRef, ...args);
         }
         lastPressRef.current = now;
     }, [setPending, onDoublePress, onFirstPress, clearTimeoutSafe]);

package/dist/src/hooks/useTextInput.js

@@ -1,3 +1,4 @@
+import { useRef, useState } from 'react';
 import { isInputModeCharacter } from '../components/PromptInput/inputModes.js';
 import { useNotifications } from '../context/notifications.js';
 import stripAnsi from 'strip-ansi';
@@ -8,7 +9,7 @@ import { env } from '../utils/env.js';
 import { isFullscreenEnvEnabled } from '../utils/fullscreen.js';
 import { isModifierPressed, prewarmModifiers } from '../utils/modifiers.js';
 import { useDoublePress } from './useDoublePress.js';
-const NOOP_HANDLER = () => { };
+const NOOP_HANDLER = (_c, _i) => { };
 function insertPlainText(cursor, input) {
     const text = stripAnsi(input)
         // eslint-disable-next-line custom-rules/no-lookbehind-regex -- .replace(re, str) on 1-2 char keystrokes: no-match returns same string (Object.is), regex never runs
@@ -21,8 +22,8 @@ function insertPlainText(cursor, input) {
 }
 function mapInput(input_map) {
     const map = new Map(input_map);
-    return function (input) {
-        return (map.get(input) ?? NOOP_HANDLER)(input);
+    return function (cursor, input) {
+        return (map.get(input) ?? NOOP_HANDLER)(cursor, input);
     };
 }
 export function useTextInput({ value: originalValue, onChange, onSubmit, onExit, onExitMessage, onHistoryUp, onHistoryDown, onHistoryReset, onClearInput, mask = '', multiline = false, cursorChar, invert, columns, onImagePaste: _onImagePaste, disableCursorMovementForUpDownKeys = false, disableEscapeDoublePress = false, maxVisibleLines, externalOffset, onOffsetChange, inputFilter, inlineGhostText, dim, }) {
@@ -32,12 +33,25 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     }
     const offset = externalOffset;
     const setOffset = onOffsetChange;
+    // Maintain synchronous internal state to prevent character loss during rapid typing.
+    // React re-renders can be slower than keystrokes in a complex TUI.
+    const lastProcessedValueRef = useRef(originalValue);
+    const lastProcessedOffsetRef = useRef(externalOffset);
+    // Sync internal state with props when they change externally (history, undo, etc.)
+    const [lastPropValue, setLastPropValue] = useState(originalValue);
+    const [lastPropOffset, setLastPropOffset] = useState(externalOffset);
+    if (originalValue !== lastPropValue || externalOffset !== lastPropOffset) {
+        lastProcessedValueRef.current = originalValue;
+        lastProcessedOffsetRef.current = externalOffset;
+        setLastPropValue(originalValue);
+        setLastPropOffset(externalOffset);
+    }
     const cursor = Cursor.fromText(originalValue, columns, offset);
     const { addNotification, removeNotification } = useNotifications();
-    const handleCtrlC = useDoublePress(show => {
+    const handleCtrlC = useDoublePress((show, _cursor) => {
         onExitMessage?.(show, 'Ctrl-C');
-    }, () => onExit?.(), () => {
-        if (originalValue) {
+    }, (_cursor) => onExit?.(), (cursor) => {
+        if (cursor.text) {
             onChange('');
             setOffset(0);
             onHistoryReset?.();
@@ -47,8 +61,8 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     // It's a text-level double-press escape for clearing input, not an action-level keybinding.
     // Double-press Esc clears the input and saves to history - this is text editing behavior,
     // not dialog dismissal, and needs the double-press safety mechanism.
-    const handleEscape = useDoublePress((show) => {
-        if (!originalValue || !show) {
+    const handleEscape = useDoublePress((show, cursor) => {
+        if (!cursor.text || !show) {
             return;
         }
         addNotification({
@@ -57,57 +71,57 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
             priority: 'immediate',
             timeoutMs: 1000,
         });
-    }, () => {
+    }, (_show, cursor) => {
         // Remove the "Esc again to clear" notification immediately
         removeNotification('escape-again-to-clear');
         onClearInput?.();
-        if (originalValue) {
+        if (cursor.text) {
             // Track double-escape usage for feature discovery
             // Save to history before clearing
-            if (originalValue.trim() !== '') {
-                addToHistory(originalValue);
+            if (cursor.text.trim() !== '') {
+                addToHistory(cursor.text);
             }
             onChange('');
             setOffset(0);
             onHistoryReset?.();
         }
     });
-    const handleEmptyCtrlD = useDoublePress(show => {
-        if (originalValue !== '') {
+    const handleEmptyCtrlD = useDoublePress((show, cursor) => {
+        if (cursor.text !== '') {
             return;
         }
         onExitMessage?.(show, 'Ctrl-D');
-    }, () => {
-        if (originalValue !== '') {
+    }, (_show, cursor) => {
+        if (cursor.text !== '') {
             return;
         }
         onExit?.();
     });
-    function handleCtrlD() {
+    function handleCtrlD(cursor) {
         if (cursor.text === '') {
             // When input is empty, handle double-press
-            handleEmptyCtrlD();
+            handleEmptyCtrlD(cursor);
             return cursor;
         }
         // When input is not empty, delete forward like iPython
         return cursor.del();
     }
-    function killToLineEnd() {
+    function killToLineEnd(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteToLineEnd();
         pushToKillRing(killed, 'append');
         return newCursor;
     }
-    function killToLineStart() {
+    function killToLineStart(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteToLineStart();
         pushToKillRing(killed, 'prepend');
         return newCursor;
     }
-    function killWordBefore() {
+    function killWordBefore(cursor) {
         const { cursor: newCursor, killed } = cursor.deleteWordBefore();
         pushToKillRing(killed, 'prepend');
         return newCursor;
     }
-    function yank() {
+    function yank(cursor) {
         const text = getLastKill();
         if (text.length > 0) {
             const startOffset = cursor.offset;
@@ -117,7 +131,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         }
         return cursor;
     }
-    function handleYankPop() {
+    function handleYankPop(cursor) {
         const popResult = yankPop();
         if (!popResult) {
             return cursor;
@@ -132,27 +146,27 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         return Cursor.fromText(newText, columns, newOffset);
     }
     const handleCtrl = mapInput([
-        ['a', () => cursor.startOfLine()],
-        ['b', () => cursor.left()],
-        ['c', handleCtrlC],
-        ['d', handleCtrlD],
-        ['e', () => cursor.endOfLine()],
-        ['f', () => cursor.right()],
-        ['h', () => cursor.deleteTokenBefore() ?? cursor.backspace()],
-        ['k', killToLineEnd],
-        ['n', () => downOrHistoryDown()],
-        ['p', () => upOrHistoryUp()],
-        ['u', killToLineStart],
-        ['w', killWordBefore],
-        ['y', yank],
+        ['a', cursor => cursor.startOfLine()],
+        ['b', cursor => cursor.left()],
+        ['c', (cursor, _input) => handleCtrlC(cursor)],
+        ['d', (cursor, _input) => handleCtrlD(cursor)],
+        ['e', cursor => cursor.endOfLine()],
+        ['f', cursor => cursor.right()],
+        ['h', cursor => cursor.deleteTokenBefore() ?? cursor.backspace()],
+        ['k', (cursor, _input) => killToLineEnd(cursor)],
+        ['n', (cursor, _input) => downOrHistoryDown(cursor)],
+        ['p', (cursor, _input) => upOrHistoryUp(cursor)],
+        ['u', (cursor, _input) => killToLineStart(cursor)],
+        ['w', (cursor, _input) => killWordBefore(cursor)],
+        ['y', (cursor, _input) => yank(cursor)],
     ]);
     const handleMeta = mapInput([
-        ['b', () => cursor.prevWord()],
-        ['f', () => cursor.nextWord()],
-        ['d', () => cursor.deleteWordAfter()],
-        ['y', handleYankPop],
+        ['b', cursor => cursor.prevWord()],
+        ['f', cursor => cursor.nextWord()],
+        ['d', cursor => cursor.deleteWordAfter()],
+        ['y', (cursor, _input) => handleYankPop(cursor)],
     ]);
-    function handleEnter(key) {
+    function handleEnter(cursor, key) {
         if (multiline &&
             cursor.offset > 0 &&
             cursor.text[cursor.offset - 1] === '\\') {
@@ -169,9 +183,9 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (env.terminal === 'Apple_Terminal' && isModifierPressed('shift')) {
             return cursor.insert('\n');
         }
-        onSubmit?.(originalValue);
+        onSubmit?.(cursor.text);
     }
-    function upOrHistoryUp() {
+    function upOrHistoryUp(cursor) {
         if (disableCursorMovementForUpDownKeys) {
             onHistoryUp?.();
             return cursor;
@@ -193,7 +207,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         onHistoryUp?.();
         return cursor;
     }
-    function downOrHistoryDown() {
+    function downOrHistoryDown(cursor) {
         if (disableCursorMovementForUpDownKeys) {
             onHistoryDown?.();
             return cursor;
@@ -218,7 +232,7 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
     function mapKey(key) {
         switch (true) {
             case key.escape:
-                return () => {
+                return (cursor) => {
                     // Skip when a keybinding context (e.g. Autocomplete) owns escape.
                     // useKeybindings can't shield us via stopImmediatePropagation —
                     // BaseTextInput's useInput registers first (child effects fire
@@ -226,38 +240,40 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
                     // time the keybinding's handler stops propagation.
                     if (disableEscapeDoublePress)
                         return cursor;
-                    handleEscape();
+                    handleEscape(cursor);
                     // Return the current cursor unchanged - handleEscape manages state internally
                     return cursor;
                 };
             case key.leftArrow && (key.ctrl || key.meta || key.fn):
-                return () => cursor.prevWord();
+                return (cursor) => cursor.prevWord();
             case key.rightArrow && (key.ctrl || key.meta || key.fn):
-                return () => cursor.nextWord();
+                return (cursor) => cursor.nextWord();
             case key.backspace:
                 return key.meta || key.ctrl
-                    ? killWordBefore
-                    : () => cursor.deleteTokenBefore() ?? cursor.backspace();
+                    ? (cursor) => killWordBefore(cursor)
+                    : (cursor) => cursor.deleteTokenBefore() ?? cursor.backspace();
             case key.delete:
-                return key.meta ? killToLineEnd : () => cursor.del();
+                return key.meta
+                    ? (cursor) => killToLineEnd(cursor)
+                    : (cursor) => cursor.del();
             case key.ctrl:
                 return handleCtrl;
             case key.home:
-                return () => cursor.startOfLine();
+                return (cursor) => cursor.startOfLine();
             case key.end:
-                return () => cursor.endOfLine();
+                return (cursor) => cursor.endOfLine();
             case key.pageDown:
                 // In fullscreen mode, PgUp/PgDn scroll the message viewport instead
                 // of moving the cursor — no-op here, ScrollKeybindingHandler handles it.
                 if (isFullscreenEnvEnabled()) {
                     return NOOP_HANDLER;
                 }
-                return () => cursor.endOfLine();
+                return (cursor) => cursor.endOfLine();
             case key.pageUp:
                 if (isFullscreenEnvEnabled()) {
                     return NOOP_HANDLER;
                 }
-                return () => cursor.startOfLine();
+                return (cursor) => cursor.startOfLine();
             case key.wheelUp:
             case key.wheelDown:
                 // Mouse wheel events only exist when fullscreen mouse tracking is on.
@@ -266,21 +282,21 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
                 return NOOP_HANDLER;
             case key.return:
                 // Must come before key.meta so Option+Return inserts newline
-                return () => handleEnter(key);
+                return (cursor) => handleEnter(cursor, key);
             case key.meta:
                 return handleMeta;
             case key.tab:
-                return () => cursor;
+                return (cursor) => cursor;
             case key.upArrow && !key.shift:
-                return upOrHistoryUp;
+                return (cursor) => upOrHistoryUp(cursor);
             case key.downArrow && !key.shift:
-                return downOrHistoryDown;
+                return (cursor) => downOrHistoryDown(cursor);
             case key.leftArrow:
-                return () => cursor.left();
+                return (cursor) => cursor.left();
             case key.rightArrow:
-                return () => cursor.right();
+                return (cursor) => cursor.right();
             default: {
-                return function (input) {
+                return function (cursor, input) {
                     switch (true) {
                         // Home key
                         case input === '\x1b[H' || input === '\x1b[1~':
@@ -327,30 +343,34 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (filteredInput === '' && input !== '') {
             return;
         }
+        // Get the current synchronous state
+        const currentCursor = Cursor.fromText(lastProcessedValueRef.current, columns, lastProcessedOffsetRef.current);
         // In SSH/tmux or slow terminals, raw DEL characters can be coalesced with
         // printable input. Process the chunk sequentially so DEL only removes the
         // preceding character and the rest of the packet still gets inserted.
         if (!key.backspace && !key.delete && filteredInput.includes('\x7f')) {
-            let currentCursor = cursor;
+            let activeCursor = currentCursor;
             let segmentStart = 0;
             for (let i = 0; i < filteredInput.length; i++) {
                 if (filteredInput[i] !== '\x7f') {
                     continue;
                 }
                 if (segmentStart < i) {
-                    currentCursor = insertPlainText(currentCursor, filteredInput.slice(segmentStart, i));
+                    activeCursor = insertPlainText(activeCursor, filteredInput.slice(segmentStart, i));
                 }
-                currentCursor = currentCursor.backspace();
+                activeCursor = activeCursor.backspace();
                 segmentStart = i + 1;
             }
             if (segmentStart < filteredInput.length) {
-                currentCursor = insertPlainText(currentCursor, filteredInput.slice(segmentStart));
+                activeCursor = insertPlainText(activeCursor, filteredInput.slice(segmentStart));
             }
-            if (!cursor.equals(currentCursor)) {
-                if (cursor.text !== currentCursor.text) {
-                    onChange(currentCursor.text);
+            if (!currentCursor.equals(activeCursor)) {
+                if (currentCursor.text !== activeCursor.text) {
+                    lastProcessedValueRef.current = activeCursor.text;
+                    onChange(activeCursor.text);
                 }
-                setOffset(currentCursor.offset);
+                lastProcessedOffsetRef.current = activeCursor.offset;
+                setOffset(activeCursor.offset);
             }
             resetKillAccumulation();
             resetYankState();
@@ -364,12 +384,14 @@ export function useTextInput({ value: originalValue, onChange, onSubmit, onExit,
         if (!isYankKey(key, filteredInput)) {
             resetYankState();
         }
-        const nextCursor = mapKey(key)(filteredInput);
+        const nextCursor = mapKey(key)(currentCursor, filteredInput);
         if (nextCursor) {
-            if (!cursor.equals(nextCursor)) {
-                if (cursor.text !== nextCursor.text) {
+            if (!currentCursor.equals(nextCursor)) {
+                if (currentCursor.text !== nextCursor.text) {
+                    lastProcessedValueRef.current = nextCursor.text;
                     onChange(nextCursor.text);
                 }
+                lastProcessedOffsetRef.current = nextCursor.offset;
                 setOffset(nextCursor.offset);
             }
             // SSH-coalesced Enter: on slow links, "o" + Enter can arrive as one

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iaforged/context-code",
-  "version": "1.2.12",
+  "version": "1.3.5",
   "description": "Context Code es un asistente de desarrollo para la terminal. Puede revisar tu proyecto, editar archivos, ejecutar comandos y apoyarte en tareas reales de programacion.",
   "author": "Context AI",
   "license": "MIT",

package/dist/vendor/audio-capture-src/index.ts

@@ -1,155 +0,0 @@
-
-import { createRequire } from 'module'
-
-const require = createRequire(import.meta.url)
-
-type AudioCaptureNapi = {
-  startRecording(
-    onData: (data: Buffer) => void,
-    onEnd: () => void,
-  ): boolean
-  stopRecording(): void
-  isRecording(): boolean
-  startPlayback(sampleRate: number, channels: number): boolean
-  writePlaybackData(data: Buffer): void
-  stopPlayback(): void
-  isPlaying(): boolean
-  // TCC microphone authorization status (macOS only):
-  // 0 = notDetermined, 1 = restricted, 2 = denied, 3 = authorized.
-  // Linux: always returns 3 (authorized) — no system-level microphone permission API.
-  // Windows: returns 3 (authorized) if registry key absent or allowed,
-  //          2 (denied) if microphone access is explicitly denied.
-  microphoneAuthorizationStatus?(): number
-}
-
-let cachedModule: AudioCaptureNapi | null = null
-let loadAttempted = false
-
-function loadModule(): AudioCaptureNapi | null {
-  if (loadAttempted) {
-    return cachedModule
-  }
-  loadAttempted = true
-
-  // Supported platforms: macOS (darwin), Linux, Windows (win32)
-  const platform = process.platform
-  if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
-    return null
-  }
-
-  // Candidate 1: native-embed path (bun compile). AUDIO_CAPTURE_NODE_PATH is
-  // defined at build time in build-with-plugins.ts for native builds only — the
-  // define resolves it to the static literal "../../audio-capture.node" so bun
-  // compile can rewrite it to /$bunfs/root/audio-capture.node. MUST stay a
-  // direct require(env var) — bun cannot analyze require(variable) from a loop.
-  if (process.env.AUDIO_CAPTURE_NODE_PATH) {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      cachedModule = require(
-        process.env.AUDIO_CAPTURE_NODE_PATH,
-      ) as AudioCaptureNapi
-      return cachedModule
-    } catch {
-      // fall through to runtime fallbacks below
-    }
-  }
-
-  // Candidates 2/3: npm-install and dev/source layouts. Dynamic require is
-  // fine here — in bundled output (node --target build) require() resolves at
-  // runtime relative to cli.js at the package root; in dev it resolves
-  // relative to this file (vendor/audio-capture-src/index.ts).
-  const platformDir = `${process.arch}-${platform}`
-  const fallbacks = [
-    `./vendor/audio-capture/${platformDir}/audio-capture.node`,
-    `../audio-capture/${platformDir}/audio-capture.node`,
-  ]
-  for (const p of fallbacks) {
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-require-imports
-      cachedModule = require(p) as AudioCaptureNapi
-      return cachedModule
-    } catch {
-      // try next
-    }
-  }
-  return null
-}
-
-export function isNativeAudioAvailable(): boolean {
-  return loadModule() !== null
-}
-
-export function startNativeRecording(
-  onData: (data: Buffer) => void,
-  onEnd: () => void,
-): boolean {
-  const mod = loadModule()
-  if (!mod) {
-    return false
-  }
-  return mod.startRecording(onData, onEnd)
-}
-
-export function stopNativeRecording(): void {
-  const mod = loadModule()
-  if (!mod) {
-    return
-  }
-  mod.stopRecording()
-}
-
-export function isNativeRecordingActive(): boolean {
-  const mod = loadModule()
-  if (!mod) {
-    return false
-  }
-  return mod.isRecording()
-}
-
-export function startNativePlayback(
-  sampleRate: number,
-  channels: number,
-): boolean {
-  const mod = loadModule()
-  if (!mod) {
-    return false
-  }
-  return mod.startPlayback(sampleRate, channels)
-}
-
-export function writeNativePlaybackData(data: Buffer): void {
-  const mod = loadModule()
-  if (!mod) {
-    return
-  }
-  mod.writePlaybackData(data)
-}
-
-export function stopNativePlayback(): void {
-  const mod = loadModule()
-  if (!mod) {
-    return
-  }
-  mod.stopPlayback()
-}
-
-export function isNativePlaying(): boolean {
-  const mod = loadModule()
-  if (!mod) {
-    return false
-  }
-  return mod.isPlaying()
-}
-
-// Returns the microphone authorization status.
-// On macOS, returns the TCC status: 0=notDetermined, 1=restricted, 2=denied, 3=authorized.
-// On Linux, always returns 3 (authorized) — no system-level mic permission API.
-// On Windows, returns 3 (authorized) if registry key absent or allowed, 2 (denied) if explicitly denied.
-// Returns 0 (notDetermined) if the native module is unavailable.
-export function microphoneAuthorizationStatus(): number {
-  const mod = loadModule()
-  if (!mod || !mod.microphoneAuthorizationStatus) {
-    return 0
-  }
-  return mod.microphoneAuthorizationStatus()
-}