diffstalker 0.1.7 → 0.2.0

package/dist/utils/ansiToBlessed.js

@@ -0,0 +1,125 @@
+/**
+ * Convert ANSI escape codes to blessed tags.
+ * Supports basic foreground colors and styles.
+ */
+// ANSI color code to blessed color name mapping
+const ANSI_FG_COLORS = {
+    30: 'black',
+    31: 'red',
+    32: 'green',
+    33: 'yellow',
+    34: 'blue',
+    35: 'magenta',
+    36: 'cyan',
+    37: 'white',
+    90: 'gray',
+    91: 'red',
+    92: 'green',
+    93: 'yellow',
+    94: 'blue',
+    95: 'magenta',
+    96: 'cyan',
+    97: 'white',
+};
+/**
+ * Escape blessed tags in plain text.
+ */
+function escapeBlessed(text) {
+    return text.replace(/\{/g, '{{').replace(/\}/g, '}}');
+}
+/**
+ * Convert ANSI escape sequences to blessed tags.
+ *
+ * @param input - String containing ANSI escape codes
+ * @returns String with blessed tags
+ */
+export function ansiToBlessed(input) {
+    if (!input)
+        return '';
+    // Track current styles
+    const activeStyles = [];
+    let result = '';
+    let i = 0;
+    while (i < input.length) {
+        // Check for ANSI escape sequence
+        if (input[i] === '\x1b' && input[i + 1] === '[') {
+            // Find the end of the sequence (look for 'm')
+            let j = i + 2;
+            while (j < input.length && input[j] !== 'm') {
+                j++;
+            }
+            if (input[j] === 'm') {
+                // Parse the codes
+                const codes = input
+                    .slice(i + 2, j)
+                    .split(';')
+                    .map(Number);
+                for (const code of codes) {
+                    if (code === 0) {
+                        // Reset - close all active styles
+                        while (activeStyles.length > 0) {
+                            const style = activeStyles.pop();
+                            if (style) {
+                                result += `{/${style}}`;
+                            }
+                        }
+                    }
+                    else if (code === 1) {
+                        // Bold
+                        activeStyles.push('bold');
+                        result += '{bold}';
+                    }
+                    else if (code === 2) {
+                        // Dim/faint - blessed doesn't have direct support, use gray
+                        activeStyles.push('gray-fg');
+                        result += '{gray-fg}';
+                    }
+                    else if (code === 3) {
+                        // Italic - not well supported in terminals, skip
+                    }
+                    else if (code === 4) {
+                        // Underline
+                        activeStyles.push('underline');
+                        result += '{underline}';
+                    }
+                    else if (code >= 30 && code <= 37) {
+                        // Standard foreground colors
+                        const color = ANSI_FG_COLORS[code];
+                        if (color) {
+                            activeStyles.push(`${color}-fg`);
+                            result += `{${color}-fg}`;
+                        }
+                    }
+                    else if (code >= 90 && code <= 97) {
+                        // Bright foreground colors
+                        const color = ANSI_FG_COLORS[code];
+                        if (color) {
+                            activeStyles.push(`${color}-fg`);
+                            result += `{${color}-fg}`;
+                        }
+                    }
+                    // Note: We ignore background colors (40-47, 100-107) for simplicity
+                }
+                i = j + 1;
+                continue;
+            }
+        }
+        // Regular character - escape if needed and append
+        const char = input[i];
+        if (char === '{' || char === '}') {
+            result += char + char;
+        }
+        else {
+            result += char;
+        }
+        i++;
+    }
+    // Close any remaining active styles
+    while (activeStyles.length > 0) {
+        const style = activeStyles.pop();
+        if (style) {
+            result += `{/${style}}`;
+        }
+    }
+    return result;
+}

package/dist/utils/displayRows.js

@@ -3,18 +3,26 @@
 import { formatDateAbsolute } from './formatDate.js';
 import { isDisplayableDiffLine } from './diffFilters.js';
 import { breakLine, getLineRowCount } from './lineBreaking.js';
