nexrall-code 0.5.107 → 0.5.109

package/dist/ui/theme.js

@@ -0,0 +1,385 @@
+import chalk from 'chalk';
+import stringWidth from 'string-width';
+// ─── Color Palette ────────────────────────────────────────────────────────────
+export const colors = {
+    primary: chalk.blue,
+    success: chalk.green,
+    error: chalk.red,
+    warning: chalk.yellow,
+    dim: chalk.dim,
+    bold: chalk.bold,
+    cyan: chalk.cyan,
+    gray: chalk.gray,
+};
+// ─── Icons ────────────────────────────────────────────────────────────────────
+export const icons = {
+    tool: '⚡',
+    file: '📄',
+    dir: '📁',
+    check: '✓',
+    cross: '✗',
+    arrow: '→',
+    thinking: '◆',
+    code: '{}',
+};
+// ─── Banner ───────────────────────────────────────────────────────────────────
+export function banner() {
+    const version = '0.1.1';
+    console.log();
+    console.log(chalk.bold.blue('  ███╗   ██╗███████╗██╗  ██╗'));
+    console.log(chalk.bold.blue('  ████╗  ██║██╔════╝╚██╗██╔╝'));
+    console.log(chalk.bold.blue('  ██╔██╗ ██║█████╗   ╚███╔╝ '));
+    console.log(chalk.bold.blue('  ██║╚██╗██║██╔══╝   ██╔██╗ '));
+    console.log(chalk.bold.blue('  ██║ ╚████║███████╗██╔╝ ██╗'));
+    console.log(chalk.bold.blue('  ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═╝'));
+    console.log();
+    console.log(chalk.bold('  Nexrall Code') +
+        chalk.dim(`  v${version}`) +
+        chalk.dim('  ·  ') +
+        chalk.cyan('AI coding assistant'));
+    console.log(chalk.dim('  ─────────────────────────────────────'));
+    console.log();
+}
+// ─── Streaming Markdown Renderer ──────────────────────────────────────────────
+//
+// Buffers incomplete lines, renders complete lines with terminal formatting.
+// Tables are fully buffered until a non-table line arrives so column widths
+// can be computed dynamically — fixing alignment and ANSI padding bugs.
+/**
+ * Width of `s` in terminal CELLS, ignoring ANSI styling.
+ *
+ * This is deliberately NOT `String#length`. A terminal grid is measured in
+ * cells, and the mapping from characters to cells is not 1:1:
+ *   • CJK ideographs, kana, Hangul and fullwidth forms occupy TWO cells each
+ *     ("你好" is 2 characters but 4 cells wide).
+ *   • Most emoji are two cells, and a ZWJ sequence like "👨‍👩‍👧" is many code
+ *     points but still renders as a single two-cell glyph.
+ *   • Combining marks ("e" + U+0301) and zero-width joiners add code points
+ *     but no width at all.
+ *
+ * Measuring with `.length` therefore under- or over-counts for every language
+ * that isn't plain Latin, which silently breaks anything doing column
+ * arithmetic on top of it — the welcome banner's box drew its border 6 cells
+ * too narrow the moment the working-directory path contained CJK, leaving the
+ * frame visibly torn.
+ *
+ * `string-width` is the same battle-tested implementation Ink itself uses to
+ * lay out text (it is already in the dependency tree for that reason), so
+ * this keeps our own measurements consistent with how Ink measures the rest
+ * of the UI, instead of maintaining a second, hand-rolled Unicode width table.
+ */
+export function visibleLen(s) {
+    return stringWidth(s);
+}
+/** Pad s to n visible cells (safe with ANSI codes and wide/zero-width chars). */
+export function padVis(s, n) {
+    const pad = n - visibleLen(s);
+    return pad > 0 ? s + ' '.repeat(pad) : s;
+}
+/**
+ * Width (in cells) for a decorative horizontal rule — code-block borders,
+ * the `---` rule, etc. — drawn `'  '` (2-cell indent) + this many `'─'`.
+ *
+ * These used to be hardcoded (`'─'.repeat(48)`, `'─'.repeat(50)`): fine at
+ * the ~80-100 column width most terminals start at, but on anything
+ * narrower the fixed-width string is itself wider than the terminal, so
+ * the terminal's own autowrap breaks it into two lines — visually
+ * identical to the "torn separator" bug already fixed for the input box's
+ * chrome (see resizeRepaint.ts), just for transcript output instead of
+ * live UI. Deriving the width from `process.stdout.columns` at print time
+ * (same convention `rowsOccupied`/`bottomChromeRows` use in screen.ts)
+ * means it can never be wider than the terminal actually is.
+ *
+ *  - `MIN` keeps the rule from collapsing to nothing on extremely narrow
+ *    terminals (a 0-width or 1-`─` rule reads as a rendering glitch, not
+ *    a rule).
+ *  - `MAX` keeps it from stretching edge-to-edge on very wide terminals,
+ *    matching the previous fixed-width look rather than a rule that's
+ *    visually disproportionate to a short paragraph next to it.
+ */
+export function ruleWidth(max = 50, columns = process.stdout.columns || 80) {
+    const MIN = 20;
+    const indent = 2; // the '  ' prefix every call site already adds
+    const available = columns - indent;
+    return Math.max(MIN, Math.min(max, available));
+}
+export class MarkdownStreamRenderer {
+    _buf = ''; // incomplete trailing chunk
+    _inCode = false;
+    _codeLang = '';
+    // Table rows accumulated until a non-table line flushes them.
+    // Each element is a string[] of styled cells, OR ['__SEP__'] for separator row.
+    _tbl = [];
+    // ── Public API ──────────────────────────────��──────────────────────────────
+    feed(chunk) {
+        this._buf += chunk;
+        const parts = this._buf.split('\n');
+        this._buf = parts.pop() ?? '';
+        for (const line of parts)
+            this._line(line);
+    }
+    /**
+     * Drop all buffered/partial state without emitting it.
+     *
+     * Used when a stream died mid-render and the same turn is being restarted: the
+     * replacement attempt re-sends the response from the beginning, so any half-parsed
+     * line, unterminated code fence or partially accumulated table from the dead attempt
+     * must be discarded. Flushing instead would print a fragment and then leave the
+     * renderer in `_inCode`/`_tbl` state that corrupts everything the retry prints.
+     *
+     * Note this only resets the PARSER — characters already written to stdout have
+     * scrolled away and cannot be unprinted; the caller prints a visible restart marker
+     * so the duplicated prefix is explained rather than silently confusing.
+     */
+    reset() {
+        this._buf = '';
+        this._inCode = false;
+        this._codeLang = '';
+        this._tbl = [];
+    }
+    flush() {
+        if (this._buf) {
+            this._line(this._buf);
+            this._buf = '';
+        }
+        if (this._inCode) {
+            console.log(chalk.dim('  └' + '─'.repeat(ruleWidth(48))));
+            this._inCode = false;
+        }
+        this._flushTable();
+        console.log();
+    }
+    // ── Table flush ────────────────────────────────────────────────────────────
+    _flushTable() {
+        if (!this._tbl.length)
+            return;
+        const rows = this._tbl;
+        this._tbl = [];
+        // Find separator row index (marks end of header)
+        const sepIdx = rows.findIndex(r => r[0] === '__SEP__');
+        const dataRows = rows.filter(r => r[0] !== '__SEP__');
+        if (!dataRows.length)
+            return;
+        // Compute max visible width per column (capped at 36 to fit most terminals)
+        const colCount = Math.max(...dataRows.map(r => r.length));
+        const colWidths = Array.from({ length: colCount }, (_, ci) => Math.min(Math.max(...dataRows.map(r => visibleLen(r[ci] ?? '')), 3), 36));
+        const B = chalk.dim('│'); // border char
+        // separator: ──────┼──────┼────── (full width, closed on both ends)
+        const sep = '  ├' + colWidths.map(w => '─'.repeat(w + 2)).join('┼') + '┤';
+        console.log();
+        let dataIdx = 0;
+        rows.forEach(row => {
+            if (row[0] === '__SEP__') {
+                // separator line between header and body
+                console.log(chalk.dim(sep));
+                return;
+            }
+            const isHeader = sepIdx > 0 ? dataIdx === 0 : false;
+            dataIdx++;
+            const cells = Array.from({ length: colCount }, (_, ci) => {
+                const raw = row[ci] ?? '';
+                const styled = isHeader ? chalk.bold(raw) : raw;
+                return padVis(styled, colWidths[ci]);
+            });
+            console.log('  ' + B + ' ' + cells.join(' ' + B + ' ') + ' ' + B);
+        });
+        console.log();
+    }
+    // ── Inline markup ──────────────────────────────────────────────────────────
+    _inline(s) {
+        return s
+            .replace(/\*\*\*(.+?)\*\*\*/g, (_, t) => chalk.bold.italic(t))
+            .replace(/\*\*(.+?)\*\*/g, (_, t) => chalk.bold(t))
+            .replace(/\*(.+?)\*/g, (_, t) => chalk.italic(t))
+            .replace(/__(.+?)__/g, (_, t) => chalk.bold(t))
+            .replace(/_(.+?)_/g, (_, t) => chalk.italic(t))
+            .replace(/~~(.+?)~~/g, (_, t) => chalk.strikethrough(t))
+            .replace(/`([^`]+)`/g, (_, t) => chalk.bgBlack.whiteBright(` ${t} `));
+    }
+    // ── Per-line renderer ──────────────────────────────────────────────────────
+    _line(raw) {
+        // ── Fenced code block ──────────────────────────────────────────────
+        if (raw.startsWith('```')) {
+            this._flushTable();
+            if (!this._inCode) {
+                this._inCode = true;
+                this._codeLang = raw.slice(3).trim();
+                const label = this._codeLang ? chalk.dim(` ${this._codeLang}`) : '';
+                console.log('\n' + chalk.dim('  ┌' + '─'.repeat(ruleWidth(48))) + label);
+            }
+            else {
+                this._inCode = false;
+                console.log(chalk.dim('  └' + '─'.repeat(ruleWidth(48))) + '\n');
+            }
+            return;
+        }
+        if (this._inCode) {
+            console.log(chalk.dim('  │ ') + chalk.cyan(raw));
+            return;
+        }
+        // ── Table row — buffer, render once complete ───────────────────────
+        if (raw.includes('|') && raw.trim().startsWith('|')) {
+            const t = raw.trim();
+            if (/^\|[-| :]+\|$/.test(t)) {
+                this._tbl.push(['__SEP__']);
+            }
+            else {
+                this._tbl.push(t.replace(/^\||\|$/g, '').split('|').map(c => this._inline(c.trim())));
+            }
+            return;
+        }
+        // Non-table line → flush any buffered table rows first
+        this._flushTable();
+        // ── Horizontal rule ────────────────────────────────────────────────
+        if (/^[-*_]{3,}\s*$/.test(raw)) {
+            console.log('\n' + chalk.dim('  ' + '─'.repeat(ruleWidth(50))) + '\n');
+            return;
+        }
+        // ── Headers ───────────────────────────────────────────────────────
+        if (raw.startsWith('#### ')) {
+            console.log('\n' + chalk.bold(raw.slice(5)));
+            return;
+        }
+        if (raw.startsWith('### ')) {
+            console.log('\n' + chalk.bold.underline(raw.slice(4)));
+            return;
+        }
+        if (raw.startsWith('## ')) {
+            console.log('\n' + chalk.bold.cyan(raw.slice(3)));
+            return;
+        }
+        if (raw.startsWith('# ')) {
+            console.log('\n' + chalk.bold.blue(raw.slice(2)));
+            return;
+        }
+        // ── Blockquote ─────────────────────────────────────────────────────
+        if (raw.startsWith('> ')) {
+            console.log(chalk.dim('  ▎ ') + chalk.italic.dim(this._inline(raw.slice(2))));
+            return;
+        }
+        // ── Task list (before ul — more specific regex) ────────────────────
+        const taskM = /^(\s*)[-*+] \[([ xX])\] (.*)$/.exec(raw);
+        if (taskM) {
+            const done = taskM[2].trim() !== '';
+            console.log(`  ${taskM[1]}${done ? chalk.green('✓') : chalk.dim('○')} ` +
+                `${done ? chalk.dim(taskM[3]) : this._inline(taskM[3])}`);
+            return;
+        }
+        // ── Unordered list ─────────────────────────────────────────────────
+        const ulM = /^(\s*)[-*+] (.*)$/.exec(raw);
+        if (ulM) {
+            const bullet = ulM[1].length > 0 ? chalk.dim('◦') : chalk.cyan('•');
+            console.log(`  ${ulM[1]}${bullet} ${this._inline(ulM[2])}`);
+            return;
+        }
+        // ── Ordered list ───────────────────────────────────────────────────
+        const olM = /^(\s*)(\d+)\. (.*)$/.exec(raw);
+        if (olM) {
+            console.log(`  ${olM[1]}${chalk.cyan(olM[2] + '.')} ${this._inline(olM[3])}`);
+            return;
+        }
+        // ── Empty line ─────────────────────────────────────────────────────
+        if (!raw.trim()) {
+            console.log();
+            return;
+        }
+        // ── Normal paragraph ───────────────────────────────────────────────
+        console.log(this._inline(raw));
+    }
+}
+// ─── Tool Formatting ──────────────────────────────────────────────────────────
+export function formatToolUse(name, input) {
+    const primaryArg = input.path ??
+        input.file_path ??
+        input.command ??
+        input.pattern ??
+        input.url ??
+        input.query ??
+        Object.values(input).find(v => typeof v === 'string') ??
+        '';
+    const argDisplay = primaryArg
+        ? chalk.dim(' ') + chalk.white(String(primaryArg).replace(/\n/g, '↵').slice(0, 80))
+        : '';
+    return chalk.yellow(icons.tool) + ' ' + chalk.bold(name) + argDisplay;
+}
+// ─── Live Tool Stream (bash progress) ─────────────────────────────────────────
+//
+// Bash commands used to go silent (spinner only) from onToolUse until the whole
+// command finished — a `npm install` or long test run gave the user no signal
+// beyond "running bash…" for however long it took. This buffers raw stdout/
+// stderr chunks and prints each COMPLETE line as it arrives, dimmed and
+// indented under a guide bar, so the terminal shows real progress. Partial
+// (no-newline-yet) lines are held back so a slow-to-flush line isn't printed
+// half-formed and then reprinted; call `flush()` at tool-result time to emit
+// whatever partial tail remains.
+export class ToolStreamPrinter {
+    carry = '';
+    linesShown = 0;
+    // Cap visible lines per command so a runaway/very chatty process (e.g. a
+    // build tool re-printing a progress bar thousands of times) doesn't flood
+    // the terminal — the full output is still available afterward via
+    // formatToolResult's summary and, for large output, the spill file.
+    static MAX_LINES = 200;
+    capped = false;
+    feed(chunk) {
+        if (this.capped)
+            return;
+        this.carry += chunk;
+        const lines = this.carry.split('\n');
+        this.carry = lines.pop() ?? '';
+        for (const line of lines) {
+            if (!this.printLine(line))
+                return;
+        }
+    }
+    printLine(line) {
+        if (this.linesShown >= ToolStreamPrinter.MAX_LINES) {
+            if (!this.capped) {
+                this.capped = true;
+                console.log(chalk.dim('  │ … output continues (full log in the result above once finished)'));
+            }
+            return false;
+        }
+        this.linesShown++;
+        console.log(chalk.dim('  │ ') + chalk.gray(line.slice(0, 300)));
+        return true;
+    }
+    flush() {
+        if (!this.capped && this.carry)
+            this.printLine(this.carry);
+        this.carry = '';
+    }
+    reset() {
+        this.carry = '';
+        this.linesShown = 0;
+        this.capped = false;
+    }
+}
+export function formatToolResult(name, result, durationMs) {
+    if (result.error) {
+        return chalk.red(icons.cross) + ' ' + chalk.dim(name) +
+            chalk.dim(' · ') + chalk.red('error') + chalk.dim(` · ${durationMs}ms`);
+    }
+    const out = result.output ?? '';
+    const lines = out.split('\n').length;
+    const sizeHint = lines > 1 ? `${lines} lines` : `${out.length} chars`;
+    return chalk.green(icons.check) + ' ' + chalk.dim(name) +
+        chalk.dim(` · ${sizeHint}`) + chalk.dim(` · ${durationMs}ms`);
+}
+// ─── Thinking Block ───────────────────────────────────────────────────────────
+export function formatThinking(text, tokens) {
+    const tokStr = tokens >= 1000
+        ? `~${(tokens / 1000).toFixed(1)}k tokens`
+        : tokens > 0 ? `~${tokens} tokens` : '';
+    const header = chalk.dim(`${icons.thinking} Thought`) + (tokStr ? chalk.dim(` for ${tokStr}`) : '');
+    const preview = text.trim().split('\n').filter(Boolean).slice(0, 3)
+        .map(l => chalk.dim('  ' + l.slice(0, 100))).join('\n');
+    return '\n' + header + (preview ? '\n' + preview : '') + '\n';
+}
+// ─── Usage — output tokens only ───────────────────────────────────────────────
+export function formatUsage(outputTokens) {
+    const tok = outputTokens >= 1000
+        ? `${(outputTokens / 1000).toFixed(1)}k`
+        : String(outputTokens);
+    return chalk.dim(`↓ ${tok} tokens`);
+}

