Major improvements to our AgentUI.ts for @ mention files, 5x faster, les than 16ms now;

typing now like @src + Tab now auto completes the first classified file, Fixes Applied
  src/ui/ink/AgentUI.tsx
  • Synchronous mention detection in handleInput: when the buffer changes, mentions are detected immediately and refs are updated so Tab works without waiting for
    e 16ms React state flush
  • Stale-state guard in the mention useEffect: skips processing when input/cursorOffset lag behind the buffer
  • Buffer-accurate cursor offset in Tab handling: uses getTextBufferCursorOffset(buffer) instead of the stale cursorOffsetRef.current
  src/ui/mentionPreview.ts
  • Synchronous suggestion refresh for Tab and arrow keys: updateSuggestions() is called immediately inside handleKeypress before handling navigation/acceptance, e
    uring fresh data
  src/ui/useBufferedInput.ts
  • Added clear documentation explaining why stdin cannot be safely connected alongside Ink
  • Removed the broken 'sequence' listener in favor of correct 'data'/'paste' listeners on StdinBuffer (ready for future safe stdin interception)

Author: igorcosta

src/ui/ink/AgentUI.tsx

@@ -238,6 +238,8 @@ export function AgentUI({
   onToggleLiveCommandExpandedRef.current = onToggleLiveCommandExpanded;
   const onInstructionRef = useRef(onInstruction);
   onInstructionRef.current = onInstruction;
+  const filesProviderRef = useRef(filesProvider);
+  filesProviderRef.current = filesProvider;
 
   // Throttled sync from buffer to React state to batch rapid keystrokes
   // and reduce re-render frequency during fast typing (16ms = ~60fps).
@@ -385,6 +387,14 @@ export function AgentUI({
       return;
     }
 
+    // Guard against stale React state: if the buffer already has newer text
+    // (because the 16ms throttle hasn't flushed yet), skip processing.
+    // The synchronous handler in handleInput already updated the refs.
+    const buffer = textBufferRef.current;
+    if (input !== buffer.getText() || cursorOffset !== getTextBufferCursorOffset(buffer)) {
+      return;
+    }
+
     const mention = matchFileMention(input, cursorOffset);
     if (!mention) {
       setFileMentionVisible(false);
@@ -488,7 +498,7 @@ export function AgentUI({
           const buffer = textBufferRef.current;
           const currentText = buffer.getText();
           const beforeMention = currentText.slice(0, fileMentionStartIndexRef.current);
-          const afterCursor = currentText.slice(cursorOffsetRef.current);
+          const afterCursor = currentText.slice(getTextBufferCursorOffset(buffer));
           const replacement = `@${suggestion.path} `;
           const newText = beforeMention + replacement + afterCursor;
 
@@ -527,6 +537,42 @@ export function AgentUI({
 
     if (result === 'handled') {
       syncInputFromBuffer();
+
+      // Immediate mention detection so Tab works without waiting for the 16ms
+      // React state throttle. This eliminates the intermittent failure where
+      // rapid typing followed by Tab is ignored because mention state hasn't
+      // been flushed to React yet.
+      const currentText = buffer.getText();
+      const currentOffset = getTextBufferCursorOffset(buffer);
+      const provider = filesProviderRef.current;
+      if (provider) {
+        const mention = matchFileMention(currentText, currentOffset);
+        if (mention) {
+          const files = provider();
+          const matchingFiles = buildFileMentionSuggestions(files, mention.seed, 5);
+          if (matchingFiles.length > 0) {
+            fileMentionStartIndexRef.current = mention.startIndex;
+            fileMentionSuggestionsRef.current = parseFileSuggestions(matchingFiles);
+            fileMentionVisibleRef.current = true;
+            setFileMentionSuggestions(fileMentionSuggestionsRef.current);
+            setFileMentionVisible(true);
+            setFileMentionActiveIndex(prev => Math.min(prev, matchingFiles.length - 1));
+          } else {
+            fileMentionVisibleRef.current = false;
+            fileMentionSuggestionsRef.current = [];
+            fileMentionStartIndexRef.current = null;
+            setFileMentionVisible(false);
+            setFileMentionSuggestions([]);
+          }
+        } else if (fileMentionVisibleRef.current) {
+          fileMentionVisibleRef.current = false;
+          fileMentionSuggestionsRef.current = [];
+          fileMentionStartIndexRef.current = null;
+          setFileMentionVisible(false);
+          setFileMentionSuggestions([]);
+        }
+      }
+
       return;
     }
   }, [syncBufferViewport, syncInputFromBuffer, exit]);

src/ui/mentionPreview.ts

@@ -168,6 +168,15 @@ export class MentionPreview {
     if (this.disposed || this.suspended) {
       return;
     }
+
+    // For navigation/acceptance keys, refresh suggestions synchronously so
+    // they reflect the current rl.line. Without this, a Tab pressed rapidly
+    // after a character can use stale suggestion data because the deferred
+    // setImmediate(updateSuggestions) hasn't fired yet.
+    if (this.isTabKey(_str, key) || key?.name === 'down' || key?.name === 'up') {
+      this.updateSuggestions();
+    }
+
     const beforeCursor = this.rl.line.slice(0, this.rl.cursor);
 
     // Tab and arrow keys must be handled synchronously (before readline processes them)

src/ui/useBufferedInput.ts

@@ -210,19 +210,36 @@ export function useBufferedInput(options: UseBufferedInputOptions): void {
     if (!stdin || !isActive) {
       return;
     }
-    
+
     const buffer = new StdinBuffer({ timeout: flushTimeout });
     bufferRef.current = buffer;
-    
-    // Handle sequence events from the buffer
-    const handleSequence = (event: SequenceEvent) => {
-      const info = sequenceToInkInput(event);
+
+    // IMPORTANT: We intentionally do NOT attach stdin.on('data') here.
+    // Ink's App component uses stdin 'readable' events to read input.
+    // Adding a 'data' listener would switch the stream to flowing mode and
+    // prevent Ink from receiving keystrokes. A future refactor should find
+    // a safe way to intercept stdin data (e.g., wrapping stdin.read()) so
+    // that bracketed-paste and Kitty-protocol events can be detected.
+
+    // Handle sequence events from the buffer (currently only triggered
+    // by direct buffer.process() calls from external code).
+    const handleData = (data: string) => {
+      const type: SequenceEvent['type'] = data.startsWith('\x1b') ? 'csi' : 'printable';
+      const info = sequenceToInkInput({ type, data });
       onInputRef.current(info.input, info.key, info);
     };
-    
-    buffer.on('sequence', handleSequence);
-    
+
+    const handlePaste = (data: string) => {
+      const info = sequenceToInkInput({ type: 'paste', data });
+      onInputRef.current(info.input, info.key, info);
+    };
+
+    buffer.on('data', handleData);
+    buffer.on('paste', handlePaste);
+
     return () => {
+      buffer.off('data', handleData);
+      buffer.off('paste', handlePaste);
       buffer.destroy();
       bufferRef.current = null;
     };