Add file browser, tests, and bin entrypoint

src/autocomplete-input.js

@@ -14,6 +14,12 @@
  *
  * The filter term is frozen while the menu is open, so completing a command
  * with Tab does not collapse the list — repeated ↑/↓ + Tab still works.
+ *
+ * It also hosts an in-prompt **file browser** (opened with Ctrl+O) with two
+ * modes: browse and line-select. The user picks a whole file (`@path`) or a
+ * line range (`@path:start-end`), and the reference is spliced into the draft
+ * at the caret. See `file-browser.js` for the pure helpers and PLAN.md for the
+ * design.
  */
 
 import chalk from 'chalk';
@@ -22,18 +28,30 @@ import {
     useState,
     useKeypress,
     useEffect,
+    useRef,
     usePrefix,
     isEnterKey,
     isTabKey,
     isUpKey,
     isDownKey,
+    isBackspaceKey,
     makeTheme,
 } from '@inquirer/core';
 
 import { COMMANDS, filterCommands } from './slash-commands.js';
+import {
+    listEntries,
+    readLines,
+    formatMention,
+    normalizeRange,
+    windowStart,
+    parentOf,
+} from './file-browser.js';
 
 const MAX_SUGGESTIONS = 6;
 const NAME_WIDTH = Math.max(...COMMANDS.map((c) => c.name.length));
