recker 1.0.14 → 1.0.15-next.0dab95d

package/dist/cli/tui/scroll-buffer.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'node:events';
+export interface ScrollBufferOptions {
+    maxLines?: number;
+    viewportHeight?: number;
+}
+export declare class ScrollBuffer extends EventEmitter {
+    private lines;
+    private scrollOffset;
+    private maxLines;
+    private viewportHeight;
+    private isScrollMode;
+    private originalWrite;
+    private pendingOutput;
+    constructor(options?: ScrollBufferOptions);
+    write(content: string): void;
+    flush(): void;
+    get lineCount(): number;
+    get position(): number;
+    get isScrolledUp(): boolean;
+    scrollUp(lines?: number): boolean;
+    scrollDown(lines?: number): boolean;
+    pageUp(): boolean;
+    pageDown(): boolean;
+    scrollToTop(): void;
+    scrollToBottom(): void;
+    getVisibleLines(): string[];
+    render(): string;
+    updateViewport(height?: number): void;
+    enterScrollMode(): void;
+    exitScrollMode(): void;
+    get inScrollMode(): boolean;
+    clear(): void;
+    getScrollInfo(): {
+        current: number;
+        total: number;
+        percent: number;
+    };
+}
+export declare function parseScrollKey(data: Buffer): 'pageUp' | 'pageDown' | 'scrollUp' | 'scrollDown' | 'home' | 'end' | 'escape' | null;
+export declare function parseMouseScroll(data: Buffer): 'scrollUp' | 'scrollDown' | null;
+export declare function enableMouseReporting(): void;
+export declare function disableMouseReporting(): void;
+//# sourceMappingURL=scroll-buffer.d.ts.map

package/dist/cli/tui/scroll-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-buffer.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/scroll-buffer.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,YAAY,CAAa;IACjC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,YAAY,CAAkB;IACtC,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,aAAa,CAAc;gBAEvB,OAAO,GAAE,mBAAwB;IAS7C,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAuB5B,KAAK,IAAI,IAAI;IAUb,IAAI,SAAS,IAAI,MAAM,CAEtB;IAKD,IAAI,QAAQ,IAAI,MAAM,CAErB;IAKD,IAAI,YAAY,IAAI,OAAO,CAE1B;IAKD,QAAQ,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO;IAcpC,UAAU,CAAC,KAAK,GAAE,MAAU,GAAG,OAAO;IAatC,MAAM,IAAI,OAAO;IAOjB,QAAQ,IAAI,OAAO;IAOnB,WAAW,IAAI,IAAI;IAOnB,cAAc,IAAI,IAAI;IAOtB,eAAe,IAAI,MAAM,EAAE;IAS3B,MAAM,IAAI,MAAM;IAsBhB,cAAc,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAOrC,eAAe,IAAI,IAAI;IAcvB,cAAc,IAAI,IAAI;IAWtB,IAAI,YAAY,IAAI,OAAO,CAE1B;IAKD,KAAK,IAAI,IAAI;IASb,aAAa,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;CAOrE;AAKD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,CAyBjI;AAOD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,YAAY,GAAG,IAAI,CAqB/E;AAKD,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAKD,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/cli/tui/scroll-buffer.js

