@teammates/cli 0.1.0 → 0.2.0

package/dist/console/paste-handler.js

@@ -0,0 +1,177 @@
+/**
+ * PasteHandler — detects and manages pasted text in a readline REPL.
+ *
+ * Handles:
+ * - Multi-line pastes: collapses into a numbered placeholder, expands on Enter
+ * - Long single-line pastes: dispatches directly with truncated preview
+ * - File drag & drop: detects pasted file paths, converts to [Image #N] / [File #N] tags
+ *
+ * Works on both Windows and macOS terminals.
+ */
+import { esc } from "@teammates/consolonia";
+import { FileDropHandler } from "./file-drop.js";
+export class PasteHandler {
+    buffer = [];
+    timer = null;
+    count = 0;
+    storedTexts = new Map();
+    prePastePrefix = "";
+    lastKeystrokeTime = 0;
+    fileDrop;
+    rl;
+    output;
+    debounceMs;
+    longPasteThreshold;
+    onLine;
+    formatPrompt;
+    formatFileTag;
+    formatFileHint;
+    constructor(options) {
+        this.rl = options.rl;
+        this.output = options.output;
+        this.debounceMs = options.debounceMs ?? 30;
+        this.longPasteThreshold = options.longPasteThreshold ?? 100;
+        this.onLine = options.onLine;
+        this.formatPrompt = options.formatPrompt ?? (() => "> ");
+        this.fileDrop = new FileDropHandler();
+        this.formatFileTag =
+            options.formatFileTag ??
+                ((a) => {
+                    const type = a.isImage ? "Image" : "File";
+                    return `[${type} #${a.id}]`;
+                });
+        this.formatFileHint =
+            options.formatFileHint ??
+                ((a) => {
+                    const type = a.isImage ? "Image" : "File";
+                    const sizeKB = (a.size / 1024).toFixed(1);
+                    return `  ${type}: ${a.name} (${sizeKB}KB)`;
+                });
+        this.installHooks();
+    }
+    /** Call from _ttyWrite override to track keystroke timing. */
+    onKeystroke() {
+        const now = Date.now();
+        if (now - this.lastKeystrokeTime > 50) {
+            this.prePastePrefix = this.rl.line ?? "";
+        }
+        this.lastKeystrokeTime = now;
+    }
+    /** Clear all stored paste data (e.g. on session reset). */
+    reset() {
+        this.storedTexts.clear();
+        this.fileDrop.clear();
+        this.buffer = [];
+        this.count = 0;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+    installHooks() {
+        // Pre-mute: detect paste from stdin chunk size/shape BEFORE readline echoes
+        process.stdin.prependListener("data", (chunk) => {
+            const str = chunk.toString();
+            const hasMultipleNewlines = str.includes("\n") && str.indexOf("\n") < str.length - 1;
+            const isLongChunk = str.length > this.longPasteThreshold;
+            if (hasMultipleNewlines || isLongChunk) {
+                this.output.mute();
+            }
+        });
+        // Buffer lines from readline, debounce to detect paste vs typing
+        this.rl.on("line", (line) => {
+            this.buffer.push(line);
+            if (this.buffer.length === 1) {
+                this.output.mute();
+            }
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = setTimeout(() => this.processPaste(), this.debounceMs);
+        });
+    }
+    processPaste() {
+        this.timer = null;
+        this.output.unmute();
+        const lines = this.buffer;
+        this.buffer = [];
+        if (lines.length === 0)
+            return;
+        if (lines.length > 1) {
+            // Multi-line paste — erase the first echoed line, show placeholder
+            process.stdout.write(esc.moveUp(1) + esc.eraseLine);
+            this.count++;
+            const combined = lines.join("\n");
+            const sizeKB = Buffer.byteLength(combined, "utf-8") / 1024;
+            const tag = `[Pasted text #${this.count} +${lines.length} lines, ${sizeKB.toFixed(1)}KB] `;
+            this.storedTexts.set(this.count, combined);
+            const newLine = this.prePastePrefix + tag;
+            this.prePastePrefix = "";
+            this.rl.line = newLine;
+            this.rl.cursor = newLine.length;
+            this.rl.prompt(true);
+            return;
+        }
+        // Single line
+        const rawLine = lines[0];
+        // ── File drop detection ──────────────────────────────────────────
+        // Check if the pasted text is a file path (drag & drop).
+        // The raw line may include the pre-paste prefix (e.g. "@beacon ").
+        const trimmedLine = rawLine.trim();
+        const detectedPath = this.fileDrop.detectFilePath(trimmedLine);
+        if (detectedPath) {
+            // It's a file drop — convert to an inline tag
+            const { text: taggedText } = this.fileDrop.processInput(trimmedLine);
+            const attachment = this.fileDrop.getAll().at(-1);
+            // Clear the echoed path and replace with tag in the prompt line
+            process.stdout.write(`\r${esc.eraseLine}`);
+            const newLine = this.prePastePrefix + taggedText;
+            this.prePastePrefix = "";
+            this.rl.line = newLine;
+            this.rl.cursor = newLine.length;
+            // Show the file hint below
+            console.log(this.formatPrompt() + newLine);
+            console.log(this.formatFileHint(attachment));
+            this.rl.prompt(true);
+            return;
+        }
+        // Also check if a file path is embedded in the line (with other text)
+        const { text: processedText, filesDetected } = this.fileDrop.processInput(rawLine);
+        const effectiveLine = filesDetected ? processedText : rawLine;
+        // If it was a long muted paste, show a truncated preview
+        if (effectiveLine.length > this.longPasteThreshold && !filesDetected) {
+            const preview = `${effectiveLine.slice(0, 80)}...`;
+            process.stdout.write(`\r${esc.eraseLine}`);
+            const prompt = this.formatPrompt();
+            process.stdout.write(`${prompt + preview}\n`);
+        }
+        // If files were detected but the line has other text too, update the display
+        if (filesDetected) {
+            process.stdout.write(`\r${esc.eraseLine}`);
+            const prompt = this.formatPrompt();
+            process.stdout.write(`${prompt + processedText}\n`);
+            for (const a of this.fileDrop.getAll()) {
+                console.log(this.formatFileHint(a));
+            }
+        }
+        // Expand paste placeholders from prior multi-line pastes
+        const hasPaste = /\[Pasted text #\d+/.test(effectiveLine);
+        const input = effectiveLine
+            .replace(/\[Pasted text #(\d+) \+\d+ lines, [\d.]+KB\]\s*/g, (_match, num) => {
+            const n = parseInt(num, 10);
+            const text = this.storedTexts.get(n);
+            if (text) {
+                this.storedTexts.delete(n);
+                return `${text}\n`;
+            }
+            return "";
+        })
+            .trim();
+        // Expand file tags to paths and collect attachments
+        const { text: expandedInput, attachments } = this.fileDrop.expandTags(input);
+        this.onLine({
+            input: filesDetected ? expandedInput : input,
+            hadPaste: hasPaste || filesDetected,
+            attachments,
+        });
+    }
+}

package/dist/console/prompt-box.d.ts

@@ -0,0 +1,55 @@
+/**
+ * PromptBox — renders a fenced input box around the readline prompt.
+ *
+ * Draws horizontal borders above and below the input line, similar to
+ * Claude Code's UI. Automatically recalculates on terminal resize.
+ *
+ * Layout:
+ *   ────────────────────────────────────────
+ *   ❯ user input here
+ *   ────────────────────────────────────────
+ *   (optional status / dropdown lines)
+ *
+ * Approach (inspired by Consolonia's dirty-region rendering):
+ *   - _refreshLine hook uses esc.eraseDown to nuke everything below the
+ *     prompt, then redraws the bottom border + dropdown fresh each time.
+ *   - On resize, the entire prompt area (top border + prompt + bottom)
+ *     is cleared and redrawn. We don't try to navigate to old content
+ *     since terminal reflow makes cursor-relative positioning unreliable.
+ */
+import type { Interface as ReadlineInterface } from "node:readline";
+export interface PromptBoxOptions {
+    /** Readline interface. */
+    rl: ReadlineInterface;
+    /** Border character (default: "─"). */
+    borderChar?: string;
+    /** ANSI color wrapper for the border (default: dim/gray). */
+    borderStyle?: (s: string) => string;
+    /** Optional status line rendered below the bottom border. */
+    getStatusLine?: () => string | null;
+}
+export declare class PromptBox {
+    private rl;
+    private out;
+    private borderChar;
+    private borderStyle;
+    private getStatusLine;
+    private refreshing;
+    private dropdownLines;
+    private active;
+    constructor(options: PromptBoxOptions);
+    /** Set dropdown content to render below the bottom border. */
+    setDropdown(lines: string[]): void;
+    /** Clear dropdown content. */
+    clearDropdown(): void;
+    /**
+     * Draw the top border and activate the prompt box.
+     * Call before rl.prompt().
+     */
+    drawTopBorder(): void;
+    /** Deactivate during dispatch so streaming output isn't corrupted. */
+    deactivate(): void;
+    private buildBorder;
+    private installHook;
+    private listenResize;
+}

package/dist/console/prompt-box.js

@@ -0,0 +1,120 @@
+/**
+ * PromptBox — renders a fenced input box around the readline prompt.
+ *
+ * Draws horizontal borders above and below the input line, similar to
+ * Claude Code's UI. Automatically recalculates on terminal resize.
+ *
+ * Layout:
+ *   ────────────────────────────────────────
+ *   ❯ user input here
+ *   ────────────────────────────────────────
+ *   (optional status / dropdown lines)
+ *
+ * Approach (inspired by Consolonia's dirty-region rendering):
+ *   - _refreshLine hook uses esc.eraseDown to nuke everything below the
+ *     prompt, then redraws the bottom border + dropdown fresh each time.
+ *   - On resize, the entire prompt area (top border + prompt + bottom)
+ *     is cleared and redrawn. We don't try to navigate to old content
+ *     since terminal reflow makes cursor-relative positioning unreliable.
+ */
+import { esc, stripAnsi, truncateAnsi } from "@teammates/consolonia";
+import { cursorToCol } from "./ansi.js";
+export class PromptBox {
+    rl;
+    out = process.stdout;
+    borderChar;
+    borderStyle;
+    getStatusLine;
+    refreshing = false;
+    dropdownLines = [];
+    active = false;
+    constructor(options) {
+        this.rl = options.rl;
+        this.borderChar = options.borderChar ?? "─";
+        this.borderStyle = options.borderStyle ?? ((s) => `\x1b[2m${s}\x1b[0m`);
+        this.getStatusLine = options.getStatusLine ?? (() => null);
+        this.installHook();
+        this.listenResize();
+    }
+    /** Set dropdown content to render below the bottom border. */
+    setDropdown(lines) {
+        this.dropdownLines = lines;
+        this.rl._refreshLine();
+    }
+    /** Clear dropdown content. */
+    clearDropdown() {
+        this.dropdownLines = [];
+    }
+    /**
+     * Draw the top border and activate the prompt box.
+     * Call before rl.prompt().
+     */
+    drawTopBorder() {
+        this.out.write(`${this.buildBorder()}\n`);
+        this.active = true;
+    }
+    /** Deactivate during dispatch so streaming output isn't corrupted. */
+    deactivate() {
+        this.active = false;
+    }
+    buildBorder() {
+        const width = this.out.columns || 80;
+        return this.borderStyle(this.borderChar.repeat(width));
+    }
+    installHook() {
+        const origRefresh = this.rl._refreshLine.bind(this.rl);
+        this.rl._refreshLine = () => {
+            if (this.refreshing || !this.active) {
+                origRefresh();
+                return;
+            }
+            this.refreshing = true;
+            // Let readline clear the prompt line and rewrite it
+            origRefresh();
+            // Nuke everything below the prompt line, then draw fresh.
+            // This avoids stale content from previous renders at different widths.
+            const cols = this.out.columns || 80;
+            let buf = esc.eraseDown;
+            let linesBelow = 0;
+            // Bottom border
+            buf += `\n${this.buildBorder()}`;
+            linesBelow++;
+            // Status line
+            const status = this.getStatusLine();
+            if (status) {
+                buf += `\n${truncateAnsi(status, cols - 1)}`;
+                linesBelow++;
+            }
+            // Dropdown lines
+            for (const line of this.dropdownLines) {
+                buf += `\n${truncateAnsi(line, cols - 1)}`;
+                linesBelow++;
+            }
+            this.out.write(buf);
+            // Move cursor back up to the prompt line
+            this.out.write(esc.moveUp(linesBelow));
+            // Restore cursor column
+            const promptText = this.rl._prompt ?? "";
+            const promptLen = stripAnsi(promptText).length;
+            const cursor = this.rl.cursor ?? 0;
+            this.out.write(cursorToCol(promptLen + cursor + 1));
+            this.refreshing = false;
+        };
+    }
+    listenResize() {
+        this.out.on("resize", () => {
+            if (!this.active)
+                return;
+            // After resize, terminal has reflowed all content. Cursor-relative
+            // navigation to old content is unreliable (a 150-char border now
+            // wraps to 2 lines on an 80-col terminal, etc.).
+            //
+            // Strategy: scroll past any reflowed junk by writing blank lines,
+            // then draw a fresh prompt area. The old top border in scrollback
+            // may look wrong — that's acceptable, same as any terminal app.
+            this.out.write(`\n\n${esc.eraseLine}`);
+            this.out.write(`${this.buildBorder()}\n`);
+            this.rl.prompt();
+        });
+    }
+}

package/dist/console/prompt-input.d.ts

@@ -0,0 +1,136 @@
+/**
+ * PromptInput — consolonia-based replacement for node:readline.
+ *
+ * Uses consolonia's InputProcessor for raw terminal input parsing
+ * (escape sequences, bracketed paste, mouse events) and renders
+ * the prompt line + fenced borders directly via ANSI escape codes.
+ *
+ * This is a scrolling REPL input component, NOT a full-screen TUI.
+ * Agent output scrolls normally above; only the input area is managed.
+ *
+ * Layout:
+ *   ────────────────────────────────────────
+ *   ❯ user input here|
+ *   ────────────────────────────────────────
+ *   (optional dropdown lines)
+ */
+import { EventEmitter } from "node:events";
+export interface PromptInputOptions {
+    /** Prompt string (may include ANSI color codes). */
+    prompt?: string;
+    /** Border character (default: "─"). */
+    borderChar?: string;
+    /** ANSI style wrapper for the border. */
+    borderStyle?: (s: string) => string;
+    /** Command history entries (most recent last). */
+    history?: string[];
+    /**
+     * Intercept up/down arrow keys before history navigation.
+     * Return true to consume the key (e.g. for wordwheel navigation).
+     */
+    onUpDown?: (direction: "up" | "down") => boolean;
+    /**
+     * Called just before Enter submits the line. Can modify the value
+     * (e.g. to accept a wordwheel selection). Return the final line text,
+     * or undefined to use the current value as-is.
+     */
+    beforeSubmit?: (currentValue: string) => string | undefined;
+    /**
+     * Colorize the input value for display. Must preserve visible length
+     * (only add ANSI codes, don't change the text). Used for syntax
+     * highlighting @mentions and /commands.
+     */
+    colorize?: (value: string) => string;
+    /**
+     * Return dim placeholder text to show after the current input value.
+     * Called on every refresh. Return null or empty string for no hint.
+     * The returned text is displayed in dim style and is not part of the value.
+     */
+    hint?: (value: string) => string | null;
+}
+export declare class PromptInput extends EventEmitter {
+    private _prompt;
+    private _promptLen;
+    private _borderChar;
+    private _borderStyle;
+    private _value;
+    private _cursor;
+    private _history;
+    private _historyIndex;
+    private _savedInput;
+    private _active;
+    private _dropdownLines;
+    private _linesBelow;
+    private _processor;
+    private _events;
+    private _dataHandler;
+    private _resizeHandler;
+    private _wasRawMode;
+    private _onUpDown;
+    private _beforeSubmit;
+    private _colorize;
+    private _hint;
+    private _resizeTimer;
+    private _promptRows;
+    private _cursorRow;
+    private _drawnCols;
+    private _statusLine;
+    constructor(options?: PromptInputOptions);
+    /** Current line text. */
+    get line(): string;
+    /** Current cursor position. */
+    get cursor(): number;
+    /** Whether the input is active (accepting keystrokes). */
+    get active(): boolean;
+    /** Command history. */
+    get history(): string[];
+    /** Set prompt text. */
+    set prompt(text: string);
+    get prompt(): string;
+    /** Set the line text and move cursor to end. */
+    setLine(text: string): void;
+    /** Show dropdown content below the bottom border. */
+    setDropdown(lines: string[]): void;
+    /** Clear dropdown content. */
+    clearDropdown(): void;
+    /**
+     * Activate the prompt: enable raw mode, bracketed paste, draw UI.
+     * Call this to show the prompt and start accepting input.
+     */
+    activate(): void;
+    /**
+     * Deactivate the prompt: stop drawing but keep raw mode and input
+     * handling active so Ctrl+C still works during dispatch.
+     */
+    deactivate(): void;
+    /**
+     * Erase the entire prompt area (top border + prompt + bottom border + dropdown)
+     * and deactivate. Cursor ends at the position where the top border was.
+     * Used when the prompt area should be replaced with other content (e.g. user message block).
+     */
+    deactivateAndErase(): void;
+    /**
+     * Set a status line that renders above the top border.
+     * Pass null to clear it. The status line is re-rendered in place
+     * without redrawing the entire prompt — ideal for animation.
+     */
+    setStatus(text: string | null): void;
+    /** Fully close the input, destroy processor, restore terminal. */
+    close(): void;
+    private _handleInput;
+    private _handlePaste;
+    private _handleKey;
+    private _historyBack;
+    private _historyForward;
+    private _wordBoundaryLeft;
+    private _wordBoundaryRight;
+    private _cols;
+    private _buildBorder;
+    private _drawStatusLine;
+    private _drawTopBorder;
+    private _drawPromptLine;
+    private _drawBelow;
+    /** Full refresh of the prompt area. */
+    private _refresh;
+    private _onResize;
+}