nexrall-code 0.5.115 → 0.5.117

package/dist/ui/theme.js

@@ -1,385 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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);
-        });
-    });
-}