minovative-mind-cli 2.13.5 → 2.14.1

package/dist/utils/historyPrompt.js

@@ -1,5 +1,10 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { TextPrompt } from '@clack/core';
 import pc from 'picocolors';
+import { distance } from 'fastest-levenshtein';
+import { workspaceRegistry } from '../services/workspaceRegistry.js';
+import { extractSymbolIndex } from './symbolExtractor.js';
 /**
  * Approximate token count for a given text string using character and word heuristics.
  * Defaults to a safe ratio of ~3.8 characters per token for multi-language code and text.
@@ -46,6 +51,8 @@ export function calculateDynamicTokenBudget(config) {
  * @param text The text to prune.
  * @param maxTokens Maximum allowable tokens for this text.
  * @param options Pruning options.
+ * @param options.truncationMarker Marker to append/prepend indicating truncation.
+ * @param options.fromStart If true, prunes from the start.
  * @returns Pruned string, with an optional truncation marker.
  */
 export function pruneTextToTokenBudget(text, maxTokens, options) {
@@ -97,11 +104,14 @@ export function optimizeHistoryForContext(history, maxEntries = 100) {
  * pruning older turns if the total estimated tokens exceed the allocated budget.
  *
  * @param history Array of conversation turns with role and text content.
- * @param maxTokens Maximum allowable tokens for the formatted history.
+ * @param maxTokens Maximum allowable tokens for the formatted history. Defaults to 16_384.
  * @param options Formatting options.
+ * @param options.keepRecentTurns Minimum number of recent turns to always keep regardless of budget if possible. Defaults to 2.
+ * @param options.userLabel Custom label prefix for user turns. Defaults to "User".
+ * @param options.modelLabel Custom label prefix for assistant/model turns. Defaults to "Assistant".
  * @returns Formatted and budget-constrained conversation history string.
  */
-export function formatHistoryWithTokenBudget(history, maxTokens = 16384, options) {
+export function formatHistoryWithTokenBudget(history, maxTokens = 16_384, options) {
     if (!history || history.length === 0 || maxTokens <= 0)
         return '';
     const keepRecent = options?.keepRecentTurns ?? 2;
@@ -169,6 +179,552 @@ const S_STEP_ACTIVE = '◆';
 const S_STEP_CANCEL = '■';
 const S_STEP_ERROR = '▲';
 const S_STEP_SUBMIT = '◇';
+const IGNORED_SCAN_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    'coverage',
+    '.turbo',
+    '.cache',
+    'out',
+    '.vscode',
+    '.idea',
+]);
+const EXCLUDED_SCAN_EXTENSIONS = new Set([
+    '.png',
+    '.jpg',
+    '.jpeg',
+    '.gif',
+    '.svg',
+    '.ico',
+    '.pdf',
+    '.zip',
+    '.tar',
+    '.gz',
+    '.lock',
+    '.pyc',
+    '.exe',
+    '.dylib',
+    '.so',
+    '.wasm',
+    '.ttf',
+    '.woff',
+    '.woff2',
+    '.eot',
+    '.mp4',
+    '.mp3',
+    '.wav',
+]);
+/**
+ * Extracts an active mention trigger token (such as `@query`) directly preceding the cursor.
+ *
+ * @param line - The full input line buffer.
+ * @param cursor - The current cursor index within the line buffer.
+ * @param triggers - Allowed trigger prefix characters (defaults to `['@']`).
+ * @returns An object containing query string and starting trigger index, or `null` if not active.
+ */
+export function extractMentionQuery(line, cursor, triggers = ['@']) {
+    if (typeof line !== 'string' || cursor < 0)
+        return null;
+    const textBeforeCursor = line.slice(0, cursor);
+    const triggerPattern = triggers.map((t) => (t === '@' ? '@' : `\\${t}`)).join('|');
+    const regex = new RegExp(`(?:^|[\\s([{\\'"<,:])(${triggerPattern})([^\\s)\\]}\\'">]*)$`);
+    const match = regex.exec(textBeforeCursor);
+    if (!match)
+        return null;
+    const trigger = match[1];
+    const query = match[2];
+    const triggerIndex = textBeforeCursor.length - query.length - trigger.length;
+    return {
+        query,
+        triggerIndex,
+        trigger,
+    };
+}
+/**
+ * Scores an autocomplete item against a search query for fuzzy and prefix ranking.
+ *
+ * @param item - The autocomplete candidate.
+ * @param query - The user search query without trigger prefix.
+ * @returns Numerical score (higher score = better match, 0 = no match).
+ */
+export function scoreAutocompleteItem(item, query) {
+    if (!query)
+        return 100;
+    const rawQ = query.toLowerCase().trim();
+    const valLower = (item.value || '').toLowerCase();
+    const labelLower = (item.label || '').toLowerCase();
+    if (valLower === rawQ || labelLower === rawQ || valLower === `@${rawQ}` || labelLower === `@${rawQ}`) {
+        return 1000;
+    }
+    // Normalize by stripping triggers/prefixes (@, #, :, /, symbol:, sym:, file:)
+    const normalize = (s) => (s || '')
+        .toLowerCase()
+        .replace(/^[@:/#]+/, '')
+        .replace(/^(?:symbol|sym|file):/, '')
+        .trim();
+    const q = normalize(query);
+    const rawVal = normalize(item.value);
+    const rawLabel = normalize(item.label);
+    if (!q)
+        return 100;
+    if (rawVal === q || rawLabel === q)
+        return 950;
+    if (rawVal.startsWith(q) || rawLabel.startsWith(q))
+        return 850 - Math.min(100, rawVal.length - q.length);
+    const baseName = (rawLabel.split('/').pop() || rawLabel).toLowerCase();
+    const baseNoExt = baseName.replace(/\.[^/.]+$/, '');
+    if (baseName.startsWith(q) || baseNoExt.startsWith(q))
+        return 750 - Math.min(100, baseName.length - q.length);
+    const idx = rawVal.indexOf(q);
+    if (idx !== -1)
+        return 500 - Math.min(100, idx);
+    const baseIdx = baseName.indexOf(q);
+    if (baseIdx !== -1)
+        return 600 - Math.min(100, baseIdx);
+    if (q.length >= 3) {
+        const dist = distance(q, baseNoExt.slice(0, Math.min(baseNoExt.length, q.length + 1)));
+        if (dist <= 2)
+            return 300 - dist * 50;
+        const fullDist = distance(q, baseNoExt);
+        if (fullDist <= 2)
+            return 300 - fullDist * 50;
+    }
+    return 0;
+}
+/**
+ * Filters and ranks suggestions according to match quality.
+ *
+ * @param items - Candidate autocomplete suggestions.
+ * @param query - The search query string.
+ * @param maxItems - Maximum number of top items to return.
+ * @returns Ranked subset of suggestions.
+ */
+export function filterAndRankSuggestions(items, query, maxItems = 10) {
+    if (!query)
+        return items.slice(0, maxItems);
+    const scored = [];
+    for (const item of items) {
+        const score = scoreAutocompleteItem(item, query);
+        if (score > 0) {
+            scored.push({ item, score });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxItems).map((s) => s.item);
+}
+/**
+ * Formats a terminal-styled category badge with picocolors.
+ *
+ * @param category - Category name (e.g. 'lines', 'sym', 'git', 'diag', 'term', 'ws', 'file').
+ * @returns Formatted ANSI badge string.
+ */
+export function formatCategoryBadge(category) {
+    switch (category?.toLowerCase()) {
+        case 'lines':
+        case 'line':
+        case 'slice':
+            return pc.blue('[lines]');
+        case 'file':
+            return pc.cyan('[file]');
+        case 'symbol':
+        case 'sym':
+            return pc.magenta('[sym]');
+        case 'git':
+        case 'diff':
+            return pc.green('[git]');
+        case 'workspace':
+        case 'ws':
+            return pc.blue('[ws]');
+        case 'diag':
+        case 'diagnostics':
+        case 'errors':
+        case 'error':
+            return pc.yellow('[diag]');
+        case 'prob':
+        case 'problem':
+        case 'problems':
+            return pc.yellow('[prob]');
+        case 'terminal':
+        case 'term':
+        case 'console':
+            return pc.magenta('[term]');
+        case 'doc':
+        case 'docs':
+            return pc.cyan('[doc]');
+        default:
+            return pc.dim(`[${category || 'item'}]`);
+    }
+}
+/**
+ * Renders an aesthetically styled autocomplete popup dropdown box for terminal display.
+ *
+ * @param suggestions - Current list of visible suggestions.
+ * @param selectedIndex - Currently selected item index.
+ * @param maxVisible - Maximum number of items visible simultaneously.
+ * @returns Multi-line ANSI string representing the autocomplete popup.
+ */
+export function renderAutocompletePopup(suggestions, selectedIndex, maxVisible = 10) {
+    if (!suggestions || suggestions.length === 0)
+        return '';
+    const total = suggestions.length;
+    const halfVisible = Math.floor(maxVisible / 2);
+    let startIndex = Math.max(0, selectedIndex - halfVisible);
+    const endIndex = Math.min(total, startIndex + maxVisible);
+    if (endIndex - startIndex < maxVisible && startIndex > 0) {
+        startIndex = Math.max(0, endIndex - maxVisible);
+    }
+    const visibleItems = suggestions.slice(startIndex, endIndex);
+    const lines = [];
+    const countBadge = pc.dim(`(${selectedIndex + 1}/${total})`);
+    lines.push(`${pc.cyan(S_BAR)}  ${pc.dim('┌─')} ${pc.bold(pc.cyan('@ Context Mentions'))} ${countBadge} ${pc.dim('─'.repeat(24))}`);
+    for (const [idx, item] of visibleItems.entries()) {
+        const actualIndex = startIndex + idx;
+        const isSelected = actualIndex === selectedIndex;
+        const pointer = isSelected ? pc.cyan('❯ ') : '  ';
+        const badge = formatCategoryBadge(item.category);
+        const label = isSelected ? pc.bold(pc.white(item.label)) : pc.white(item.label);
+        const desc = item.description ? ` ${pc.dim(item.description)}` : '';
+        lines.push(`${pc.cyan(S_BAR)}  ${pc.dim('│')} ${pointer}${badge} ${label}${desc}`);
+    }
+    lines.push(`${pc.cyan(S_BAR)}  ${pc.dim('└' + '─'.repeat(48))}`);
+    lines.push(`${pc.cyan(S_BAR)}  ${pc.cyan('Tab to insert • ↑/↓ navigate • Esc dismiss')}`);
+    return lines.join('\n');
+}
+/**
+ * Resolver for dynamic workspace files, git actions, and registered external workspaces.
+ */
+export class ContextMentionResolver {
+    cachedFiles = null;
+    externalWorkspaceCache = new Map();
+    symbolCache = new Map();
+    cacheTimestamp = 0;
+    cacheTtlMs;
+    workspaceRoot;
+    constructor(workspaceRoot = process.cwd(), cacheTtlMs = 5000) {
+        this.workspaceRoot = workspaceRoot;
+        this.cacheTtlMs = cacheTtlMs;
+    }
+    /**
+     * Clears in-memory file scanning caches.
+     */
+    clearCache() {
+        this.cachedFiles = null;
+        this.cacheTimestamp = 0;
+        this.externalWorkspaceCache.clear();
+        this.symbolCache.clear();
+    }
+    /**
+     * Returns standard built-in git, diagnostic, terminal, and symbol context mention options.
+     */
+    getBuiltInMentions() {
+        return [
+            {
+                value: '@git:diff',
+                label: 'git:diff',
+                category: 'git',
+                description: 'Working tree unstaged and staged changes',
+                metadata: { helperLabel: '[git] working tree diff' },
+            },
+            {
+                value: '@diff',
+                label: 'diff',
+                category: 'git',
+                description: 'Quick uncommitted diff alias',
+                metadata: { helperLabel: '[git] uncommitted diff' },
+            },
+            {
+                value: '@git:staged',
+                label: 'git:staged',
+                category: 'git',
+                description: 'Staged git changes only',
+                metadata: { helperLabel: '[git] staged changes' },
+            },
+            {
+                value: '@git:status',
+                label: 'git:status',
+                category: 'git',
+                description: 'Git status and untracked files',
+                metadata: { helperLabel: '[git] status summary' },
+            },
+            {
+                value: '@git:branch',
+                label: 'git:branch',
+                category: 'git',
+                description: 'Current git branch & HEAD commit',
+                metadata: { helperLabel: '[git] branch info' },
+            },
+            {
+                value: '@git:log',
+                label: 'git:log',
+                category: 'git',
+                description: 'Recent commit history log',
+                metadata: { helperLabel: '[git] recent commits' },
+            },
+            {
+                value: '@diagnostics',
+                label: 'diagnostics',
+                category: 'diag',
+                description: 'Workspace syntax and linter diagnostics',
+                metadata: { helperLabel: '[diag] workspace syntax scan' },
+            },
+            {
+                value: '@problems',
+                label: 'problems',
+                category: 'prob',
+                description: 'Workspace diagnostics / problem scan',
+                metadata: { helperLabel: '[prob] problem scan' },
+            },
+            {
+                value: '@errors',
+                label: 'errors',
+                category: 'diag',
+                description: 'Workspace errors & syntax diagnostics',
+                metadata: { helperLabel: '[diag] syntax error scan' },
+            },
+            {
+                value: '@terminal',
+                label: 'terminal',
+                category: 'term',
+                description: 'Recent terminal output and shell environment',
+                metadata: { helperLabel: '[term] shell environment' },
+            },
+            {
+                value: '@console',
+                label: 'console',
+                category: 'term',
+                description: 'Console environment and terminal session',
+                metadata: { helperLabel: '[term] console session' },
+            },
+            {
+                value: '@symbol:',
+                label: 'symbol:<name>',
+                category: 'sym',
+                description: 'AST symbol extraction (@symbol:name, @#name)',
+                metadata: { helperLabel: '[sym] AST symbol extraction' },
+            },
+        ];
+    }
+    /**
+     * Scans and caches workspace relative file paths up to depth limit.
+     *
+     * @param targetRoot - Directory root to scan. Defaults to this.workspaceRoot.
+     * @returns Array of relative file paths within the target root.
+     */
+    getWorkspaceFiles(targetRoot = this.workspaceRoot) {
+        const resolvedTarget = path.resolve(targetRoot);
+        const isPrimary = resolvedTarget === path.resolve(this.workspaceRoot);
+        const now = Date.now();
+        if (isPrimary && this.cachedFiles && now - this.cacheTimestamp < this.cacheTtlMs) {
+            return this.cachedFiles;
+        }
+        const externalEntry = this.externalWorkspaceCache.get(resolvedTarget);
+        if (!isPrimary && externalEntry && now - externalEntry.timestamp < this.cacheTtlMs) {
+            return externalEntry.files;
+        }
+        const files = [];
+        const scan = (dir, depth = 0) => {
+            if (depth > 5)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name.startsWith('.') && entry.name !== '.env')
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    const relPath = path.relative(resolvedTarget, fullPath).replace(/\\/g, '/');
+                    if (entry.isDirectory()) {
+                        if (!IGNORED_SCAN_DIRS.has(entry.name)) {
+                            scan(fullPath, depth + 1);
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        const ext = path.extname(entry.name).toLowerCase();
+                        if (!EXCLUDED_SCAN_EXTENSIONS.has(ext)) {
+                            files.push(relPath);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore unreadable directories
+            }
+        };
+        scan(resolvedTarget);
+        if (isPrimary) {
+            this.cachedFiles = files;
+            this.cacheTimestamp = now;
+        }
+        else {
+            this.externalWorkspaceCache.set(resolvedTarget, { files, timestamp: now });
+        }
+        return files;
+    }
+    /**
+     * Returns registered external workspaces as autocomplete items.
+     */
+    getWorkspaceMentions() {
+        try {
+            const list = workspaceRegistry.list();
+            return list.map((ws) => ({
+                value: `@${ws.alias}/`,
+                label: `@${ws.alias}/`,
+                category: 'workspace',
+                description: `External workspace: ${ws.absolutePath}`,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Collects base mention items including builtins, registered workspace descriptors,
+     * local files, and external workspace files if matching an external workspace alias query.
+     */
+    collectMentionItems(cleanQuery) {
+        const allItems = [
+            ...this.getBuiltInMentions(),
+            ...this.getWorkspaceMentions(),
+        ];
+        // Check if query targets an external workspace alias (@<alias>/... or <alias>/...)
+        const slashIdx = cleanQuery.indexOf('/');
+        if (slashIdx !== -1) {
+            const candidateAlias = cleanQuery.slice(0, slashIdx).toLowerCase().trim();
+            const ws = workspaceRegistry.get(candidateAlias);
+            if (ws) {
+                const extFiles = this.getWorkspaceFiles(ws.absolutePath);
+                for (const file of extFiles) {
+                    allItems.push({
+                        value: `@${ws.alias}/${file}`,
+                        label: `@${ws.alias}/${file}`,
+                        category: 'ws',
+                        description: `External file: ${ws.alias}`,
+                        metadata: {
+                            workspaceAlias: ws.alias,
+                            filePath: file,
+                            helperLabel: `[ws] @${ws.alias}/${file}`,
+                        },
+                    });
+                }
+            }
+        }
+        const files = this.getWorkspaceFiles();
+        for (const file of files) {
+            allItems.push({
+                value: `@${file}`,
+                label: file,
+                category: 'file',
+                description: 'Workspace file',
+            });
+        }
+        // Extract symbols if query is symbol-related or has at least 2 characters
+        const isSymbolQuery = cleanQuery.startsWith('symbol:') ||
+            cleanQuery.startsWith('sym:') ||
+            cleanQuery.startsWith('#');
+        const isHash = cleanQuery.startsWith('#');
+        if (isSymbolQuery || cleanQuery.length >= 2) {
+            const sourceExts = new Set(['.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs']);
+            const sourceFiles = files
+                .filter((f) => sourceExts.has(path.extname(f).toLowerCase()))
+                .sort((a, b) => {
+                const aIsSrc = a.startsWith('src/') || a.startsWith('lib/') || a.startsWith('app/') ? 0 : 1;
+                const bIsSrc = b.startsWith('src/') || b.startsWith('lib/') || b.startsWith('app/') ? 0 : 1;
+                if (aIsSrc !== bIsSrc)
+                    return aIsSrc - bIsSrc;
+                return a.localeCompare(b);
+            })
+                .slice(0, 150);
+            for (const relPath of sourceFiles) {
+                const fullPath = path.resolve(this.workspaceRoot, relPath);
+                try {
+                    const stat = fs.statSync(fullPath);
+                    let fileSymbols = this.symbolCache.get(fullPath);
+                    if (!fileSymbols || fileSymbols.mtime !== stat.mtimeMs) {
+                        const content = fs.readFileSync(fullPath, 'utf-8');
+                        const raw = extractSymbolIndex(content, fullPath);
+                        fileSymbols = { mtime: stat.mtimeMs, symbols: raw };
+                        this.symbolCache.set(fullPath, fileSymbols);
+                    }
+                    for (const s of fileSymbols.symbols) {
+                        const prefix = isHash ? '@#' : '@symbol:';
+                        allItems.push({
+                            value: `${prefix}${s.symbol}`,
+                            label: `${prefix}${s.symbol}`,
+                            category: 'sym',
+                            description: `${s.kind ? s.kind + ' in ' : ''}${relPath}`,
+                            metadata: {
+                                symbol: s.symbol,
+                                filePath: relPath,
+                                helperLabel: `[sym] ${s.symbol}`,
+                                symbolKind: s.kind,
+                            },
+                        });
+                    }
+                }
+                catch {
+                    // ignore unreadable files
+                }
+            }
+        }
+        return allItems;
+    }
+    /**
+     * Resolves, filters, and ranks suggestions matching the user's @ query.
+     */
+    async resolveSuggestions(query, options) {
+        const q = (query || '').trim();
+        const cleanQuery = q.replace(/^@/, '');
+        const allItems = this.collectMentionItems(cleanQuery);
+        if (options?.getSuggestions) {
+            try {
+                const custom = await options.getSuggestions(cleanQuery, { fullText: query, cursor: query.length });
+                if (Array.isArray(custom)) {
+                    allItems.push(...custom);
+                }
+            }
+            catch {
+                // Fallback to default items on custom provider error
+            }
+        }
+        const customFilter = options?.filterSuggestions || options?.filter;
+        if (typeof customFilter === 'function') {
+            return customFilter(allItems, cleanQuery);
+        }
+        const maxItems = options?.maxVisibleItems ?? 10;
+        return filterAndRankSuggestions(allItems, cleanQuery, maxItems);
+    }
+    /**
+     * Resolves, filters, and ranks suggestions synchronously for real-time prompt keystrokes.
+     */
+    resolveSuggestionsSync(query, options) {
+        const q = (query || '').trim();
+        const cleanQuery = q.replace(/^@/, '');
+        const allItems = this.collectMentionItems(cleanQuery);
+        const customFilter = options?.filterSuggestions || options?.filter;
+        if (typeof customFilter === 'function') {
+            return customFilter(allItems, cleanQuery);
+        }
+        const maxItems = options?.maxVisibleItems ?? 10;
+        return filterAndRankSuggestions(allItems, cleanQuery, maxItems);
+    }
+}
+/** Default singleton resolver instance */
+const defaultMentionResolver = new ContextMentionResolver();
+/**
+ * Resolves context mentions for an @ query string.
+ *
+ * @param query - The search query string without the @ prefix.
+ * @param options - Optional autocomplete configuration.
+ * @returns A promise resolving to ranked autocomplete suggestions.
+ */
+export async function resolveContextMentions(query, options) {
+    const resolver = options?.workspaceRoot || options?.cacheTtlMs
+        ? new ContextMentionResolver(options.workspaceRoot, options.cacheTtlMs)
+        : defaultMentionResolver;
+    return resolver.resolveSuggestions(query, options);
+}
 function symbol(state) {
     switch (state) {
         case 'initial':
@@ -186,7 +742,7 @@ function symbol(state) {
 }
 /**
  * A custom text prompt that supports command history navigation using Up/Down arrow keys
- * with memory bounds and dynamic input optimization.
+ * with memory bounds, dynamic input optimization, and real-time interactive @ autocomplete popups.
  *
  * @param opts - The configuration options for the prompt.
  * @returns A promise that resolves to the user's input string or a symbol if cancelled.
@@ -195,7 +751,26 @@ export const historyText = (opts) => {
     const maxLen = opts.maxHistoryLength ?? 100;
     const history = optimizeHistoryForContext(opts.history || [], maxLen);
     let historyIndex = -1;
+    const autocompleteEnabled = opts.autocomplete !== false;
+    const autocompleteOpts = typeof opts.autocomplete === 'object' ? opts.autocomplete : {};
+    const maxVisibleItems = autocompleteOpts.maxVisibleItems ?? 10;
+    const tabCompletion = autocompleteOpts.tabCompletion !== false;
+    const enterCompletion = autocompleteOpts.enterCompletion === true;
+    const resolver = autocompleteOpts.workspaceRoot || autocompleteOpts.cacheTtlMs
+        ? new ContextMentionResolver(autocompleteOpts.workspaceRoot, autocompleteOpts.cacheTtlMs)
+        : defaultMentionResolver;
+    const customGetSuggestions = opts.getSuggestions || autocompleteOpts.getSuggestions;
+    let autocompleteState = {
+        isOpen: false,
+        query: '',
+        triggerIndex: -1,
+        selectedIndex: 0,
+        suggestions: [],
+    };
+    let activeQueryVersion = 0;
     const prompt = new TextPrompt({
+        input: opts.input,
+        output: opts.output,
         validate: opts.validate,
         placeholder: opts.placeholder,
         defaultValue: opts.defaultValue,
@@ -215,43 +790,213 @@ export const historyText = (opts) => {
                 }
                 case 'cancel':
                     return `${title}${pc.gray(S_BAR)}  ${pc.strikethrough(pc.dim(this.value ?? ''))}${this.value?.trim() ? `\n${pc.gray(S_BAR)}` : ''}`;
-                default:
-                    return `${title}${pc.cyan(S_BAR)}  ${value}\n${pc.cyan(S_BAR_END)}\n`;
+                default: {
+                    let body = `${title}${pc.cyan(S_BAR)}  ${value}\n`;
+                    if (autocompleteState.isOpen && autocompleteState.suggestions.length > 0) {
+                        const popup = renderAutocompletePopup(autocompleteState.suggestions, autocompleteState.selectedIndex, maxVisibleItems);
+                        body += `${popup}\n`;
+                    }
+                    body += `${pc.cyan(S_BAR_END)}\n`;
+                    return body;
+                }
             }
         },
     });
-    prompt.on('cursor', (key) => {
-        if (key === 'up') {
-            if (history.length > 0 && historyIndex < history.length - 1) {
-                historyIndex++;
-                prompt.value = history[history.length - 1 - historyIndex];
-                const rl = prompt.rl;
-                if (rl) {
-                    rl.line = prompt.value;
-                    rl.cursor = prompt.value.length;
+    function updateAutocomplete(line, cursor) {
+        if (!autocompleteEnabled)
+            return;
+        const extracted = extractMentionQuery(line, cursor, autocompleteOpts.triggers || ['@']);
+        if (!extracted) {
+            if (autocompleteState.isOpen) {
+                autocompleteState.isOpen = false;
+                autocompleteState.suggestions = [];
+                prompt.render();
+            }
+            return;
+        }
+        const currentVersion = ++activeQueryVersion;
+        const { query, triggerIndex } = extracted;
+        if (customGetSuggestions) {
+            try {
+                const res = customGetSuggestions(query, { fullText: line, cursor });
+                if (res && typeof res.then === 'function') {
+                    ;
+                    res.then((items) => {
+                        if (currentVersion !== activeQueryVersion)
+                            return;
+                        const ranked = filterAndRankSuggestions(items || [], query, maxVisibleItems);
+                        autocompleteState = {
+                            isOpen: ranked.length > 0,
+                            query,
+                            triggerIndex,
+                            selectedIndex: Math.min(autocompleteState.selectedIndex, Math.max(0, ranked.length - 1)),
+                            suggestions: ranked,
+                        };
+                        prompt.render();
+                    }).catch(() => { });
+                    return;
+                }
+                else if (Array.isArray(res)) {
+                    const ranked = filterAndRankSuggestions(res, query, maxVisibleItems);
+                    autocompleteState = {
+                        isOpen: ranked.length > 0,
+                        query,
+                        triggerIndex,
+                        selectedIndex: Math.min(autocompleteState.selectedIndex, Math.max(0, ranked.length - 1)),
+                        suggestions: ranked,
+                    };
+                    prompt.render();
+                    return;
                 }
             }
+            catch {
+                // Fallback to default resolver
+            }
+        }
+        const items = resolver.resolveSuggestionsSync(query, {
+            ...autocompleteOpts,
+            maxVisibleItems,
+        });
+        autocompleteState = {
+            isOpen: items.length > 0,
+            query,
+            triggerIndex,
+            selectedIndex: Math.min(autocompleteState.selectedIndex, Math.max(0, items.length - 1)),
+            suggestions: items,
+        };
+        prompt.render();
+    }
+    const originalOnKeypress = prompt.onKeypress;
+    prompt.onKeypress = function (char, key) {
+        const rl = prompt.rl;
+        const currentLine = rl ? rl.line : prompt.value || '';
+        const currentCursor = rl ? rl.cursor : prompt.cursor || 0;
+        // Escape dismisses active autocomplete popup
+        if (key?.name === 'escape' && autocompleteState.isOpen) {
+            autocompleteState.isOpen = false;
+            autocompleteState.suggestions = [];
+            prompt.render();
+            return;
         }
-        else if (key === 'down') {
-            if (historyIndex > 0) {
-                historyIndex--;
-                prompt.value = history[history.length - 1 - historyIndex];
-                const rl = prompt.rl;
-                if (rl) {
-                    rl.line = prompt.value;
-                    rl.cursor = prompt.value.length;
+        // Tab completion of selected suggestion
+        if (tabCompletion &&
+            (key?.name === 'tab' || char === '\t') &&
+            autocompleteState.isOpen &&
+            autocompleteState.suggestions.length > 0) {
+            const selected = autocompleteState.suggestions[autocompleteState.selectedIndex];
+            const rawValue = selected.value.startsWith('@') ? selected.value : `@${selected.value}`;
+            const isDir = rawValue.endsWith('/');
+            const replacement = isDir ? rawValue : `${rawValue} `;
+            const before = currentLine.slice(0, autocompleteState.triggerIndex);
+            const after = currentLine.slice(currentCursor);
+            const newLine = before + replacement + after;
+            const newCursor = before.length + replacement.length;
+            if (rl) {
+                rl.line = newLine;
+                rl.cursor = newCursor;
+            }
+            prompt.value = newLine;
+            prompt._cursor = newCursor;
+            if (isDir) {
+                updateAutocomplete(newLine, newCursor);
+            }
+            else {
+                autocompleteState.isOpen = false;
+                autocompleteState.suggestions = [];
+                prompt.render();
+            }
+            return;
+        }
+        // Enter completion (if explicitly configured)
+        if (enterCompletion &&
+            key?.name === 'return' &&
+            autocompleteState.isOpen &&
+            autocompleteState.suggestions.length > 0) {
+            const selected = autocompleteState.suggestions[autocompleteState.selectedIndex];
+            const rawValue = selected.value.startsWith('@') ? selected.value : `@${selected.value}`;
+            const isDir = rawValue.endsWith('/');
+            const replacement = isDir ? rawValue : `${rawValue} `;
+            const before = currentLine.slice(0, autocompleteState.triggerIndex);
+            const after = currentLine.slice(currentCursor);
+            const newLine = before + replacement + after;
+            const newCursor = before.length + replacement.length;
+            if (rl) {
+                rl.line = newLine;
+                rl.cursor = newCursor;
+            }
+            prompt.value = newLine;
+            prompt._cursor = newCursor;
+            if (isDir) {
+                updateAutocomplete(newLine, newCursor);
+            }
+            else {
+                autocompleteState.isOpen = false;
+                autocompleteState.suggestions = [];
+                prompt.render();
+            }
+            return;
+        }
+        // Arrow navigation when autocomplete is open
+        if (autocompleteState.isOpen && autocompleteState.suggestions.length > 0) {
+            if (key?.name === 'up') {
+                autocompleteState.selectedIndex =
+                    (autocompleteState.selectedIndex - 1 + autocompleteState.suggestions.length) %
+                        autocompleteState.suggestions.length;
+                prompt.render();
+                return;
+            }
+            if (key?.name === 'down') {
+                autocompleteState.selectedIndex =
+                    (autocompleteState.selectedIndex + 1) % autocompleteState.suggestions.length;
+                prompt.render();
+                return;
+            }
+        }
+        // Normal History Navigation (when autocomplete popup is not active)
+        if (!autocompleteState.isOpen) {
+            if (key?.name === 'up') {
+                if (history.length > 0 && historyIndex < history.length - 1) {
+                    historyIndex++;
+                    prompt.value = history[history.length - 1 - historyIndex];
+                    if (rl) {
+                        rl.line = prompt.value;
+                        rl.cursor = prompt.value.length;
+                    }
+                    ;
+                    prompt.render();
                 }
+                return;
             }
-            else if (historyIndex === 0) {
-                historyIndex = -1;
-                prompt.value = '';
-                const rl = prompt.rl;
-                if (rl) {
-                    rl.line = '';
-                    rl.cursor = 0;
+            if (key?.name === 'down') {
+                if (historyIndex > 0) {
+                    historyIndex--;
+                    prompt.value = history[history.length - 1 - historyIndex];
+                    if (rl) {
+                        rl.line = prompt.value;
+                        rl.cursor = prompt.value.length;
+                    }
+                    ;
+                    prompt.render();
+                }
+                else if (historyIndex === 0) {
+                    historyIndex = -1;
+                    prompt.value = '';
+                    if (rl) {
+                        rl.line = '';
+                        rl.cursor = 0;
+                    }
+                    ;
+                    prompt.render();
                 }
+                return;
             }
         }
-    });
+        // Fall through to Clack's original keypress handler
+        originalOnKeypress?.call(prompt, char, key);
+        // Evaluate autocomplete trigger after keypress
+        const updatedLine = rl ? rl.line : prompt.value || '';
+        const updatedCursor = rl ? rl.cursor : prompt.cursor || 0;
+        updateAutocomplete(updatedLine, updatedCursor);
+    };
     return prompt.prompt();
 };