+import { computeWordDiff, areSimilarEnough } from './wordDiff.js';
+import { getLanguageFromPath, highlightBlockPreserveBg, } from './languageDetection.js';
 /**
- * Get the text content from a diff line (strip leading +/-/space)
+ * Get the text content from a diff line (strip leading +/-/space and control chars)
  */
 function getLineContent(line) {
+    let content;
     if (line.type === 'addition' || line.type === 'deletion') {
-        return line.content.slice(1);
+        content = line.content.slice(1);
     }
-    if (line.type === 'context') {
+    else if (line.type === 'context') {
         // Context lines start with space
-        return line.content.startsWith(' ') ? line.content.slice(1) : line.content;
+        content = line.content.startsWith(' ') ? line.content.slice(1) : line.content;
     }
-    return line.content;
+    else {
+        content = line.content;
+    }
+    // Strip control characters that cause rendering artifacts
+    // and convert tabs to spaces for consistent width calculation
+    return content.replace(/[\x00-\x08\x0a-\x1f\x7f]/g, '').replace(/\t/g, '    ');
 }
 /**
  * Convert a DiffLine to a DisplayRow
@@ -45,14 +53,185 @@ function convertDiffLineToDisplayRow(line) {
             };
     }
 }
+/**
+ * Extract file path from a diff --git header line.
+ */
+function extractFilePathFromHeader(content) {
+    const match = content.match(/^diff --git a\/.+ b\/(.+)$/);
+    return match ? match[1] : null;
+}
 /**
  * Build display rows from a DiffResult.
  * Filters out non-displayable lines (index, ---, +++ headers).
+ * Pairs consecutive deletions/additions within hunks and computes word-level diffs.
+ * Applies block-based syntax highlighting to properly handle multi-line constructs.
  */
 export function buildDiffDisplayRows(diff) {
     if (!diff)
         return [];
-    return diff.lines.filter(isDisplayableDiffLine).map(convertDiffLineToDisplayRow);
+    const filteredLines = diff.lines.filter(isDisplayableDiffLine);
+    const rows = [];
+    const fileSections = [];
+    let currentSection = null;
+    // Phase 1: Build display rows WITHOUT highlighting
+    // Also collect content for block highlighting
+    let i = 0;
+    while (i < filteredLines.length) {
+        const line = filteredLines[i];
+        // Headers - start new file section
+        if (line.type === 'header') {
+            const filePath = extractFilePathFromHeader(line.content);
+            if (filePath) {
+                // Save previous section if any
+                if (currentSection) {
+                    fileSections.push(currentSection);
+                    // Add spacer between files for visual separation
+                    rows.push({ type: 'spacer' });
+                }
+                // Start new section
+                currentSection = {
+                    language: getLanguageFromPath(filePath),
+                    startRowIndex: rows.length,
+                    oldContent: [],
+                    oldRowIndices: [],
+                    newContent: [],
+                    newRowIndices: [],
+                };
+            }
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Hunks - just convert (don't highlight)
+        if (line.type === 'hunk') {
+            rows.push(convertDiffLineToDisplayRow(line));
+            i++;
+            continue;
+        }
+        // Context lines - add to both streams
+        if (line.type === 'context') {
+            const content = getLineContent(line);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-context',
+                lineNum: line.oldLineNum ?? line.newLineNum,
+                content,
+            });
+            // Context appears in both old and new streams
+            if (currentSection && currentSection.language) {
+                currentSection.oldContent.push(content);
+                currentSection.oldRowIndices.push(rowIndex);
+                currentSection.newContent.push(content);
+                currentSection.newRowIndices.push(rowIndex);
+            }
+            i++;
+            continue;
+        }
+        // Collect consecutive deletions
+        const deletions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'deletion') {
+            deletions.push(filteredLines[i]);
+            i++;
+        }
+        // Collect consecutive additions (immediately following deletions)
+        const additions = [];
+        while (i < filteredLines.length && filteredLines[i].type === 'addition') {
+            additions.push(filteredLines[i]);
+            i++;
+        }
+        // Build arrays to store word diff segments for paired lines
+        const delSegmentsMap = new Map();
+        const addSegmentsMap = new Map();
+        // Pair deletions with additions for word-level diff (only if similar enough)
+        const pairCount = Math.min(deletions.length, additions.length);
+        for (let j = 0; j < pairCount; j++) {
+            const delContent = getLineContent(deletions[j]);
+            const addContent = getLineContent(additions[j]);
+            // Only compute word diff if lines are similar enough
+            if (areSimilarEnough(delContent, addContent)) {
+                const { oldSegments, newSegments } = computeWordDiff(delContent, addContent);
+                delSegmentsMap.set(j, oldSegments);
+                addSegmentsMap.set(j, newSegments);
+            }
+        }
+        // Output deletions first (preserving original diff order)
+        for (let j = 0; j < deletions.length; j++) {
+            const delLine = deletions[j];
+            const delContent = getLineContent(delLine);
+            const segments = delSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-del',
+                lineNum: delLine.oldLineNum,
+                content: delContent,
+                ...(segments && { wordDiffSegments: segments }),
+            });
+            // Add to old stream (only if no word-diff, as word-diff takes priority)
+            if (currentSection && currentSection.language && !segments) {
+                currentSection.oldContent.push(delContent);
+                currentSection.oldRowIndices.push(rowIndex);
+            }
+        }
+        // Then output additions
+        for (let j = 0; j < additions.length; j++) {
+            const addLine = additions[j];
+            const addContent = getLineContent(addLine);
+            const segments = addSegmentsMap.get(j);
+            const rowIndex = rows.length;
+            rows.push({
+                type: 'diff-add',
+                lineNum: addLine.newLineNum,
+                content: addContent,
+                ...(segments && { wordDiffSegments: segments }),
+            });
+            // Add to new stream (only if no word-diff, as word-diff takes priority)
+            if (currentSection && currentSection.language && !segments) {
+                currentSection.newContent.push(addContent);
+                currentSection.newRowIndices.push(rowIndex);
+            }
+        }
+    }
+    // Save final section
+    if (currentSection) {
+        fileSections.push(currentSection);
+    }
+    // Phase 2: Apply block highlighting for each file section
+    for (const section of fileSections) {
+        if (!section.language)
+            continue;
+        // Highlight old stream (context + deletions)
+        if (section.oldContent.length > 0) {
+            const oldHighlighted = highlightBlockPreserveBg(section.oldContent, section.language);
+            for (let j = 0; j < section.oldRowIndices.length; j++) {
+                const rowIndex = section.oldRowIndices[j];
+                const row = rows[rowIndex];
+                const highlighted = oldHighlighted[j];
+                // Only set highlighted if it's different from content
+                if (highlighted &&
+                    highlighted !== row.content &&
+                    (row.type === 'diff-del' || row.type === 'diff-context')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+        // Highlight new stream (context + additions)
+        if (section.newContent.length > 0) {
+            const newHighlighted = highlightBlockPreserveBg(section.newContent, section.language);
+            for (let j = 0; j < section.newRowIndices.length; j++) {
+                const rowIndex = section.newRowIndices[j];
+                const row = rows[rowIndex];
+                const highlighted = newHighlighted[j];
+                // Only set highlighted if it's different from content
+                // Note: context lines appear in both streams, but result should be same
+                if (highlighted &&
+                    highlighted !== row.content &&
+                    (row.type === 'diff-add' || row.type === 'diff-context')) {
+                    row.highlighted = highlighted;
+                }
+            }
+        }
+    }
+    return rows;
 }
 /**
  * Build display rows from commit + diff (for History tab).

package/dist/utils/explorerDisplayRows.js

@@ -17,8 +17,8 @@ import { getLanguageFromPath, highlightLine } from './languageDetection.js';
 export function buildExplorerContentRows(content, filePath, truncated) {
     if (!content)
         return [];
-    const rows = [];
     const lines = content.split('\n');
+    const rows = [];
     // Detect language for highlighting
     const language = filePath ? getLanguageFromPath(filePath) : null;
     for (let i = 0; i < lines.length; i++) {

package/dist/utils/languageDetection.js

@@ -155,6 +155,7 @@ export function getLanguageFromPath(filePath) {
  * Apply syntax highlighting to a line of code.
  * Returns the highlighted string with ANSI escape codes.
  * If highlighting fails, returns the original content.
+ * Skips highlighting for lines that look like comments (heuristic for multi-line context).
  */
 export function highlightLine(content, language) {
     if (!content || !language)
@@ -168,6 +169,61 @@ export function highlightLine(content, language) {
         return content;
     }
 }
+/**
+ * Apply syntax highlighting preserving background color.
+ * Replaces full ANSI resets with foreground-only resets so that
+ * the caller's background color is not cleared.
+ * Returns the highlighted string, or original content if highlighting fails.
+ */
+export function highlightLinePreserveBg(content, language) {
+    if (!content || !language)
+        return content;
+    try {
+        const result = emphasize.highlight(language, content);
+        // Replace full reset (\x1b[0m) with foreground-only reset (\x1b[39m)
+        // This preserves any background color set by the caller
+        return result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+    }
+    catch {
+        return content;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving multi-line context
+ * (e.g., block comments, multi-line strings).
+ * Returns an array of highlighted lines.
+ */
+export function highlightBlock(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        // Join lines and highlight as one block to preserve state
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        return result.value.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
+/**
+ * Highlight multiple lines as a block, preserving background color.
+ * Returns an array of highlighted lines with foreground-only resets.
+ */
+export function highlightBlockPreserveBg(lines, language) {
+    if (!language || lines.length === 0)
+        return lines;
+    try {
+        const block = lines.join('\n');
+        const result = emphasize.highlight(language, block);
+        // Replace full resets with foreground-only resets
+        const highlighted = result.value.replace(/\x1b\[0m/g, '\x1b[39m');
+        return highlighted.split('\n');
+    }
+    catch {
+        return lines;
+    }
+}
 /**
  * Apply syntax highlighting to multiple lines.
  * More efficient than calling highlightLine for each line

package/dist/utils/pathUtils.js

@@ -0,0 +1,27 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+/**
+ * Expand tilde (~) to home directory.
+ */
+export function expandPath(p) {
+    if (p.startsWith('~/')) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    if (p === '~') {
+        return os.homedir();
+    }
+    return p;
+}
+/**
+ * Get the last non-empty line from content.
+ * Supports append-only files by reading only the last non-empty line.
+ */
+export function getLastNonEmptyLine(content) {
+    const lines = content.split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i].trim();
+        if (line)
+            return line;
+    }
+    return '';
+}

package/dist/utils/rowCalculations.js

@@ -207,3 +207,40 @@ export function getCompareItemIndexFromRow(row, commitCount, fileCount, commitsE
     }
     return -1; // Out of bounds
 }
+/**
+ * Map an item index to its row position in CompareListView.
+ * This is the inverse of getCompareItemIndexFromRow.
+ *
+ * For itemIndex in 0..(commitCount-1): row = 1 + itemIndex
+ * For itemIndex in commitCount..(commitCount+fileCount-1): row = 1 + commitCount + 1 + 1 + (itemIndex - commitCount)
+ */
+export function getCompareRowFromItemIndex(itemIndex, commitCount, fileCount, commitsExpanded = true, filesExpanded = true) {
+    if (itemIndex < 0)
+        return 0;
+    // Handle commit items
+    if (itemIndex < commitCount) {
+        // Row 0 is commits header, so commit i is at row 1 + i
+        return commitsExpanded ? 1 + itemIndex : 0;
+    }
+    // Handle file items
+    const fileIndex = itemIndex - commitCount;
+    if (fileIndex >= fileCount)
+        return 0;
+    // Calculate row for file:
+    // - commits header (1 row if commits exist)
+    // - commits (commitCount rows if expanded)
+    // - spacer (1 row if commits exist)
+    // - files header (1 row)
+    // - file items
+    let row = 0;
+    if (commitCount > 0) {
+        row += 1; // commits header
+        if (commitsExpanded)
+            row += commitCount;
+        row += 1; // spacer
+    }
+    row += 1; // files header
+    if (filesExpanded)
+        row += fileIndex;
+    return row;
+}

package/dist/utils/wordDiff.js

@@ -0,0 +1,50 @@
+// Word-level diff utility using fast-diff
+import fastDiff from 'fast-diff';
+/**
+ * Check if two lines are similar enough to warrant word-level diffing.
+ * Returns true if they share at least 30% common content.
+ */
+export function areSimilarEnough(oldText, newText) {
+    if (!oldText || !newText)
+        return false;
+    const diffs = fastDiff(oldText, newText);
+    let commonLength = 0;
+    let totalLength = 0;
+    for (const [type, text] of diffs) {
+        totalLength += text.length;
+        if (type === fastDiff.EQUAL) {
+            commonLength += text.length;
+        }
+    }
+    if (totalLength === 0)
+        return false;
+    // Require at least 50% similarity for word-level highlighting to be useful
+    const similarity = commonLength / totalLength;
+    return similarity >= 0.5;
+}
+/**
+ * Compute word-level diff between two strings.
+ * Returns segments for both the old (deleted) and new (added) lines,
+ * marking which portions changed.
+ */
+export function computeWordDiff(oldText, newText) {
+    const diffs = fastDiff(oldText, newText);
+    const oldSegments = [];
+    const newSegments = [];
+    for (const [type, text] of diffs) {
+        if (type === fastDiff.EQUAL) {
+            // Same in both - add to both segment lists
+            oldSegments.push({ text, type: 'same' });
+            newSegments.push({ text, type: 'same' });
+        }
+        else if (type === fastDiff.DELETE) {
+            // Deleted from old - only in old segments
+            oldSegments.push({ text, type: 'changed' });
+        }
+        else if (type === fastDiff.INSERT) {
+            // Inserted in new - only in new segments
+            newSegments.push({ text, type: 'changed' });
+        }
+    }
+    return { oldSegments, newSegments };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffstalker",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Terminal application that displays git diff/status for directories",
   "author": "yogh-io",
   "license": "MIT",
@@ -18,14 +18,15 @@
     "diffstalker": "bin/diffstalker"
   },
   "scripts": {
-    "dev": "bun --watch src/index.tsx",
+    "postinstall": "node scripts/patch-neo-blessed.cjs",
+    "dev": "bun --watch src/index.ts",
     "build": "tsc",
     "build:prod": "tsc && bun build dist/index.js --outfile dist/index.js --minify --target node --packages external",
-    "bundle": "bun run build:prod && bun build dist/index.js --outdir dist/bundle --minify --target node --external react-devtools-core",
+    "bundle": "bun run build:prod && bun build dist/index.js --outdir dist/bundle --minify --target node --external neo-blessed",
     "start": "bun dist/index.js",
     "start:bundle": "bun dist/bundle/index.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
+    "test": "bun test src/*.test.ts src/**/*.test.ts",
+    "test:watch": "bun test --watch src/*.test.ts src/**/*.test.ts",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
     "format": "prettier --write src/",
@@ -46,22 +47,20 @@
     "chokidar": "^4.0.3",
     "emphasize": "^7.0.0",
     "fast-diff": "^1.3.0",
-    "ink": "^6.6.0",
-    "ink-text-input": "^6.0.0",
-    "react": "^19.2.0",
+    "ignore": "^7.0.5",
+    "neo-blessed": "^0.2.0",
     "simple-git": "^3.27.0",
     "string-width": "^8.1.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
+    "@types/blessed": "^0.1.27",
     "@types/node": "^22.10.7",
-    "@types/react": "^19.2.0",
     "eslint": "^9.39.2",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-react-hooks": "^7.0.1",
+    "patch-package": "^8.0.1",
     "prettier": "^3.8.0",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.53.1",
-    "vitest": "^2.1.0"
+    "typescript-eslint": "^8.53.1"
   }
 }

package/dist/components/BaseBranchPicker.js

@@ -1,60 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState, useMemo } from 'react';
-import { Box, Text, useInput } from 'ink';
-import { Modal, centerModal } from './Modal.js';
-export function BaseBranchPicker({ candidates, currentBranch, onSelect, onCancel, width, height, }) {
-    const [inputValue, setInputValue] = useState('');
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    // Filter candidates based on input
-    const filteredCandidates = useMemo(() => {
-        if (!inputValue)
-            return candidates;
-        const lower = inputValue.toLowerCase();
-        return candidates.filter((c) => c.toLowerCase().includes(lower));
-    }, [candidates, inputValue]);
-    // Clamp selected index to valid range
-    const clampedIndex = Math.min(selectedIndex, Math.max(0, filteredCandidates.length - 1));
-    useInput((input, key) => {
-        if (key.escape) {
-            onCancel();
-        }
-        else if (key.return) {
-            // If input matches no candidates but has value, use the input as custom branch
-            if (filteredCandidates.length === 0 && inputValue) {
-                onSelect(inputValue);
-            }
-            else if (filteredCandidates.length > 0) {
-                onSelect(filteredCandidates[clampedIndex]);
-            }
-        }
-        else if (key.upArrow) {
-            setSelectedIndex((prev) => Math.max(0, prev - 1));
-        }
-        else if (key.downArrow) {
-            setSelectedIndex((prev) => Math.min(filteredCandidates.length - 1, prev + 1));
-        }
-        else if (key.backspace || key.delete) {
-            setInputValue((prev) => prev.slice(0, -1));
-            setSelectedIndex(0);
-        }
-        else if (input && !key.ctrl && !key.meta) {
-            setInputValue((prev) => prev + input);
-            setSelectedIndex(0);
-        }
-    });
-    // Calculate box dimensions
-    const boxWidth = Math.min(60, width - 4);
-    const maxListHeight = Math.min(10, height - 10);
-    const boxHeight = Math.min(maxListHeight + 9, height - 4); // +9 for header, input, footer, borders
-    // Center the modal
-    const { x, y } = centerModal(boxWidth, boxHeight, width, height);
-    // Visible candidates (with scroll)
-    const scrollOffset = Math.max(0, clampedIndex - maxListHeight + 1);
-    const visibleCandidates = filteredCandidates.slice(scrollOffset, scrollOffset + maxListHeight);
-    return (_jsx(Modal, { x: x, y: y, width: boxWidth, height: boxHeight, children: _jsxs(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", width: boxWidth, children: [_jsx(Box, { justifyContent: "center", marginBottom: 1, children: _jsxs(Text, { bold: true, color: "cyan", children: [' ', "Select Base Branch", ' '] }) }), _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Filter: " }), _jsx(Text, { color: "cyan", children: inputValue }), _jsx(Text, { color: "cyan", children: "\u258C" })] }), _jsx(Box, { flexDirection: "column", height: maxListHeight, children: visibleCandidates.length > 0 ? (visibleCandidates.map((branch, index) => {
-                        const actualIndex = scrollOffset + index;
-                        const isSelected = actualIndex === clampedIndex;
-                        const isCurrent = branch === currentBranch;
-                        return (_jsxs(Box, { children: [_jsx(Text, { color: isSelected ? 'cyan' : undefined, children: isSelected ? '▸ ' : '  ' }), _jsx(Text, { bold: isSelected, color: isSelected ? 'cyan' : undefined, children: branch }), isCurrent && _jsx(Text, { dimColor: true, children: " (current)" })] }, branch));
-                    })) : inputValue ? (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " No matches. Press Enter to use: " }), _jsx(Text, { color: "yellow", children: inputValue })] })) : (_jsx(Text, { dimColor: true, children: " No candidates found" })) }), filteredCandidates.length > maxListHeight && (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: [scrollOffset > 0 ? '↑ ' : '  ', scrollOffset + maxListHeight < filteredCandidates.length ? '↓ more' : ''] }) })), _jsx(Box, { marginTop: 1, justifyContent: "center", children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u2022 Enter select \u2022 Esc cancel" }) })] }) }));
-}