@letta-ai/letta-code 0.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2025, Letta authors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,122 @@
+# Letta Code (Research Preview)
+
+A self-improving, stateful coding agent that can learn from experience and improve with use.
+
+## What is Letta Code?
+
+Letta Code is a command-line harness around the stateful Letta [Agents API](https://docs.letta.com/api-reference/overview). You can use Letta Code to create and connect with any Letta agent (even non-coding agents!) - Letta Code simply gives your agents the ability to interact with your local dev environment, directly in your terminal.
+
+> [!IMPORTANT]
+> Letta Code is a **research preview** in active development, and may have bugs or unexpected issues. To learn more about the roadmap and chat with the dev team, visit our Discord at [discord.gg/letta](https:/discord.gg/letta). Contributions welcome, join the fun.
+
+## Quickstart
+
+Get an API key at: [https://app.letta.com](https://app.letta.com/)
+
+Install the package via npm:
+```bash
+npm install @letta-ai/letta-code
+```
+
+Set your API key, and run `letta`:
+```
+export LETTA_API_KEY=...
+letta
+```
+
+## Quickstart (from source)
+
+First, install Bun if you don't have it yet: [https://bun.com/docs/installation](https://bun.com/docs/installation)
+
+```bash
+# install deps
+bun install
+
+# run Letta Code
+bun run src/index.ts
+
+# alternatively, install globally to `letta` executable
+bun add --global .
+
+# then, you can run w/ `letta`
+letta
+```
+
+## Usage
+
+### Interactive Mode
+```bash
+letta                    # Start new session
+letta --continue         # Resume last session
+letta --agent <id>       # Open specific agent
+```
+
+### Headless Mode
+```bash
+letta -p "your prompt"                           # Run non-interactive
+letta -p "commit changes" --continue             # Continue previous session
+letta -p "run tests" --allowedTools "Bash"       # Control tool permissions
+letta -p "run tests" --disallowedTools "Bash"    # Control tool permissions
+
+# Pipe input from stdin
+echo "Explain this code" | letta -p
+cat file.txt | letta -p
+gh pr diff 123 | letta -p --yolo                 # Review PR changes
+```
+
+You can also use the `--tools` flag to control the underlying *attachment* of tools (not just the permissions).
+Compared to disallowing the tool, this will additionally remove the tool schema from the agent's context window.
+```bash
+letta -p "run tests" --tools "Bash,Read"         # Only load specific tools
+letta -p "analyze code" --tools ""               # No tools (analysis only)
+```
+
+### Permissions
+
+**Tool selection** (controls which tools are loaded):
+```bash
+--tools "Bash,Read,Write"                        # Only load these tools
+--tools ""                                       # No tools (conversation only)
+```
+
+**Permission overrides** (controls tool access, applies to loaded tools):
+```bash
+--allowedTools "Bash,Read,Write"                 # Allow specific tools
+--allowedTools "Bash(npm run test:*)"            # Allow specific commands
+--disallowedTools "Bash(curl:*)"                 # Block specific patterns
+--permission-mode acceptEdits                    # Auto-allow Write/Edit tools
+--permission-mode plan                           # Read-only mode
+--permission-mode bypassPermissions              # Allow all tools (use carefully!)
+--yolo                                           # Alias for --permission-mode bypassPermissions
+```
+
+Permission modes:
+- `default` - Standard behavior, prompts for approval
+- `acceptEdits` - Auto-allows Write/Edit/NotebookEdit
+- `plan` - Read-only, allows analysis but blocks modifications
+- `bypassPermissions` - Auto-allows all tools (for trusted environments)
+
+Permissions are also configured in `.letta/settings.json`:
+```json
+{
+  "permissions": {
+    "allow": ["Bash(npm run lint)", "Read(src/**)"],
+    "deny": ["Bash(rm -rf:*)", "Read(.env)"]
+  }
+}
+```
+
+---
+
+To distribute:
+```bash
+# build single-file binary
+bun build src/index.ts --compile --outfile letta
+
+# optionally copy to bin
+sudo mv letta /usr/local/bin/
+```
+
+---
+
+Made with 💜 in San Francisco

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@letta-ai/letta-code",
+  "version": "0.1.0",
+  "description": "Letta Code CLI for interacting with Letta agents from the terminal.",
+  "type": "module",
+  "bin": {
+    "letta": "bin/letta"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "bin",
+    "scripts",
+    "vendor"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/letta-ai/letta-code.git"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.2.5",
+    "@types/bun": "latest",
+    "@types/diff": "^8.0.0",
+    "typescript": "^5.0.0",
+    "husky": "9.1.7",
+    "lint-staged": "16.2.4"
+  },
+  "dependencies": {
+    "@letta-ai/letta-client": "1.0.0-alpha.2",
+    "diff": "^8.0.2",
+    "ink": "^5.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^5.0.0",
+    "minimatch": "^10.0.3",
+    "react": "18.2.0"
+  },
+  "scripts": {
+    "lint": "biome check src",
+    "fix": "biome check --write src",
+    "dev:ui": "bun run src/index.ts",
+    "build": "bun build src/index.ts --compile --outfile bin/letta",
+    "prepublishOnly": "bun run build",
+    "postinstall": "bun scripts/postinstall-patches.js || true"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx,json,md}": [
+      "biome check --write"
+    ]
+  }
+}