package/dist/ui/trustPrompt.js

@@ -0,0 +1,126 @@
+import React from 'react';
+import { render, Box, Text, useInput, useApp } from 'ink';
+const CHOICES = ['Yes, I trust this folder', 'No, exit'];
+function TrustPrompt({ workDir, signals, onDecide }) {
+    const { exit } = useApp();
+    const [index, setIndex] = React.useState(0);
+    // The selected index is read inside the input handler, which closes over
+    // state from the render it was created in. Enter pressed within the same
+    // frame as an arrow key would otherwise act on the PREVIOUS selection — the
+    // same stale-closure class of bug that made fast Vietnamese input submit an
+    // empty line (see inkTerminal.tsx's lineRef). Keep a ref in sync and read
+    // that instead.
+    const indexRef = React.useRef(0);
+    const setSelection = (next) => {
+        indexRef.current = next;
+        setIndex(next);
+    };
+    const decide = (trusted) => {
+        onDecide(trusted);
+        exit();
+    };
+    useInput((input, key) => {
+        if (key.upArrow) {
+            setSelection((indexRef.current + CHOICES.length - 1) % CHOICES.length);
+            return;
+        }
+        if (key.downArrow) {
+            setSelection((indexRef.current + 1) % CHOICES.length);
+            return;
+        }
+        // Number keys select directly, matching the visible "1." / "2." labels.
+        if (input === '1') {
+            setSelection(0);
+            decide(true);
+            return;
+        }
+        if (input === '2') {
+            setSelection(1);
+            decide(false);
+            return;
+        }
+        // Escape and Ctrl+C are treated as "do not trust". Declining is the safe
+        // default, so any way of backing out must land there rather than
+        // proceeding.
+        if (key.escape || (key.ctrl && input === 'c')) {
+            decide(false);
+            return;
+        }
+        // Enter is delivered as `return` on some terminals and as `\n` on those
+        // with ICRNL translating CR at the tty layer — Ink surfaces the latter as
+        // a distinct key with no `key.return` set, so checking `key.return` alone
+        // silently misses the most common delivery (see inkTerminal.tsx).
+        //
+        // Checking `input === '\r' || input === '\n'` (an EXACT match, as this
+        // used to) misses a real, reproducible case: Ink's `useInput` docs note
+        // that "if the user pastes text and it's more than one character, the
+        // callback will be called only once, and the whole string will be
+        // passed as `input`" — and the same applies to ordinary fast typing, not
+        // just clipboard pastes. Confirmed directly with a pty test: pressing
+        // Enter and immediately typing text right after (well within human
+        // typing speed — e.g. confirming trust, then typing the first message
+        // before the next screen has even drawn) can arrive as ONE input chunk
+        // like `"\nverifyfix"`. The exact match above never fires on that chunk,
+        // `decide()` is never called, and the prompt silently sits there having
+        // ignored the Enter that was actually pressed — until something else
+        // (Ctrl+C, which decides NOT to trust) ends it. That is a real
+        // security-relevant regression: a user who clearly chose "trust" can
+        // end up on the "do not trust" path instead, or the session can appear
+        // to hang.
+        //
+        // Scanning for an embedded \r/\n anywhere in `input` (mirroring
+        // inkTerminal.tsx's own newline-detection for exactly this class of
+        // fast-typing chunk) fixes it: the Enter is honoured as soon as it's
+        // found, regardless of what was typed immediately after it in the same
+        // chunk. Anything after the newline is simply ignored here — the trust
+        // prompt exits right after deciding, so there is no "rest of the line"
+        // to carry forward the way inkTerminal.tsx's main input box has to.
+        if (key.return || /[\r\n]/.test(input)) {
+            decide(indexRef.current === 0);
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, null,
+            React.createElement(Text, { bold: true, color: "yellow" }, "Accessing workspace:")),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { bold: true }, workDir)),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, null, "Quick safety check: is this a project you created, or one you trust?"),
+            React.createElement(Text, null, "Nexrall Code will be able to read, edit and execute files here.")),
+        signals.length > 0 && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
+            React.createElement(Text, { dimColor: true }, "This folder also configures the agent:"),
+            signals.map((s) => (React.createElement(Text, { key: s, dimColor: true }, `  • ${s}`))))),
+        React.createElement(Box, { marginTop: 1, flexDirection: "column" }, CHOICES.map((choice, i) => {
+            const selected = i === index;
+            return (React.createElement(Text, { key: choice, color: selected ? 'blue' : undefined },
+                selected ? '❯ ' : '  ',
+                `${i + 1}. ${choice}`));
+        })),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Enter to confirm \u00B7 Esc to cancel"))));
+}
+/**
+ * Renders the trust prompt and resolves with the user's decision.
+ *
+ * This mounts its own short-lived Ink app and unmounts it before returning:
+ * the prompt has to run BEFORE the main session UI starts (that's the whole
+ * point — nothing from the folder may be loaded until the user decides), and
+ * Ink does not support two concurrent renders sharing one stdout.
+ */
+export function askForTrust(workDir, signals) {
+    return new Promise((resolve) => {
+        let decided = false;
+        const settle = (trusted) => {
+            if (decided)
+                return;
+            decided = true;
+            resolve(trusted);
+        };
+        const app = render(React.createElement(TrustPrompt, { workDir: workDir, signals: signals, onDecide: settle }), { exitOnCtrlC: false });
+        void app.waitUntilExit().then(() => {
+            // If the app exited without an explicit choice (terminal closed, stdin
+            // ended), fall back to NOT trusting.
+            settle(false);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexrall-code",
-  "version": "0.5.107",
+  "version": "0.5.109",
   "description": "Nexrall Code — AI coding assistant for your terminal (headless agent for scripts, CI and automation)",
   "keywords": [
     "ai",