@@ -0,0 +1,162 @@
+import { EventEmitter } from 'node:events';
+export class ScrollBuffer extends EventEmitter {
+    lines = [];
+    scrollOffset = 0;
+    maxLines;
+    viewportHeight;
+    isScrollMode = false;
+    originalWrite = null;
+    pendingOutput = '';
+    constructor(options = {}) {
+        super();
+        this.maxLines = options.maxLines || 10000;
+        this.viewportHeight = options.viewportHeight || (process.stdout.rows || 24) - 2;
+    }
+    write(content) {
+        const parts = (this.pendingOutput + content).split('\n');
+        this.pendingOutput = parts.pop() || '';
+        for (const part of parts) {
+            this.lines.push(part);
+        }
+        if (this.lines.length > this.maxLines) {
+            this.lines = this.lines.slice(-this.maxLines);
+        }
+        if (this.scrollOffset === 0 && !this.isScrollMode) {
+            this.emit('output', content);
+        }
+    }
+    flush() {
+        if (this.pendingOutput) {
+            this.lines.push(this.pendingOutput);
+            this.pendingOutput = '';
+        }
+    }
+    get lineCount() {
+        return this.lines.length;
+    }
+    get position() {
+        return this.scrollOffset;
+    }
+    get isScrolledUp() {
+        return this.scrollOffset > 0;
+    }
+    scrollUp(lines = 1) {
+        const maxScroll = Math.max(0, this.lines.length - this.viewportHeight);
+        const newOffset = Math.min(this.scrollOffset + lines, maxScroll);
+        if (newOffset !== this.scrollOffset) {
+            this.scrollOffset = newOffset;
+            return true;
+        }
+        return false;
+    }
+    scrollDown(lines = 1) {
+        const newOffset = Math.max(0, this.scrollOffset - lines);
+        if (newOffset !== this.scrollOffset) {
+            this.scrollOffset = newOffset;
+            return true;
+        }
+        return false;
+    }
+    pageUp() {
+        return this.scrollUp(this.viewportHeight - 1);
+    }
+    pageDown() {
+        return this.scrollDown(this.viewportHeight - 1);
+    }
+    scrollToTop() {
+        this.scrollOffset = Math.max(0, this.lines.length - this.viewportHeight);
+    }
+    scrollToBottom() {
+        this.scrollOffset = 0;
+    }
+    getVisibleLines() {
+        const endIndex = this.lines.length - this.scrollOffset;
+        const startIndex = Math.max(0, endIndex - this.viewportHeight);
+        return this.lines.slice(startIndex, endIndex);
+    }
+    render() {
+        const visibleLines = this.getVisibleLines();
+        let output = '';
+        output += '\x1b[2J\x1b[H';
+        output += visibleLines.join('\n');
+        if (this.scrollOffset > 0) {
+            const indicator = `\x1b[7m ↑ ${this.scrollOffset} lines above | Page Down to scroll ↓ \x1b[0m`;
+            output += `\n${indicator}`;
+        }
+        return output;
+    }
+    updateViewport(height) {
+        this.viewportHeight = height || (process.stdout.rows || 24) - 2;
+    }
+    enterScrollMode() {
+        if (this.isScrollMode)
+            return;
+        this.isScrollMode = true;
+        this.flush();
+        this.emit('scrollModeStart');
+    }
+    exitScrollMode() {
+        if (!this.isScrollMode)
+            return;
+        this.isScrollMode = false;
+        this.scrollToBottom();
+        this.emit('scrollModeEnd');
+    }
+    get inScrollMode() {
+        return this.isScrollMode;
+    }
+    clear() {
+        this.lines = [];
+        this.scrollOffset = 0;
+        this.pendingOutput = '';
+    }
+    getScrollInfo() {
+        const total = this.lines.length;
+        const current = total - this.scrollOffset;
+        const percent = total > 0 ? Math.round((current / total) * 100) : 100;
+        return { current, total, percent };
+    }
+}
+export function parseScrollKey(data) {
+    const str = data.toString();
+    if (str === '\x1b[5~' || str === '\x1bOy')
+        return 'pageUp';
+    if (str === '\x1b[6~' || str === '\x1bOs')
+        return 'pageDown';
+    if (str === '\x1b[1;2A')
+        return 'scrollUp';
+    if (str === '\x1b[1;2B')
+        return 'scrollDown';
+    if (str === '\x1b[H' || str === '\x1b[1~' || str === '\x1bOH')
+        return 'home';
+    if (str === '\x1b[F' || str === '\x1b[4~' || str === '\x1bOF')
+        return 'end';
+    if (str === '\x1b' || str === '\x1b\x1b')
+        return 'escape';
+    return null;
+}
+export function parseMouseScroll(data) {
+    const str = data.toString();
+    const sgrMatch = str.match(/\x1b\[<(\d+);(\d+);(\d+)[Mm]/);
+    if (sgrMatch) {
+        const button = parseInt(sgrMatch[1], 10);
+        if (button === 64)
+            return 'scrollUp';
+        if (button === 65)
+            return 'scrollDown';
+    }
+    if (data.length >= 6 && data[0] === 0x1b && data[1] === 0x5b && data[2] === 0x4d) {
+        const button = data[3];
+        if (button === 96 || button === 0x60)
+            return 'scrollUp';
+        if (button === 97 || button === 0x61)
+            return 'scrollDown';
+    }
+    return null;
+}
+export function enableMouseReporting() {
+    process.stdout.write('\x1b[?1000h\x1b[?1006h');
+}
+export function disableMouseReporting() {
+    process.stdout.write('\x1b[?1000l\x1b[?1006l');
+}

package/dist/cli/tui/search-panel.d.ts

@@ -0,0 +1,41 @@
+interface SearchPanelOptions {
+    initialQuery?: string;
+    docsPath?: string;
+}
+export declare class SearchPanel {
+    private rl;
+    private state;
+    private docsPath;
+    private running;
+    private termWidth;
+    private termHeight;
+    private leftPanelWidth;
+    private rightPanelWidth;
+    private contentHeight;
+    private previewContent;
+    constructor(options?: SearchPanelOptions);
+    private findDocsPath;
+    open(): Promise<void>;
+    close(): void;
+    private updateDimensions;
+    private handleKeyInput;
+    private navigateUp;
+    private navigateDown;
+    private scrollPreview;
+    private performSearch;
+    private loadPreview;
+    private formatMarkdown;
+    private wordWrap;
+    private stripAnsi;
+    private render;
+    private renderHeader;
+    private renderSearchInput;
+    private renderDivider;
+    private renderContent;
+    private renderLeftPanelLine;
+    private renderRightPanelLine;
+    private renderFooter;
+}
+export declare function openSearchPanel(query?: string): Promise<void>;
+export {};
+//# sourceMappingURL=search-panel.d.ts.map

package/dist/cli/tui/search-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-panel.d.ts","sourceRoot":"","sources":["../../../src/cli/tui/search-panel.ts"],"names":[],"mappings":"AAyCA,UAAU,kBAAkB;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAeD,qBAAa,WAAW;IACtB,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,cAAc,CAAgB;gBAE1B,OAAO,GAAE,kBAAuB;IAa5C,OAAO,CAAC,YAAY;IAed,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiD3B,KAAK,IAAI,IAAI;IAsBb,OAAO,CAAC,gBAAgB;YAYV,cAAc;IA8C5B,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,aAAa;YAKP,aAAa;IAgC3B,OAAO,CAAC,WAAW;IAyBnB,OAAO,CAAC,cAAc;IAyCtB,OAAO,CAAC,QAAQ;IAuBhB,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,MAAM;IA0Bd,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,iBAAiB;IAiBzB,OAAO,CAAC,aAAa;IAcrB,OAAO,CAAC,aAAa;IAoBrB,OAAO,CAAC,mBAAmB;IAiC3B,OAAO,CAAC,oBAAoB;IA8B5B,OAAO,CAAC,YAAY;CA0BrB;AAKD,wBAAsB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGnE"}

package/dist/cli/tui/search-panel.js

@@ -0,0 +1,419 @@
+import { createInterface } from 'readline';
+import { getShellSearch } from './shell-search.js';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import colors from '../../utils/colors.js';
+const ESC = '\x1b';
+const CLEAR_SCREEN = `${ESC}[2J`;
+const CURSOR_HOME = `${ESC}[H`;
+const CURSOR_HIDE = `${ESC}[?25l`;
+const CURSOR_SHOW = `${ESC}[?25h`;
+const CLEAR_LINE = `${ESC}[2K`;
+const BOX = {
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+    horizontal: '─',
+    vertical: '│',
+    verticalRight: '├',
+    verticalLeft: '┤',
+    horizontalDown: '┬',
+    horizontalUp: '┴',
+    cross: '┼',
+};
+export class SearchPanel {
+    rl = null;
+    state;
+    docsPath;
+    running = false;
+    termWidth = 80;
+    termHeight = 24;
+    leftPanelWidth = 0;
+    rightPanelWidth = 0;
+    contentHeight = 0;
+    previewContent = [];
+    constructor(options = {}) {
+        this.state = {
+            query: options.initialQuery || '',
+            results: [],
+            selectedIndex: 0,
+            scrollOffset: 0,
+            previewScrollOffset: 0,
+            isSearching: false,
+            error: null,
+        };
+        this.docsPath = options.docsPath || this.findDocsPath();
+    }
+    findDocsPath() {
+        const candidates = [
+            join(process.cwd(), 'docs'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../../docs'),
+            join(dirname(fileURLToPath(import.meta.url)), '../../../../docs'),
+        ];
+        for (const p of candidates) {
+            if (existsSync(p))
+                return p;
+        }
+        return candidates[0];
+    }
+    async open() {
+        this.running = true;
+        this.updateDimensions();
+        this.rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdout.on('resize', () => {
+            this.updateDimensions();
+            this.render();
+        });
+        process.stdin.on('data', this.handleKeyInput.bind(this));
+        if (this.state.query) {
+            await this.performSearch();
+        }
+        this.render();
+        return new Promise((resolve) => {
+            const checkInterval = setInterval(() => {
+                if (!this.running) {
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, 100);
+        });
+    }
+    close() {
+        this.running = false;
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        process.stdout.write(CURSOR_SHOW);
+        process.stdout.write(CLEAR_SCREEN);
+        process.stdout.write(CURSOR_HOME);
+        if (this.rl) {
+            this.rl.close();
+            this.rl = null;
+        }
+        process.stdin.removeAllListeners('data');
+        process.stdout.removeAllListeners('resize');
+    }
+    updateDimensions() {
+        this.termWidth = process.stdout.columns || 80;
+        this.termHeight = process.stdout.rows || 24;
+        this.leftPanelWidth = Math.max(30, Math.floor(this.termWidth * 0.4));
+        this.rightPanelWidth = this.termWidth - this.leftPanelWidth - 1;
+        this.contentHeight = this.termHeight - 6;
+    }
+    async handleKeyInput(data) {
+        const key = data.toString();
+        if (key === '\x1b' || key === '\x03') {
+            this.close();
+            return;
+        }
+        if (key === '\x1b[A') {
+            this.navigateUp();
+        }
+        else if (key === '\x1b[B') {
+            this.navigateDown();
+        }
+        else if (key === '\x1b[C') {
+            this.scrollPreview(5);
+        }
+        else if (key === '\x1b[D') {
+            this.scrollPreview(-5);
+        }
+        else if (key === '\x1b[5~') {
+            this.scrollPreview(-this.contentHeight);
+        }
+        else if (key === '\x1b[6~') {
+            this.scrollPreview(this.contentHeight);
+        }
+        else if (key === '\r' || key === '\n') {
+        }
+        else if (key === '\x7f' || key === '\b') {
+            if (this.state.query.length > 0) {
+                this.state.query = this.state.query.slice(0, -1);
+                await this.performSearch();
+            }
+        }
+        else if (key.length === 1 && key >= ' ') {
+            this.state.query += key;
+            await this.performSearch();
+        }
+        this.render();
+    }
+    navigateUp() {
+        if (this.state.selectedIndex > 0) {
+            this.state.selectedIndex--;
+            this.state.previewScrollOffset = 0;
+            if (this.state.selectedIndex < this.state.scrollOffset) {
+                this.state.scrollOffset = this.state.selectedIndex;
+            }
+            this.loadPreview();
+        }
+    }
+    navigateDown() {
+        if (this.state.selectedIndex < this.state.results.length - 1) {
+            this.state.selectedIndex++;
+            this.state.previewScrollOffset = 0;
+            const visibleItems = this.contentHeight - 2;
+            if (this.state.selectedIndex >= this.state.scrollOffset + visibleItems) {
+                this.state.scrollOffset = this.state.selectedIndex - visibleItems + 1;
+            }
+            this.loadPreview();
+        }
+    }
+    scrollPreview(delta) {
+        const maxScroll = Math.max(0, this.previewContent.length - this.contentHeight + 2);
+        this.state.previewScrollOffset = Math.max(0, Math.min(maxScroll, this.state.previewScrollOffset + delta));
+    }
+    async performSearch() {
+        if (!this.state.query.trim()) {
+            this.state.results = [];
+            this.state.selectedIndex = 0;
+            this.state.scrollOffset = 0;
+            this.previewContent = [];
+            return;
+        }
+        this.state.isSearching = true;
+        this.state.error = null;
+        try {
+            const search = getShellSearch();
+            this.state.results = await search.search(this.state.query, { limit: 20 });
+            this.state.selectedIndex = 0;
+            this.state.scrollOffset = 0;
+            this.state.previewScrollOffset = 0;
+            if (this.state.results.length > 0) {
+                this.loadPreview();
+            }
+            else {
+                this.previewContent = [];
+            }
+        }
+        catch (error) {
+            this.state.error = error.message;
+            this.state.results = [];
+        }
+        finally {
+            this.state.isSearching = false;
+        }
+    }
+    loadPreview() {
+        const result = this.state.results[this.state.selectedIndex];
+        if (!result) {
+            this.previewContent = [];
+            return;
+        }
+        const fullPath = join(this.docsPath, result.path);
+        if (existsSync(fullPath)) {
+            try {
+                const content = readFileSync(fullPath, 'utf-8');
+                this.previewContent = this.formatMarkdown(content);
+            }
+            catch {
+                this.previewContent = this.formatMarkdown(result.content || result.snippet || 'No preview available');
+            }
+        }
+        else if (result.content) {
+            this.previewContent = this.formatMarkdown(result.content);
+        }
+        else if (result.snippet) {
+            this.previewContent = this.formatMarkdown(result.snippet);
+        }
+        else {
+            this.previewContent = ['No preview available'];
+        }
+    }
+    formatMarkdown(text) {
+        const lines = [];
+        const width = this.rightPanelWidth - 4;
+        for (const rawLine of text.split('\n')) {
+            let line = rawLine;
+            if (line.startsWith('# ')) {
+                line = colors.bold(colors.cyan(line.substring(2)));
+            }
+            else if (line.startsWith('## ')) {
+                line = colors.bold(colors.blue(line.substring(3)));
+            }
+            else if (line.startsWith('### ')) {
+                line = colors.bold(colors.green(line.substring(4)));
+            }
+            else if (line.startsWith('#### ')) {
+                line = colors.bold(line.substring(5));
+            }
+            else if (line.startsWith('```')) {
+                line = colors.gray(line);
+            }
+            else if (line.includes('`')) {
+                line = line.replace(/`([^`]+)`/g, (_, code) => colors.cyan(code));
+            }
+            if (line.includes('**')) {
+                line = line.replace(/\*\*([^*]+)\*\*/g, (_, text) => colors.bold(text));
+            }
+            const wrapped = this.wordWrap(line, width);
+            lines.push(...wrapped);
+        }
+        return lines;
+    }
+    wordWrap(text, width) {
+        if (this.stripAnsi(text).length <= width) {
+            return [text];
+        }
+        const words = text.split(' ');
+        const lines = [];
+        let currentLine = '';
+        for (const word of words) {
+            const testLine = currentLine ? `${currentLine} ${word}` : word;
+            if (this.stripAnsi(testLine).length <= width) {
+                currentLine = testLine;
+            }
+            else {
+                if (currentLine)
+                    lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+        if (currentLine)
+            lines.push(currentLine);
+        return lines;
+    }
+    stripAnsi(text) {
+        return text.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+    render() {
+        const output = [];
+        output.push(CURSOR_HIDE);
+        output.push(CURSOR_HOME);
+        output.push(this.renderHeader());
+        output.push(this.renderSearchInput());
+        output.push(this.renderDivider());
+        output.push(...this.renderContent());
+        output.push(this.renderFooter());
+        process.stdout.write(output.join(''));
+    }
+    renderHeader() {
+        const title = ' Documentation Search ';
+        const padding = Math.max(0, Math.floor((this.termWidth - title.length) / 2));
+        const line = BOX.horizontal.repeat(this.termWidth);
+        return (colors.cyan(BOX.topLeft + line.slice(0, padding - 1)) +
+            colors.bold(colors.cyan(title)) +
+            colors.cyan(line.slice(padding + title.length - 1) + BOX.topRight) +
+            '\n');
+    }
+    renderSearchInput() {
+        const prefix = colors.cyan(BOX.vertical) + ' ' + colors.yellow('Search: ');
+        const query = this.state.query;
+        const cursor = colors.cyan('_');
+        const status = this.state.isSearching
+            ? colors.gray(' (searching...)')
+            : this.state.results.length > 0
+                ? colors.gray(` (${this.state.results.length} results)`)
+                : '';
+        const contentWidth = this.termWidth - 4;
+        const inputLine = query + cursor + status;
+        const padding = Math.max(0, contentWidth - this.stripAnsi(inputLine).length);
+        return prefix + inputLine + ' '.repeat(padding) + colors.cyan(BOX.vertical) + '\n';
+    }
+    renderDivider() {
+        const leftPart = BOX.horizontal.repeat(this.leftPanelWidth - 1);
+        const rightPart = BOX.horizontal.repeat(this.rightPanelWidth);
+        return (colors.cyan(BOX.verticalRight) +
+            colors.cyan(leftPart) +
+            colors.cyan(BOX.horizontalDown) +
+            colors.cyan(rightPart) +
+            colors.cyan(BOX.verticalLeft) +
+            '\n');
+    }
+    renderContent() {
+        const lines = [];
+        for (let i = 0; i < this.contentHeight; i++) {
+            const leftContent = this.renderLeftPanelLine(i);
+            const rightContent = this.renderRightPanelLine(i);
+            lines.push(colors.cyan(BOX.vertical) +
+                leftContent +
+                colors.cyan(BOX.vertical) +
+                rightContent +
+                colors.cyan(BOX.vertical) +
+                '\n');
+        }
+        return lines;
+    }
+    renderLeftPanelLine(lineIndex) {
+        const width = this.leftPanelWidth - 2;
+        const resultIndex = this.state.scrollOffset + lineIndex;
+        if (resultIndex >= this.state.results.length) {
+            return ' '.repeat(width);
+        }
+        const result = this.state.results[resultIndex];
+        const isSelected = resultIndex === this.state.selectedIndex;
+        const score = Math.round(result.score * 100);
+        const indexStr = ` ${resultIndex + 1}. `;
+        const scoreStr = ` (${score}%)`;
+        const maxTitleLen = width - indexStr.length - scoreStr.length - 1;
+        let title = result.title;
+        if (title.length > maxTitleLen) {
+            title = title.slice(0, maxTitleLen - 1) + '…';
+        }
+        let line = indexStr + title + scoreStr;
+        const padding = width - this.stripAnsi(line).length;
+        line += ' '.repeat(Math.max(0, padding));
+        if (isSelected) {
+            return colors.bgBlue(colors.white(colors.bold(line)));
+        }
+        return colors.white(indexStr) + colors.white(title) + colors.gray(scoreStr) + ' '.repeat(Math.max(0, padding));
+    }
+    renderRightPanelLine(lineIndex) {
+        const width = this.rightPanelWidth - 1;
+        const contentIndex = this.state.previewScrollOffset + lineIndex;
+        if (this.state.results.length === 0) {
+            if (lineIndex === Math.floor(this.contentHeight / 2) - 1) {
+                const msg = this.state.query ? 'No results found' : 'Type to search documentation';
+                const padding = Math.floor((width - msg.length) / 2);
+                return ' '.repeat(padding) + colors.gray(msg) + ' '.repeat(width - padding - msg.length);
+            }
+            return ' '.repeat(width);
+        }
+        if (contentIndex >= this.previewContent.length) {
+            return ' '.repeat(width);
+        }
+        let line = ' ' + this.previewContent[contentIndex];
+        const visibleLen = this.stripAnsi(line).length;
+        if (visibleLen > width) {
+            line = line.slice(0, width - 1) + '…';
+        }
+        else {
+            line += ' '.repeat(width - visibleLen);
+        }
+        return line;
+    }
+    renderFooter() {
+        const bottomLine = BOX.horizontal.repeat(this.termWidth - 2);
+        const helpText = ' ↑↓ Navigate  ←→ Scroll preview  ESC Close ';
+        const pathText = this.state.results[this.state.selectedIndex]
+            ? ` ${this.state.results[this.state.selectedIndex].path} `
+            : '';
+        const footerLine = colors.cyan(BOX.bottomLeft) +
+            colors.cyan(bottomLine) +
+            colors.cyan(BOX.bottomRight) +
+            '\n' +
+            colors.gray(helpText) +
+            ' '.repeat(Math.max(0, this.termWidth - helpText.length - pathText.length)) +
+            colors.cyan(pathText);
+        return (colors.cyan(BOX.verticalRight) +
+            colors.cyan(BOX.horizontal.repeat(this.leftPanelWidth - 1)) +
+            colors.cyan(BOX.horizontalUp) +
+            colors.cyan(BOX.horizontal.repeat(this.rightPanelWidth)) +
+            colors.cyan(BOX.verticalLeft) +
+            '\n' +
+            footerLine);
+    }
+}
+export async function openSearchPanel(query) {
+    const panel = new SearchPanel({ initialQuery: query });
+    await panel.open();
+}