@letta-ai/letta-code 0.5.0 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "bin": {

package/vendor/ink-text-input/build/index.js

@@ -2,9 +2,34 @@ import chalk from 'chalk';
 import { Text, useInput } from 'ink';
 import React, { useEffect, useState } from 'react';
 
+/**
+ * Determines if the input should be treated as a control sequence (not inserted as text).
+ * This centralizes escape sequence filtering to prevent garbage characters from being inserted.
+ */
+function isControlSequence(input, key) {
+    // Pasted content is handled separately
+    if (key?.isPasted) return true;
+
+    // Standard control keys (but NOT plain escape - apps may need it for shortcuts)
+    if (key.tab || (key.ctrl && input === 'c')) return true;
+    if (key.shift && key.tab) return true;
+
+    // Ctrl+W (delete word) - handled by parent component
+    if (key.ctrl && (input === 'w' || input === 'W')) return true;
+
+    // Option+Arrow escape sequences: Ink parses \x1bb as meta=true, input='b'
+    if (key.meta && (input === 'b' || input === 'B' || input === 'f' || input === 'F')) return true;
+
+    // Filter specific escape sequences that would insert garbage, but allow plain ESC through
+    // CSI sequences (ESC[...), Option+Delete (ESC + DEL), and other multi-char escape sequences
+    if (input && typeof input === 'string' && input.startsWith('\x1b') && input.length > 1) return true;
+
+    return false;
+}
+
 function TextInput({ value: originalValue, placeholder = '', focus = true, mask, highlightPastedText = false, showCursor = true, onChange, onSubmit, externalCursorOffset, onCursorOffsetChange }) {
-    const [state, setState] = useState({ cursorOffset: (originalValue || '').length, cursorWidth: 0 });
-    const { cursorOffset, cursorWidth } = state;
+    const [state, setState] = useState({ cursorOffset: (originalValue || '').length, cursorWidth: 0, killBuffer: '' });
+    const { cursorOffset, cursorWidth, killBuffer } = state;
     useEffect(() => {
         setState(previousState => {
             if (!focus || !showCursor) {
@@ -12,7 +37,7 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
             }
             const newValue = originalValue || '';
             if (previousState.cursorOffset > newValue.length - 1) {
-                return { cursorOffset: newValue.length, cursorWidth: 0 };
+                return { ...previousState, cursorOffset: newValue.length, cursorWidth: 0 };
             }
             return previousState;
         });
@@ -21,7 +46,7 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
         if (typeof externalCursorOffset === 'number') {
             const newValue = originalValue || '';
             const clamped = Math.max(0, Math.min(externalCursorOffset, newValue.length));
-            setState(prev => ({ cursorOffset: clamped, cursorWidth: 0 }));
+            setState(prev => ({ ...prev, cursorOffset: clamped, cursorWidth: 0 }));
             if (typeof onCursorOffsetChange === 'function') onCursorOffsetChange(clamped);
         }
     }, [externalCursorOffset, originalValue, onCursorOffsetChange]);
@@ -42,11 +67,8 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
         }
     }
     useInput((input, key) => {
-        if (key && key.isPasted) {
-            return;
-        }
-        // Treat Escape as a control key (don't insert into value)
-        if (key.escape || (key.ctrl && input === 'c') || key.tab || (key.shift && key.tab)) {
+        // Filter control sequences (escape keys, Option+Arrow garbage, etc.)
+        if (isControlSequence(input, key)) {
             return;
         }
         if (key.return) {
@@ -58,22 +80,25 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
         let nextCursorOffset = cursorOffset;
         let nextValue = originalValue;
         let nextCursorWidth = 0;
-        if (key.leftArrow) {
-            if (showCursor) {
-                nextCursorOffset--;
+        let nextKillBuffer = killBuffer;
+        if (key.leftArrow || key.rightArrow) {
+            // Skip if meta is pressed - Option+Arrow is handled by parent for word navigation
+            if (key.meta) {
+                return;
             }
-        }
-        else if (key.rightArrow) {
             if (showCursor) {
-                nextCursorOffset++;
+                nextCursorOffset += key.leftArrow ? -1 : 1;
             }
         }
         else if (key.upArrow || key.downArrow) {
-            // Handle wrapped line navigation - don't handle here, let parent decide
-            // Parent will check cursor position to determine if at boundary
+            // Let parent decide (wrapped line navigation)
             return;
         }
         else if (key.backspace || key.delete) {
+            // Skip if meta is pressed - Option+Delete is handled by parent for word deletion
+            if (key.meta) {
+                return;
+            }
             if (cursorOffset > 0) {
                 nextValue = originalValue.slice(0, cursorOffset - 1) + originalValue.slice(cursorOffset, originalValue.length);
                 nextCursorOffset--;
@@ -91,6 +116,28 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
                 nextCursorOffset = originalValue.length;
             }
         }
+        else if (key.ctrl && input === 'k') {
+            // CTRL-K: kill from cursor to end of line
+            if (cursorOffset < originalValue.length) {
+                nextKillBuffer = originalValue.slice(cursorOffset);
+                nextValue = originalValue.slice(0, cursorOffset);
+            }
+        }
+        else if (key.ctrl && input === 'u') {
+            // CTRL-U: kill from beginning to cursor
+            if (cursorOffset > 0) {
+                nextKillBuffer = originalValue.slice(0, cursorOffset);
+                nextValue = originalValue.slice(cursorOffset);
+                nextCursorOffset = 0;
+            }
+        }
+        else if (key.ctrl && input === 'y') {
+            // CTRL-Y: yank (paste) from kill buffer
+            if (killBuffer) {
+                nextValue = originalValue.slice(0, cursorOffset) + killBuffer + originalValue.slice(cursorOffset);
+                nextCursorOffset = cursorOffset + killBuffer.length;
+            }
+        }
         else {
             nextValue = originalValue.slice(0, cursorOffset) + input + originalValue.slice(cursorOffset, originalValue.length);
             nextCursorOffset += input.length;
@@ -99,7 +146,7 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
             }
         }
         nextCursorOffset = Math.max(0, Math.min(nextCursorOffset, nextValue.length));
-        setState({ cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth });
+        setState(prev => ({ ...prev, cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth, killBuffer: nextKillBuffer }));
         if (typeof onCursorOffsetChange === 'function') onCursorOffsetChange(nextCursorOffset);
         if (nextValue !== originalValue) {
             onChange(nextValue);