+const BROWSE_WINDOW = 12; // visible rows in the file browser
+const LINE_WINDOW = 18; // visible rows in the line selector
 
 /** Show the inline menu only while the first word is being typed (no space yet). */
 function termFrom(line) {
@@ -62,13 +80,159 @@ export const autocompleteInput = createPrompt((config, done) => {
     const [term, setTerm] = useState(termFrom(initial)); // frozen filter term while the menu is open
     const [active, setActive] = useState(0); // highlighted suggestion index
 
+    // ── File-browser state ──────────────────────────────────────────────
+    // mode: 'input' (normal editing) | 'browse' (file picker) | 'lines' (line selector)
+    const [mode, setMode] = useState('input');
+    const [cwd, setCwd] = useState('');           // browse dir, relative to ROOT_DIR ('' = root)
+    const [entries, setEntries] = useState([]);   // listing for `cwd`
+    const [browseActive, setBrowseActive] = useState(0);
+    const [selFile, setSelFile] = useState(null); // file chosen in 'lines' mode
+    const [fileLines, setFileLines] = useState([]);
+    const [fileBinary, setFileBinary] = useState(false);
+    const [cursor, setCursor] = useState(0);       // current line index in 'lines' mode
+    const [anchor, setAnchor] = useState(null);    // range-selection anchor (line index) or null
+    const [notice, setNotice] = useState('');      // dim status/notice line
+
+    // The draft (and caret) captured when the browser opened, so a cancel can
+    // restore the untouched message and an insert knows where to splice.
+    const draftRef = useRef('');
+    const caretRef = useRef(0);
+    // Mirror `mode` into a ref so the SIGINT guard (installed once) sees it.
+    const modeRef = useRef('input');
+    modeRef.current = mode;
+
     const prefix = usePrefix({ status, theme });
     const suggestions = term === null ? [] : filterCommands(term).slice(0, MAX_SUGGESTIONS);
     const count = suggestions.length;
 
+    // ── Browser helpers ─────────────────────────────────────────────────
+    const openDir = (rel) => {
+        setCwd(rel);
+        setEntries(listEntries(rel));
+        setBrowseActive(0);
+        setNotice('');
+    };
+
+    const openFile = (rel) => {
+        const { lines, binary, error } = readLines(rel);
+        if (error) {
+            setNotice(`could not read ${rel}`);
+            setEntries(listEntries(cwd)); // refresh in case it moved/vanished
+            return;
+        }
+        setSelFile(rel);
+        setFileLines(lines);
+        setFileBinary(binary);
+        setCursor(0);
+        setAnchor(null);
+        setNotice(binary ? 'binary file — whole-file mention only' : '');
+        setMode('lines');
+    };
+
+    const cancelToInput = (rl) => {
+        replaceBuffer(rl, draftRef.current);
+        const back = draftRef.current.length - caretRef.current;
+        for (let i = 0; i < back; i++) rl.write(null, { ctrl: true, name: 'b' });
+        setMode('input');
+        setNotice('');
+    };
+
+    // Splice `text` into the captured draft at the captured caret, leaving the
+    // caret just after the inserted text, then return to normal input mode.
+    const insertMention = (rl, text) => {
+        const draft = draftRef.current;
+        const pos = Math.min(caretRef.current, draft.length);
+        const before = draft.slice(0, pos);
+        const after = draft.slice(pos);
+        const pad = before.length && !/\s$/.test(before) ? ' ' : '';
+        const next = before + pad + text + after;
+        replaceBuffer(rl, next);
+        for (let i = 0; i < after.length; i++) rl.write(null, { ctrl: true, name: 'b' });
+        setValue(next);
+        setTerm(termFrom(next));
+        setActive(0);
+        setMode('input');
+        setNotice('');
+    };
+
     useKeypress((key, rl) => {
         if (status !== 'idle') return;
 
+        // ── Browse mode ─────────────────────────────────────────────────
+        if (mode === 'browse') {
+            const n = entries.length;
+            if (isUpKey(key)) {
+                if (n) setBrowseActive((browseActive - 1 + n) % n);
+                return;
+            }
+            if (isDownKey(key)) {
+                if (n) setBrowseActive((browseActive + 1) % n);
+                return;
+            }
+            if (isEnterKey(key)) {
+                const entry = entries[browseActive];
+                if (!entry) return;
+                if (entry.type === 'f') openFile(entry.rel);
+                else openDir(entry.rel); // dir or synthetic '..'
+                return;
+            }
+            if (isTabKey(key)) {
+                const entry = entries[browseActive];
+                if (entry && entry.type === 'f') insertMention(rl, formatMention(entry.rel));
+                return;
+            }
+            if (isBackspaceKey(key)) {
+                if (cwd) openDir(parentOf(cwd));
+                return;
+            }
+            if (key.name === 'escape') cancelToInput(rl);
+            return; // swallow every other key so the draft is untouched
+        }
+
+        // ── Line-select mode ────────────────────────────────────────────
+        if (mode === 'lines') {
+            const n = fileLines.length;
+            if (isUpKey(key)) {
+                setCursor(Math.max(0, cursor - 1));
+                return;
+            }
+            if (isDownKey(key)) {
+                setCursor(Math.max(0, Math.min(n - 1, cursor + 1)));
+                return;
+            }
+            if (!fileBinary && n > 0) {
+                if (key.name === 'v') { setAnchor(anchor === null ? cursor : null); return; }
+                if (key.name === 'g') { setCursor(0); return; }
+                if (key.name === 'G') { setCursor(n - 1); return; }
+            }
+            if (isEnterKey(key)) {
+                let text;
+                if (anchor !== null && n > 0) {
+                    const { start, end } = normalizeRange(anchor, cursor);
+                    text = formatMention(selFile, start, end);
+                } else {
+                    text = formatMention(selFile);
+                }
+                insertMention(rl, text);
+                return;
+            }
+            if (key.name === 'escape' || isBackspaceKey(key)) {
+                setMode('browse');
+                setNotice('');
+            }
+            return;
+        }
+
+        // ── Input mode (normal editing) ─────────────────────────────────
+        // Ctrl+O opens the file browser at the workspace root.
+        if (key.ctrl && key.name === 'o') {
+            draftRef.current = rl.line;
+            caretRef.current = rl.cursor;
+            openDir('');
+            setMode('browse');
+            return;
+        }
+
         if (isEnterKey(key)) {
             const answer = value || rl.line;
             setValue(answer);
@@ -109,9 +273,80 @@ export const autocompleteInput = createPrompt((config, done) => {
         if (initial) rl.write(initial);
     }, []);
 
+    // While browsing, Ctrl+C should return to the prompt, not abort the whole
+    // prompt. @inquirer/core installs its own SIGINT listener that rejects the
+    // prompt; wrap it so it only fires when we're in normal input mode.
+    useEffect((rl) => {
+        const existing = rl.listeners('SIGINT');
+        rl.removeAllListeners('SIGINT');
+        const guarded = (...args) => {
+            if (modeRef.current === 'input') existing.forEach((fn) => fn.apply(rl, args));
+        };
+        rl.on('SIGINT', guarded);
+        return () => {
+            rl.removeAllListeners('SIGINT');
+            existing.forEach((fn) => rl.on('SIGINT', fn));
+        };
+    }, []);
+
     const message = theme.style.message(config.message);
     const formattedValue = status === 'done' ? theme.style.answer(value) : value;
 
+    // ── File-browser view ───────────────────────────────────────────────
+    if (mode === 'browse') {
+        const n = entries.length;
+        const start = windowStart(browseActive, n, BROWSE_WINDOW);
+        const end = Math.min(n, start + BROWSE_WINDOW);
+        const rows = [];
+        for (let i = start; i < end; i++) {
+            const e = entries[i];
+            const marker = i === browseActive ? chalk.cyan('❯') : ' ';
+            let label;
+            if (e.type === 'parent') label = chalk.dim('../');
+            else if (e.type === 'd') label = chalk.bold.cyan(`${e.name}/`);
+            else label = e.name;
+            rows.push(`  ${marker} ${label}`);
+        }
+        const where = cwd ? `${cwd}/` : '(workspace root)';
+        const out = [
+            `  ${chalk.bold.cyan('📁 File browser')} ${chalk.dim(where)}`,
+            rows.length ? rows.join('\n') : chalk.dim('  (empty directory)'),
+        ];
+        if (notice) out.push(chalk.dim(`  ${notice}`));
+        out.push(chalk.dim('  ↑/↓ move · Enter open · Tab mention · Backspace up · Esc cancel'));
+        return out.join('\n');
+    }
+
+    // ── Line-selector view ──────────────────────────────────────────────
+    if (mode === 'lines') {
+        const n = fileLines.length;
+        const out = [`  ${chalk.bold.cyan(selFile)} ${chalk.dim('— select lines')}`];
+        if (fileBinary) {
+            out.push(chalk.dim('  (binary file — Enter mentions the whole file)'));
+        } else if (n === 0) {
+            out.push(chalk.dim('  (empty file — Enter mentions the whole file)'));
+        } else {
+            const start = windowStart(cursor, n, LINE_WINDOW);
+            const end = Math.min(n, start + LINE_WINDOW);
+            const width = String(n).length;
+            const lo = anchor === null ? null : Math.min(anchor, cursor);
+            const hi = anchor === null ? null : Math.max(anchor, cursor);
+            const rows = [];
+            for (let i = start; i < end; i++) {
+                const cur = i === cursor ? chalk.cyan('❯') : ' ';
+                const mark = lo !== null && i >= lo && i <= hi ? chalk.cyan('│') : ' ';
+                const num = chalk.dim(String(i + 1).padStart(width));
+                const text = fileLines[i].replace(/\t/g, '    ');
+                rows.push(`  ${cur} ${num} ${mark} ${i === cursor ? chalk.white(text) : text}`);
+            }
+            out.push(rows.join('\n'));
+        }
+        if (notice) out.push(chalk.dim(`  ${notice}`));
+        out.push(chalk.dim('  ↑/↓ move · v mark · g/G top/bottom · Enter insert · Esc back'));
+        return out.join('\n');
+    }
+
+    // ── Input view (unchanged) ──────────────────────────────────────────
     const lines = suggestions.map((c, i) => {
         const marker = i === active % count ? chalk.cyan('❯') : ' ';
         return `  ${chalk.cyan(marker)} ${chalk.bold(c.name.padEnd(NAME_WIDTH + 2))} ${chalk.dim(c.description)}`;