package/scripts/postinstall-patches.js

@@ -0,0 +1,106 @@
+// Postinstall patcher for vendoring our Ink modifications without patch-package.
+// Copies patched runtime files from ./src/vendor into node_modules.
+
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = dirname(__dirname);
+const require = createRequire(import.meta.url);
+
+async function copyToResolved(srcRel, targetSpecifier) {
+  const src = join(pkgRoot, srcRel);
+  if (!existsSync(src)) return;
+  let dest;
+  try {
+    // Special handling for Ink internals due to package exports
+    if (targetSpecifier.startsWith("ink/")) {
+      // Resolve root of installed ink package; add robust fallbacks for Bun
+      let buildDir;
+      try {
+        // Prefer import.meta.resolve when available
+        const inkEntryUrl = await import.meta.resolve("ink");
+        const inkEntryPath = fileURLToPath(inkEntryUrl); // .../node_modules/ink/build/index.js
+        buildDir = dirname(inkEntryPath); // .../node_modules/ink/build
+      } catch {}
+      if (!buildDir) {
+        try {
+          const inkPkgPath = require.resolve("ink/package.json");
+          const inkRoot = dirname(inkPkgPath);
+          buildDir = join(inkRoot, "build");
+        } catch {}
+      }
+      if (!buildDir) {
+        // Final fallback: assume standard layout relative to project root
+        buildDir = join(pkgRoot, "node_modules", "ink", "build");
+      }
+      const rel = targetSpecifier.replace(/^ink\//, ""); // e.g. build/components/App.js
+      const afterBuild = rel.replace(/^build\//, ""); // e.g. components/App.js
+      dest = join(buildDir, afterBuild);
+    } else if (targetSpecifier.startsWith("ink-text-input/")) {
+      // Resolve root of installed ink-text-input in a Node 18+ compatible way
+      try {
+        const entryUrl = await import.meta.resolve("ink-text-input");
+        dest = fileURLToPath(entryUrl); // .../node_modules/ink-text-input/build/index.js
+      } catch {
+        try {
+          const itPkgPath = require.resolve("ink-text-input/package.json");
+          const itRoot = dirname(itPkgPath);
+          dest = join(itRoot, "build", "index.js");
+        } catch {
+          // Final fallback
+          dest = join(
+            pkgRoot,
+            "node_modules",
+            "ink-text-input",
+            "build",
+            "index.js",
+          );
+        }
+      }
+    } else {
+      dest = require.resolve(targetSpecifier);
+    }
+  } catch (e) {
+    console.warn(
+      `[patch] failed to resolve ${targetSpecifier}:`,
+      e?.message || e,
+    );
+    return;
+  }
+  const destDir = dirname(dest);
+  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+  try {
+    copyFileSync(src, dest);
+    console.log(`[patch] ${srcRel} -> ${dest}`);
+  } catch (e) {
+    console.warn(
+      `[patch] failed to copy ${srcRel} to ${dest}:`,
+      e?.message || e,
+    );
+  }
+}
+
+// Ink internals (resolve actual installed module path)
+await copyToResolved(
+  "vendor/ink/build/components/App.js",
+  "ink/build/components/App.js",
+);
+await copyToResolved(
+  "vendor/ink/build/hooks/use-input.js",
+  "ink/build/hooks/use-input.js",
+);
+await copyToResolved(
+  "vendor/ink/build/devtools.js",
+  "ink/build/devtools.js",
+);
+
+// ink-text-input (optional vendor with externalCursorOffset support)
+await copyToResolved(
+  "vendor/ink-text-input/build/index.js",
+  "ink-text-input/build/index.js",
+);
+
+console.log("[patch] Ink runtime patched");

package/vendor/ink/build/components/App.js

@@ -0,0 +1,348 @@
+import { EventEmitter } from 'node:events';
+import process from 'node:process';
+import cliCursor from 'cli-cursor';
+import React, { PureComponent } from 'react';
+import AppContext from './AppContext.js';
+import ErrorOverview from './ErrorOverview.js';
+import FocusContext from './FocusContext.js';
+import StderrContext from './StderrContext.js';
+import StdinContext from './StdinContext.js';
+import StdoutContext from './StdoutContext.js';
+
+const tab = '\t';
+const shiftTab = '\u001B[Z';
+const escape = '\u001B';
+export default class App extends PureComponent {
+    static displayName = 'InternalApp';
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    state = {
+        isFocusEnabled: true,
+        activeFocusId: undefined,
+        focusables: [],
+        error: undefined,
+    };
+    rawModeEnabledCount = 0;
+    internal_eventEmitter = new EventEmitter();
+    isRawModeSupported() {
+        return this.props.stdin.isTTY;
+    }
+    render() {
+        return (React.createElement(AppContext.Provider, { value: { exit: this.handleExit } },
+            React.createElement(StdinContext.Provider, { value: { stdin: this.props.stdin, setRawMode: this.handleSetRawMode, isRawModeSupported: this.isRawModeSupported(), internal_exitOnCtrlC: this.props.exitOnCtrlC, internal_eventEmitter: this.internal_eventEmitter } },
+                React.createElement(StdoutContext.Provider, { value: { stdout: this.props.stdout, write: this.props.writeToStdout } },
+                    React.createElement(StderrContext.Provider, { value: { stderr: this.props.stderr, write: this.props.writeToStderr } },
+                        React.createElement(FocusContext.Provider, { value: { activeId: this.state.activeFocusId, add: this.addFocusable, remove: this.removeFocusable, activate: this.activateFocusable, deactivate: this.deactivateFocusable, enableFocus: this.enableFocus, disableFocus: this.disableFocus, focusNext: this.focusNext, focusPrevious: this.focusPrevious, focus: this.focus } }, this.state.error ? (React.createElement(ErrorOverview, { error: this.state.error })) : (this.props.children)))))));
+    }
+    componentDidMount() {
+        cliCursor.hide(this.props.stdout);
+    }
+    componentWillUnmount() {
+        cliCursor.show(this.props.stdout);
+        if (this.isRawModeSupported()) {
+            this.handleSetRawMode(false);
+        }
+    }
+    componentDidCatch(error) {
+        this.handleExit(error);
+    }
+    handleSetRawMode = (isEnabled) => {
+        const { stdin } = this.props;
+        if (!this.isRawModeSupported()) {
+            if (stdin === process.stdin) {
+                throw new Error('Raw mode is not supported on the current process.stdin, which Ink uses as input stream by default.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported');
+            }
+            else {
+                throw new Error('Raw mode is not supported on the stdin provided to Ink.\nRead about how to prevent this error on https://github.com/vadimdemedes/ink/#israwmodesupported');
+            }
+        }
+        stdin.setEncoding('utf8');
+        if (isEnabled) {
+            if (this.rawModeEnabledCount === 0) {
+                stdin.ref();
+                stdin.setRawMode(true);
+                stdin.addListener('readable', this.handleReadable);
+                // Enable bracketed paste on this TTY
+                this.props.stdout?.write('\x1B[?2004h');
+            }
+            this.rawModeEnabledCount++;
+            return;
+        }
+        if (--this.rawModeEnabledCount === 0) {
+            this.props.stdout?.write('\x1B[?2004l');
+            stdin.setRawMode(false);
+            stdin.removeListener('readable', this.handleReadable);
+            stdin.unref();
+        }
+    };
+    keyParseState = { mode: 'NORMAL', incomplete: '', pasteBuffer: '' };
+    fallbackPaste = { aggregating: false, buffer: '', timer: null, lastAt: 0, chunks: 0, bytes: 0, escalated: false, recentTime: 0, recentLen: 0 };
+    FALLBACK_NORMAL_MS = 16;
+    FALLBACK_PASTE_MS = 150;
+    PLACEHOLDER_LINE_THRESHOLD = 5;
+    PLACEHOLDER_CHAR_THRESHOLD = 500;
+    FALLBACK_START_LEN_THRESHOLD = 200;
+    parseChunk = (state, chunk) => {
+        const START = '\x1B[200~';
+        const END = '\x1B[201~';
+        const events = [];
+        let next = { ...state };
+        let buf = (next.incomplete || '') + (chunk || '');
+        next.incomplete = '';
+        const pushText = (text) => {
+            if (text && text.length > 0) {
+                events.push({ type: 'text', value: text });
+            }
+        };
+        if (next.mode === 'NORMAL') {
+            let offset = 0;
+            while (offset < buf.length) {
+                const startIdx = buf.indexOf(START, offset);
+                if (startIdx === -1) {
+                    const remainder = buf.slice(offset);
+                    let keep = 0;
+                    const max = Math.min(remainder.length, START.length - 1);
+                    // Only keep potential START prefixes of length >= 2 (e.g., "\x1B[") to avoid swallowing a bare ESC
+                    for (let i = max; i > 1; i--) {
+                        if (START.startsWith(remainder.slice(-i))) {
+                            keep = i;
+                            break;
+                        }
+                    }
+                    if (remainder.length > keep) {
+                        pushText(remainder.slice(0, remainder.length - keep));
+                    }
+                    next.incomplete = remainder.slice(remainder.length - keep);
+                    break;
+                }
+                if (startIdx > offset) {
+                    pushText(buf.slice(offset, startIdx));
+                }
+                offset = startIdx + START.length;
+                const endIdx = buf.indexOf(END, offset);
+                if (endIdx !== -1) {
+                    const content = buf.slice(offset, endIdx);
+                    events.push({ type: 'paste', value: content });
+                    offset = endIdx + END.length;
+                    continue;
+                }
+                next.mode = 'IN_PASTE';
+                next.pasteBuffer = buf.slice(offset);
+                break;
+            }
+            return [events, next];
+        }
+        if (next.mode === 'IN_PASTE') {
+            next.pasteBuffer += buf;
+            const endIdx = next.pasteBuffer.indexOf(END);
+            if (endIdx === -1) {
+                return [events, next];
+            }
+            const content = next.pasteBuffer.slice(0, endIdx);
+            events.push({ type: 'paste', value: content });
+            const after = next.pasteBuffer.slice(endIdx + END.length);
+            next.mode = 'NORMAL';
+            next.pasteBuffer = '';
+            const [moreEvents, finalState] = this.parseChunk(next, after);
+            return [events.concat(moreEvents), finalState];
+        }
+        return [events, next];
+    };
+    countLines = (text) => {
+        if (!text)
+            return 0;
+        const m = text.match(/\r\n|\r|\n/g);
+        return (m ? m.length : 0);
+    };
+    fallbackStart = () => {
+        this.fallbackStop();
+        this.fallbackPaste.aggregating = true;
+        this.fallbackPaste.buffer = '';
+        this.fallbackPaste.chunks = 0;
+        this.fallbackPaste.bytes = 0;
+        this.fallbackPaste.escalated = false;
+        this.fallbackPaste.lastAt = Date.now();
+        this.fallbackPaste.timer = setTimeout(this.fallbackFlush, this.FALLBACK_NORMAL_MS);
+    };
+    fallbackSchedule = (ms) => {
+        if (this.fallbackPaste.timer)
+            clearTimeout(this.fallbackPaste.timer);
+        this.fallbackPaste.timer = setTimeout(this.fallbackFlush, ms);
+        this.fallbackPaste.lastAt = Date.now();
+    };
+    fallbackStop = () => {
+        if (this.fallbackPaste.timer)
+            clearTimeout(this.fallbackPaste.timer);
+        this.fallbackPaste.timer = null;
+        this.fallbackPaste.aggregating = false;
+    };
+    fallbackFlush = () => {
+        const txt = this.fallbackPaste.buffer;
+        this.fallbackStop();
+        if (!txt)
+            return;
+        const lines = this.countLines(txt);
+        const isPaste = this.fallbackPaste.escalated || (lines > this.PLACEHOLDER_LINE_THRESHOLD) || (txt.length > this.PLACEHOLDER_CHAR_THRESHOLD);
+        if (isPaste) {
+            const pasteEvent = { sequence: txt, raw: txt, isPasted: true, name: '', ctrl: false, meta: false, shift: false };
+            this.internal_eventEmitter.emit('input', pasteEvent);
+        }
+        else {
+            this.handleInput(txt);
+            this.internal_eventEmitter.emit('input', txt);
+        }
+        this.fallbackPaste.buffer = '';
+        this.fallbackPaste.chunks = 0;
+        this.fallbackPaste.bytes = 0;
+        this.fallbackPaste.escalated = false;
+    };
+    handleReadable = () => {
+        let chunk;
+        while ((chunk = this.props.stdin.read()) !== null) {
+            const [events, nextState] = this.parseChunk(this.keyParseState, chunk);
+            this.keyParseState = nextState;
+            for (const evt of events) {
+                if (evt.type === 'paste') {
+                    if (this.fallbackPaste.aggregating) {
+                        this.fallbackFlush();
+                    }
+                    const content = evt.value;
+                    const pasteEvent = { sequence: content, raw: content, isPasted: true, name: '', ctrl: false, meta: false, shift: false };
+                    this.internal_eventEmitter.emit('input', pasteEvent);
+                }
+                else if (evt.type === 'text') {
+                    const text = evt.value;
+                    if (!text)
+                        continue;
+                    const hasNewline = /\r|\n/.test(text);
+                    if (this.fallbackPaste.aggregating) {
+                        this.fallbackPaste.buffer += text;
+                        this.fallbackPaste.chunks += 1;
+                        this.fallbackPaste.bytes += text.length;
+                        if (!this.fallbackPaste.escalated) {
+                            if (this.fallbackPaste.buffer.length >= 128) {
+                                this.fallbackPaste.escalated = true;
+                            }
+                        }
+                        this.fallbackSchedule(this.fallbackPaste.escalated ? this.FALLBACK_PASTE_MS : this.FALLBACK_NORMAL_MS);
+                        continue;
+                    }
+                    const now = Date.now();
+                    const quickCombo = (now - this.fallbackPaste.recentTime) <= 16 && (this.fallbackPaste.recentLen + text.length) >= 128;
+                    if (text.length >= 128 || quickCombo) {
+                        this.fallbackStart();
+                        this.fallbackPaste.buffer += text;
+                        this.fallbackPaste.chunks = 1;
+                        this.fallbackPaste.bytes = text.length;
+                        this.fallbackPaste.escalated = text.length >= 128;
+                        this.fallbackSchedule(this.FALLBACK_PASTE_MS);
+                        continue;
+                    }
+                    this.handleInput(text);
+                    this.internal_eventEmitter.emit('input', text);
+                    this.fallbackPaste.recentTime = Date.now();
+                    this.fallbackPaste.recentLen = text.length;
+                    continue;
+                }
+            }
+        }
+    };
+    handleInput = (input) => {
+        if (input === '\x03' && this.props.exitOnCtrlC) {
+            this.handleExit();
+        }
+        // Disable ESC-based focus clearing to avoid consuming the first Escape
+        // if (input === escape && this.state.activeFocusId) {
+        //     this.setState({ activeFocusId: undefined });
+        // }
+        if (this.state.isFocusEnabled && this.state.focusables.length > 0) {
+            if (input === tab) {
+                this.focusNext();
+            }
+            if (input === shiftTab) {
+                this.focusPrevious();
+            }
+        }
+    };
+    handleExit = (error) => {
+        if (this.isRawModeSupported()) {
+            this.handleSetRawMode(false);
+        }
+        this.props.onExit(error);
+    };
+    enableFocus = () => {
+        this.setState({ isFocusEnabled: true });
+    };
+    disableFocus = () => {
+        this.setState({ isFocusEnabled: false });
+    };
+    focus = (id) => {
+        this.setState(previousState => {
+            const hasFocusableId = previousState.focusables.some(focusable => focusable?.id === id);
+            if (!hasFocusableId) {
+                return previousState;
+            }
+            return { activeFocusId: id };
+        });
+    };
+    focusNext = () => {
+        this.setState(previousState => {
+            const firstFocusableId = previousState.focusables.find(focusable => focusable.isActive)?.id;
+            const nextFocusableId = this.findNextFocusable(previousState);
+            return { activeFocusId: nextFocusableId ?? firstFocusableId };
+        });
+    };
+    focusPrevious = () => {
+        this.setState(previousState => {
+            const lastFocusableId = previousState.focusables.findLast(focusable => focusable.isActive)?.id;
+            const previousFocusableId = this.findPreviousFocusable(previousState);
+            return { activeFocusId: previousFocusableId ?? lastFocusableId };
+        });
+    };
+    addFocusable = (id, { autoFocus }) => {
+        this.setState(previousState => {
+            let nextFocusId = previousState.activeFocusId;
+            if (!nextFocusId && autoFocus) {
+                nextFocusId = id;
+            }
+            return { activeFocusId: nextFocusId, focusables: [...previousState.focusables, { id, isActive: true }] };
+        });
+    };
+    removeFocusable = (id) => {
+        this.setState(previousState => ({ activeFocusId: previousState.activeFocusId === id ? undefined : previousState.activeFocusId, focusables: previousState.focusables.filter(focusable => focusable.id !== id) }));
+    };
+    activateFocusable = (id) => {
+        this.setState(previousState => ({ focusables: previousState.focusables.map(focusable => (focusable.id !== id ? focusable : { id, isActive: true })) }));
+    };
+    deactivateFocusable = (id) => {
+        this.setState(previousState => ({ activeFocusId: previousState.activeFocusId === id ? undefined : previousState.activeFocusId, focusables: previousState.focusables.map(focusable => (focusable.id !== id ? focusable : { id, isActive: false })) }));
+    };
+    findNextFocusable = (state) => {
+        const activeIndex = state.focusables.findIndex(focusable => {
+            return focusable.id === state.activeFocusId;
+        });
+        for (let index = activeIndex + 1; index < state.focusables.length; index++) {
+            const focusable = state.focusables[index];
+            if (focusable?.isActive) {
+                return focusable.id;
+            }
+        }
+        return undefined;
+    };
+    findPreviousFocusable = (state) => {
+        const activeIndex = state.focusables.findIndex(focusable => {
+            return focusable.id === state.activeFocusId;
+        });
+        for (let index = activeIndex - 1; index >= 0; index--) {
+            const focusable = state.focusables[index];
+            if (focusable?.isActive) {
+                return focusable.id;
+            }
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=App.js.map
+
+

package/vendor/ink/build/devtools.js

@@ -0,0 +1,6 @@
+/* Patched by Letta Code: disable React DevTools hook in production builds. */
+export default {
+  connectToDevTools() {
+    // no-op
+  },
+};

package/vendor/ink/build/hooks/use-input.js

@@ -0,0 +1,101 @@
+import { useEffect } from 'react';
+import parseKeypress, { nonAlphanumericKeys } from '../parse-keypress.js';
+import reconciler from '../reconciler.js';
+import useStdin from './use-stdin.js';
+
+// Patched for bracketed paste: propagate "isPasted" and avoid leaking ESC sequences
+const useInput = (inputHandler, options = {}) => {
+    const { stdin, setRawMode, internal_exitOnCtrlC, internal_eventEmitter } = useStdin();
+
+    useEffect(() => {
+        if (options.isActive === false) {
+            return;
+        }
+        setRawMode(true);
+        return () => {
+            setRawMode(false);
+        };
+    }, [options.isActive, setRawMode]);
+
+    useEffect(() => {
+        if (options.isActive === false) {
+            return;
+        }
+
+        const handleData = (data) => {
+            // Handle bracketed paste events emitted by Ink stdin manager
+            if (data && typeof data === 'object' && data.isPasted) {
+                const key = {
+                    upArrow: false,
+                    downArrow: false,
+                    leftArrow: false,
+                    rightArrow: false,
+                    pageDown: false,
+                    pageUp: false,
+                    return: false,
+                    escape: false,
+                    ctrl: false,
+                    shift: false,
+                    tab: false,
+                    backspace: false,
+                    delete: false,
+                    meta: false,
+                    isPasted: true
+                };
+                reconciler.batchedUpdates(() => {
+                    inputHandler(data.sequence || data.raw || '', key);
+                });
+                return;
+            }
+
+            const keypress = parseKeypress(data);
+            const key = {
+                upArrow: keypress.name === 'up',
+                downArrow: keypress.name === 'down',
+                leftArrow: keypress.name === 'left',
+                rightArrow: keypress.name === 'right',
+                pageDown: keypress.name === 'pagedown',
+                pageUp: keypress.name === 'pageup',
+                return: keypress.name === 'return',
+                escape: keypress.name === 'escape',
+                ctrl: keypress.ctrl,
+                shift: keypress.shift,
+                tab: keypress.name === 'tab',
+                backspace: keypress.name === 'backspace',
+                delete: keypress.name === 'delete',
+                meta: keypress.meta || keypress.name === 'escape' || keypress.option,
+                isPasted: false
+            };
+
+            let input = keypress.ctrl ? keypress.name : keypress.sequence;
+            const seq = typeof keypress.sequence === 'string' ? keypress.sequence : '';
+            // Filter xterm focus in/out sequences (ESC[I / ESC[O)
+            if (seq === '\u001B[I' || seq === '\u001B[O' || input === '[I' || input === '[O' || /^(?:\[I|\[O)+$/.test(input || '')) {
+                return;
+            }
+
+            if (nonAlphanumericKeys.includes(keypress.name)) {
+                input = '';
+            }
+
+            if (input.length === 1 && typeof input[0] === 'string' && /[A-Z]/.test(input[0])) {
+                key.shift = true;
+            }
+
+            if (!(input === 'c' && key.ctrl) || !internal_exitOnCtrlC) {
+                reconciler.batchedUpdates(() => {
+                    inputHandler(input, key);
+                });
+            }
+        };
+
+        internal_eventEmitter?.on('input', handleData);
+        return () => {
+            internal_eventEmitter?.removeListener('input', handleData);
+        };
+    }, [options.isActive, stdin, internal_exitOnCtrlC, inputHandler]);
+};
+
+export default useInput;
+
+

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

@@ -0,0 +1,115 @@
+import chalk from 'chalk';
+import { Text, useInput } from 'ink';
+import React, { useEffect, useState } from 'react';
+
+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;
+    useEffect(() => {
+        setState(previousState => {
+            if (!focus || !showCursor) {
+                return previousState;
+            }
+            const newValue = originalValue || '';
+            if (previousState.cursorOffset > newValue.length - 1) {
+                return { cursorOffset: newValue.length, cursorWidth: 0 };
+            }
+            return previousState;
+        });
+    }, [originalValue, focus, showCursor]);
+    useEffect(() => {
+        if (typeof externalCursorOffset === 'number') {
+            const newValue = originalValue || '';
+            const clamped = Math.max(0, Math.min(externalCursorOffset, newValue.length));
+            setState(prev => ({ cursorOffset: clamped, cursorWidth: 0 }));
+            if (typeof onCursorOffsetChange === 'function') onCursorOffsetChange(clamped);
+        }
+    }, [externalCursorOffset, originalValue, onCursorOffsetChange]);
+    const cursorActualWidth = highlightPastedText ? cursorWidth : 0;
+    const value = mask ? mask.repeat(originalValue.length) : originalValue;
+    let renderedValue = value;
+    let renderedPlaceholder = placeholder ? chalk.grey(placeholder) : undefined;
+    if (showCursor && focus) {
+        renderedPlaceholder = placeholder.length > 0 ? chalk.inverse(placeholder[0]) + chalk.grey(placeholder.slice(1)) : chalk.inverse(' ');
+        renderedValue = value.length > 0 ? '' : chalk.inverse(' ');
+        let i = 0;
+        for (const char of value) {
+            renderedValue += i >= cursorOffset - cursorActualWidth && i <= cursorOffset ? chalk.inverse(char) : char;
+            i++;
+        }
+        if (value.length > 0 && cursorOffset === value.length) {
+            renderedValue += chalk.inverse(' ');
+        }
+    }
+    useInput((input, key) => {
+        if (key && key.isPasted) {
+            return;
+        }
+        // Treat Escape as a control key (don't insert into value)
+        if (key.escape || key.upArrow || key.downArrow || (key.ctrl && input === 'c') || key.tab || (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            if (onSubmit) {
+                onSubmit(originalValue);
+            }
+            return;
+        }
+        let nextCursorOffset = cursorOffset;
+        let nextValue = originalValue;
+        let nextCursorWidth = 0;
+        if (key.leftArrow) {
+            if (showCursor) {
+                nextCursorOffset--;
+            }
+        }
+        else if (key.rightArrow) {
+            if (showCursor) {
+                nextCursorOffset++;
+            }
+        }
+        else if (key.backspace || key.delete) {
+            if (cursorOffset > 0) {
+                nextValue = originalValue.slice(0, cursorOffset - 1) + originalValue.slice(cursorOffset, originalValue.length);
+                nextCursorOffset--;
+            }
+        }
+        else if (key.ctrl && input === 'a') {
+            // CTRL-A: jump to beginning of line
+            if (showCursor) {
+                nextCursorOffset = 0;
+            }
+        }
+        else if (key.ctrl && input === 'e') {
+            // CTRL-E: jump to end of line
+            if (showCursor) {
+                nextCursorOffset = originalValue.length;
+            }
+        }
+        else {
+            nextValue = originalValue.slice(0, cursorOffset) + input + originalValue.slice(cursorOffset, originalValue.length);
+            nextCursorOffset += input.length;
+            if (input.length > 1) {
+                nextCursorWidth = input.length;
+            }
+        }
+        if (cursorOffset < 0) {
+            nextCursorOffset = 0;
+        }
+        if (cursorOffset > originalValue.length) {
+            nextCursorOffset = originalValue.length;
+        }
+        setState({ cursorOffset: nextCursorOffset, cursorWidth: nextCursorWidth });
+        if (typeof onCursorOffsetChange === 'function') onCursorOffsetChange(nextCursorOffset);
+        if (nextValue !== originalValue) {
+            onChange(nextValue);
+        }
+    }, { isActive: focus });
+    return (React.createElement(Text, null, placeholder ? (value.length > 0 ? renderedValue : renderedPlaceholder) : renderedValue));
+}
+export default TextInput;
+export function UncontrolledTextInput({ initialValue = '', ...props }) {
+    const [value, setValue] = useState(initialValue);
+    return React.createElement(TextInput, { ...props, value: value, onChange: setValue });
+}
+