inup 1.5.5 → 1.6.0

package/dist/interactive-ui.js

@@ -1,49 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InteractiveUI = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const semver = __importStar(require("semver"));
 const ui_1 = require("./ui");
 const controllers_1 = require("./ui/controllers");
-const themes_1 = require("./ui/themes");
-const themes_colors_1 = require("./ui/themes-colors");
-const debug_1 = require("./features/debug");
+const session_1 = require("./ui/session");
 const DEFAULT_VULNERABILITY_DISPLAY_OPTIONS = {
     showPeerDependencyVulnerabilities: false,
     showOptionalDependencyVulnerabilities: false,
@@ -57,12 +17,18 @@ function normalizeVulnerabilityDisplayOptions(options) {
     };
 }
 class InteractiveUI {
+    renderer;
+    packageManager;
+    options;
+    saveExact;
+    vulnerabilityAuditController = new controllers_1.VulnerabilityAuditController();
+    packageInfoModalController = new controllers_1.PackageInfoModalController();
+    refreshView;
     constructor(packageManager, options) {
-        this.vulnerabilityAuditController = new controllers_1.VulnerabilityAuditController();
-        this.packageInfoModalController = new controllers_1.PackageInfoModalController();
         this.renderer = new ui_1.UIRenderer();
         this.packageManager = packageManager;
         this.options = normalizeVulnerabilityDisplayOptions(options);
+        this.saveExact = options?.saveExact ?? false;
     }
     async displayPackagesTable(packages) {
         console.log(this.renderer.renderPackagesTable(packages));
@@ -72,65 +38,14 @@ class InteractiveUI {
         if (selectionStates.length === 0) {
             return [];
         }
-        const selectedStates = await this.interactiveTableSelector(selectionStates);
-        return this.createUpgradeChoices(selectedStates);
+        const selectedStates = await (0, session_1.runInteractiveSession)(selectionStates, this.packageManager, this.renderer, this.packageInfoModalController, this.vulnerabilityAuditController, this.options, (refresh) => { this.refreshView = refresh; });
+        return (0, session_1.createUpgradeChoices)(selectedStates, this.saveExact);
     }
     createSelectionStates(packages, previousSelections, includeUpToDate = true) {
-        const relevantPackages = includeUpToDate ? packages : packages.filter((p) => p.isOutdated);
-        const uniquePackages = this.deduplicatePackages(relevantPackages);
-        return Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths }) => {
-            const currentClean = semver.coerce(pkg.currentVersion)?.version || pkg.currentVersion;
-            const rangeClean = semver.coerce(pkg.rangeVersion)?.version || pkg.rangeVersion;
-            const latestClean = semver.coerce(pkg.latestVersion)?.version || pkg.latestVersion;
-            const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
-            const previousSelection = previousSelections?.get(key) || 'none';
-            return {
-                name: pkg.name,
-                packageJsonPath: pkg.packageJsonPath,
-                packageJsonPaths: Array.from(packageJsonPaths),
-                currentVersionSpecifier: pkg.currentVersion,
-                currentVersion: currentClean,
-                rangeVersion: rangeClean,
-                latestVersion: latestClean,
-                selectedOption: previousSelection,
-                loadState: 'ready',
-                hasRangeUpdate: pkg.hasRangeUpdate,
-                hasMajorUpdate: pkg.hasMajorUpdate,
-                type: pkg.type,
-                vulnerability: this.vulnerabilityAuditController.getCachedSummary(pkg.name, pkg.currentVersion, pkg.type),
-                allVersions: pkg.allVersions,
-            };
-        });
+        return (0, session_1.createSelectionStates)(packages, (name, version, type) => this.vulnerabilityAuditController.getCachedSummary(name, version, type), previousSelections, includeUpToDate);
     }
     createPendingSelectionStates(packages, previousSelections) {
-        const uniquePackages = this.deduplicatePackages(packages.map((pkg) => ({
-            ...pkg,
-            rangeVersion: pkg.currentVersion,
-            latestVersion: pkg.currentVersion,
-            isOutdated: false,
-            hasRangeUpdate: false,
-            hasMajorUpdate: false,
-        })));
-        return Array.from(uniquePackages.values()).map(({ pkg, packageJsonPaths }) => {
-            const currentClean = semver.coerce(pkg.currentVersion)?.version || pkg.currentVersion;
-            const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
-            const previousSelection = previousSelections?.get(key) || 'none';
-            return {
-                name: pkg.name,
-                packageJsonPath: pkg.packageJsonPath,
-                packageJsonPaths: Array.from(packageJsonPaths),
-                currentVersionSpecifier: pkg.currentVersion,
-                currentVersion: currentClean,
-                rangeVersion: 'loading',
-                latestVersion: 'loading',
-                selectedOption: previousSelection,
-                loadState: 'pending',
-                hasRangeUpdate: false,
-                hasMajorUpdate: false,
-                type: pkg.type,
-                vulnerability: this.vulnerabilityAuditController.getCachedSummary(pkg.name, pkg.currentVersion, pkg.type),
-            };
-        });
+        return (0, session_1.createPendingSelectionStates)(packages, (name, version, type) => this.vulnerabilityAuditController.getCachedSummary(name, version, type), previousSelections);
     }
     appendOutdatedBatchToSelectionStates(selectionStates, batch, previousSelections) {
         const outdatedStates = this.createSelectionStates(batch.flatMap((batchItem) => batchItem.packageInfo).filter((pkg) => pkg.isOutdated), previousSelections, false);
@@ -149,518 +64,12 @@ class InteractiveUI {
     }
     async selectPackagesToUpgradeProgressive(selectionStates, progress, attachRefresh) {
         this.enqueueSecurityAudit(selectionStates);
-        const selectedStates = await this.interactiveTableSelector(selectionStates, progress, attachRefresh);
-        return this.createUpgradeChoices(selectedStates);
+        const selectedStates = await (0, session_1.runInteractiveSession)(selectionStates, this.packageManager, this.renderer, this.packageInfoModalController, this.vulnerabilityAuditController, this.options, (refresh) => { this.refreshView = refresh; }, progress, attachRefresh);
+        return (0, session_1.createUpgradeChoices)(selectedStates, this.saveExact);
     }
     enqueueSecurityAudit(selectionStates) {
         this.vulnerabilityAuditController.enqueueStates(selectionStates, () => this.refreshView?.());
     }
-    deduplicatePackages(packages) {
-        const uniquePackages = new Map();
-        for (const pkg of packages) {
-            const key = `${pkg.name}@${pkg.currentVersion}@${pkg.type}`;
-            if (!uniquePackages.has(key)) {
-                uniquePackages.set(key, {
-                    pkg,
-                    packageJsonPaths: new Set([pkg.packageJsonPath]),
-                });
-            }
-            else {
-                uniquePackages.get(key).packageJsonPaths.add(pkg.packageJsonPath);
-            }
-        }
-        return new Map(Array.from(uniquePackages.entries()).sort(([, a], [, b]) => {
-            const aIsScoped = a.pkg.name.startsWith('@');
-            const bIsScoped = b.pkg.name.startsWith('@');
-            if (aIsScoped && !bIsScoped)
-                return -1;
-            if (!aIsScoped && bIsScoped)
-                return 1;
-            return a.pkg.name.localeCompare(b.pkg.name);
-        }));
-    }
-    createUpgradeChoices(selectedStates) {
-        const choices = [];
-        selectedStates
-            .filter((state) => state.loadState === 'ready' && state.selectedOption !== 'none')
-            .forEach((state) => {
-            const targetVersion = state.selectedOption === 'range' ? state.rangeVersion : state.latestVersion;
-            const targetVersionWithPrefix = ui_1.VersionUtils.applyVersionPrefix(state.currentVersionSpecifier, targetVersion);
-            const pathsToUpdate = state.packageJsonPaths || [state.packageJsonPath];
-            pathsToUpdate.forEach((packageJsonPath) => {
-                choices.push({
-                    name: state.name,
-                    packageJsonPath,
-                    dependencyType: state.type,
-                    upgradeType: state.selectedOption,
-                    targetVersion: targetVersionWithPrefix,
-                    currentVersionSpecifier: state.currentVersionSpecifier,
-                });
-            });
-        });
-        return choices;
-    }
-    getTerminalHeight() {
-        // Check if stdout is a TTY and has rows property
-        if (process.stdout.isTTY &&
-            typeof process.stdout.rows === 'number' &&
-            process.stdout.rows > 0) {
-            return process.stdout.rows;
-        }
-        return 24; // Fallback default
-    }
-    async interactiveTableSelector(selectionStates, loadingProgress, attachRefresh) {
-        return new Promise((resolve) => {
-            const states = selectionStates;
-            const stateManager = new ui_1.StateManager(0, this.getTerminalHeight());
-            let isResolved = false;
-            let ownsAlternateScreen = false;
-            const vulnerabilityDisplayOptions = this.options;
-            const claimInteractiveScreen = () => {
-                if (ownsAlternateScreen) {
-                    return;
-                }
-                ui_1.ConsoleUtils.clearProgress();
-                ui_1.CursorUtils.enterAlternateScreen();
-                ui_1.CursorUtils.clearScreen();
-                ownsAlternateScreen = true;
-            };
-            const releaseInteractiveScreen = () => {
-                if (!ownsAlternateScreen) {
-                    return;
-                }
-                ui_1.CursorUtils.exitAlternateScreen();
-                ownsAlternateScreen = false;
-            };
-            // No grouping needed - packages are already filtered by type
-            // This simplifies scrolling and avoids rendering issues
-            stateManager.setRenderableItems([]);
-            // Track the current max scroll offset for the info modal
-            let infoModalMaxScrollOffset = 0;
-            // Track the current max scroll offset for the debug modal
-            let debugModalMaxScrollOffset = 0;
-            let previousViewportMode = null;
-            let previousModalViewportLineCount = null;
-            const handleAction = (action) => {
-                const uiState = stateManager.getUIState();
-                const filteredStates = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
-                switch (action.type) {
-                    case 'navigate_up':
-                        if (!uiState.showThemeModal) {
-                            stateManager.navigateUp(filteredStates.length);
-                        }
-                        break;
-                    case 'navigate_down':
-                        if (!uiState.showThemeModal) {
-                            stateManager.navigateDown(filteredStates.length);
-                        }
-                        break;
-                    case 'select_left':
-                        if (!uiState.showThemeModal) {
-                            stateManager.updateSelection(filteredStates, 'left');
-                        }
-                        break;
-                    case 'select_right':
-                        if (!uiState.showThemeModal) {
-                            stateManager.updateSelection(filteredStates, 'right');
-                        }
-                        break;
-                    case 'bulk_select_minor':
-                        if (!uiState.showThemeModal) {
-                            stateManager.bulkSelectMinor(filteredStates);
-                        }
-                        break;
-                    case 'bulk_select_latest':
-                        if (!uiState.showThemeModal) {
-                            stateManager.bulkSelectLatest(filteredStates);
-                        }
-                        break;
-                    case 'bulk_unselect_all':
-                        if (!uiState.showThemeModal) {
-                            stateManager.bulkUnselectAll(filteredStates);
-                        }
-                        break;
-                    case 'toggle_dep_type_filter':
-                        if (!uiState.showThemeModal) {
-                            stateManager.toggleDependencyTypeFilter(action.depType);
-                        }
-                        break;
-                    case 'toggle_info_modal':
-                        if (!uiState.showInfoModal) {
-                            // Opening modal - load package info asynchronously
-                            const modalSessionId = stateManager.toggleInfoModal();
-                            const currentState = filteredStates[uiState.currentRow];
-                            const canFetchMetadata = currentState?.loadState === 'ready';
-                            stateManager.setModalLoading(canFetchMetadata, modalSessionId);
-                            renderInterface();
-                            if (currentState && canFetchMetadata) {
-                                this.packageInfoModalController
-                                    .hydrate(currentState)
-                                    .then(() => {
-                                    if (isResolved || stateManager.getInfoModalSessionId() !== modalSessionId)
-                                        return;
-                                    stateManager.setModalLoading(false, modalSessionId);
-                                    renderInterface();
-                                    // Auto-load the first version's release notes
-                                    if (stateManager.getInfoModalSessionId() === modalSessionId &&
-                                        this.packageInfoModalController.getVersionCount(currentState) > 0) {
-                                        this.packageInfoModalController.loadVersionAtIndex(currentState, 0, () => {
-                                            if (!isResolved)
-                                                renderInterface();
-                                        });
-                                    }
-                                })
-                                    .catch(() => {
-                                    if (isResolved || stateManager.getInfoModalSessionId() !== modalSessionId)
-                                        return;
-                                    stateManager.setModalLoading(false, modalSessionId);
-                                    renderInterface();
-                                });
-                            }
-                        }
-                        else {
-                            // Closing modal - cancel in-flight fetches
-                            this.packageInfoModalController.cancel();
-                            stateManager.toggleInfoModal();
-                            renderInterface();
-                        }
-                        break;
-                    case 'scroll_info_modal_up':
-                        if (!stateManager.scrollInfoModalUp()) {
-                            return;
-                        }
-                        break;
-                    case 'scroll_info_modal_down':
-                        if (!stateManager.scrollInfoModalDown(infoModalMaxScrollOffset)) {
-                            return;
-                        }
-                        break;
-                    case 'toggle_debug_modal':
-                        stateManager.toggleDebugModal();
-                        break;
-                    case 'scroll_debug_modal_up':
-                        if (!stateManager.scrollDebugModalUp()) {
-                            return;
-                        }
-                        break;
-                    case 'scroll_debug_modal_down':
-                        if (!stateManager.scrollDebugModalDown(debugModalMaxScrollOffset)) {
-                            return;
-                        }
-                        break;
-                    case 'switch_info_modal_tab': {
-                        const nextTab = stateManager.getInfoModalTab() === 'info' ? 'usedBy' : 'info';
-                        stateManager.setInfoModalTab(nextTab);
-                        break;
-                    }
-                    case 'navigate_info_modal_version':
-                        {
-                            if (uiState.infoModalRow >= 0 && uiState.infoModalRow < filteredStates.length) {
-                                const currentState = filteredStates[uiState.infoModalRow];
-                                const newIndex = this.packageInfoModalController.navigateVersion(currentState, action.direction);
-                                if (newIndex >= 0) {
-                                    // Reset scroll to top when switching versions
-                                    stateManager.resetInfoModalScroll();
-                                    // Load the version if not already loaded
-                                    if (!this.packageInfoModalController.isVersionLoaded(currentState, newIndex)) {
-                                        this.packageInfoModalController.loadVersionAtIndex(currentState, newIndex, () => {
-                                            if (!isResolved)
-                                                renderInterface();
-                                        });
-                                    }
-                                }
-                                else {
-                                    return;
-                                }
-                            }
-                            else {
-                                return;
-                            }
-                        }
-                        break;
-                    case 'enter_filter_mode':
-                        stateManager.enterFilterMode(action.preserveQuery);
-                        break;
-                    case 'exit_filter_mode':
-                        stateManager.exitFilterMode(action.clearQuery);
-                        break;
-                    case 'filter_input':
-                        stateManager.appendToFilterQuery(action.char);
-                        // Re-calculate filtered states after input
-                        break;
-                    case 'filter_backspace':
-                        stateManager.deleteFromFilterQuery();
-                        // Re-calculate filtered states after backspace
-                        break;
-                    case 'resize':
-                        const heightChanged = stateManager.updateTerminalHeight(action.height);
-                        if (heightChanged) {
-                            stateManager.resetForResize(filteredStates.length);
-                        }
-                        else {
-                            // Even if height didn't change, width might have changed
-                            // Force a full re-render to clear any wrapping issues
-                            stateManager.setInitialRender(true);
-                        }
-                        break;
-                    case 'toggle_theme_modal':
-                        stateManager.toggleThemeModal();
-                        break;
-                    case 'theme_navigate_up': {
-                        const themeManager = stateManager.getThemeManager();
-                        const currentIndex = themes_1.themeNames.indexOf(themeManager.getPreviewTheme());
-                        const themeArray = Object.keys(themes_1.themes);
-                        const nextIndex = currentIndex > 0 ? currentIndex - 1 : themeArray.length - 1;
-                        stateManager.previewTheme(themeArray[nextIndex]);
-                        break;
-                    }
-                    case 'theme_navigate_down': {
-                        const themeManager = stateManager.getThemeManager();
-                        const currentIndex = themes_1.themeNames.indexOf(themeManager.getPreviewTheme());
-                        const themeArray = Object.keys(themes_1.themes);
-                        const nextIndex = currentIndex < themeArray.length - 1 ? currentIndex + 1 : 0;
-                        stateManager.previewTheme(themeArray[nextIndex]);
-                        break;
-                    }
-                    case 'theme_confirm':
-                        stateManager.confirmTheme();
-                        break;
-                    case 'trigger_audit_scan':
-                        if (!uiState.showThemeModal) {
-                            const auditProgress = this.vulnerabilityAuditController.getProgress();
-                            if (auditProgress.hasData) {
-                                stateManager.toggleVulnerableFilter();
-                            }
-                            else if (!auditProgress.isRunning) {
-                                this.enqueueSecurityAudit(states);
-                            }
-                        }
-                        break;
-                    case 'cancel':
-                        this.packageInfoModalController.cancel();
-                        handleCancel();
-                        return;
-                }
-                if (action.type !== 'toggle_info_modal') {
-                    renderInterface();
-                }
-            };
-            const handleConfirm = (selectedStates) => {
-                finalizeSelection(selectedStates);
-            };
-            const handleCancel = () => {
-                finalizeSelection(states.map((s) => ({ ...s, selectedOption: 'none' })));
-            };
-            const inputHandler = new ui_1.InputHandler(stateManager, handleAction, handleConfirm, handleCancel);
-            const resetAnsiPattern = /\x1b\[(?:0|49)m/g;
-            const packageListRenderOptions = {
-                showPeerDependencyVulnerabilities: this.options.showPeerDependencyVulnerabilities,
-                showOptionalDependencyVulnerabilities: this.options.showOptionalDependencyVulnerabilities,
-            };
-            const keypressHandler = (str, key) => inputHandler.handleKeypress(str, key, states);
-            const buildRemainingViewport = (terminalWidth, terminalHeight, usedLines) => {
-                const remainingLines = Math.max(0, terminalHeight - usedLines);
-                const blankLine = ' '.repeat(terminalWidth);
-                return Array.from({ length: remainingLines }, () => blankLine);
-            };
-            const applyBackgroundToLine = (line, bgCode) => `${bgCode}${line.replace(resetAnsiPattern, (match) => `${match}${bgCode}`)}${(0, themes_colors_1.getTerminalResetCode)()}`;
-            const writeFrame = (lines, bgCode) => {
-                if (lines.length === 0) {
-                    return;
-                }
-                process.stdout.write(lines.map((line) => applyBackgroundToLine(line, bgCode)).join('\n'));
-            };
-            const key = (text) => chalk_1.default.bold.white(text);
-            const hint = (text) => chalk_1.default.gray(text);
-            const sep = hint('  ·  ');
-            const SHORTCUTS = {
-                scroll: key('↑/↓ ') + hint('Scroll'),
-                version: key('←/→ ') + hint('Version'),
-                switchTab: key('Tab ') + hint('Switch tab'),
-                closeInfo: key('I / Esc ') + hint('Close'),
-                closeTheme: key('T / Esc ') + hint('Close'),
-            };
-            const buildModalHeaderLines = (shortcutLabel) => [
-                '  ' + chalk_1.default.bold('🚀 ') + (0, themes_colors_1.coloredInupLogo)(),
-                '',
-                '  ' + shortcutLabel,
-                '',
-            ];
-            const renderViewport = (lines, terminalWidth, terminalHeight, bgCode) => {
-                const viewportLines = [
-                    ...lines,
-                    ...buildRemainingViewport(terminalWidth, terminalHeight, lines.length),
-                ];
-                writeFrame(viewportLines, bgCode);
-            };
-            const renderModalViewport = (mode, shortcutLabel, modalLines, terminalWidth, terminalHeight, bgCode) => {
-                const viewportLineCount = buildModalHeaderLines(shortcutLabel).length + modalLines.length;
-                const shouldClearBeforeRender = previousViewportMode !== mode || previousModalViewportLineCount !== viewportLineCount;
-                if (shouldClearBeforeRender) {
-                    ui_1.CursorUtils.clearScreen();
-                    ui_1.CursorUtils.hide();
-                }
-                renderViewport([...buildModalHeaderLines(shortcutLabel), ...modalLines], terminalWidth, terminalHeight, bgCode);
-                previousViewportMode = mode;
-                previousModalViewportLineCount = viewportLineCount;
-                stateManager.markRendered([]);
-            };
-            let cleanupInteractiveSession = () => {
-                process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
-                ui_1.CursorUtils.show();
-                process.stdin.off('keypress', keypressHandler);
-                process.stdin.pause();
-                process.off('SIGWINCH', handleResize);
-                this.refreshView = undefined;
-            };
-            // Safety net: restore terminal if the process exits without going through finalizeSelection.
-            // Only synchronous writes work in an 'exit' handler, but that's all we need here.
-            const emergencyCleanup = () => {
-                if (ownsAlternateScreen) {
-                    process.stdout.write('\x1b[?1049l');
-                }
-                process.stdout.write('\x1b[?25h');
-                if (process.stdin.setRawMode) {
-                    process.stdin.setRawMode(false);
-                }
-            };
-            process.on('exit', emergencyCleanup);
-            const finalizeSelection = (selectedStates) => {
-                isResolved = true;
-                this.packageInfoModalController.cancel();
-                releaseInteractiveScreen();
-                cleanupInteractiveSession();
-                process.off('exit', emergencyCleanup);
-                resolve(selectedStates);
-            };
-            const renderInterface = () => {
-                const uiState = stateManager.getUIState();
-                const filteredStates = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
-                const auditProgress = this.vulnerabilityAuditController.getProgress();
-                // Apply terminal background color
-                const bgCode = (0, themes_colors_1.getTerminalBgColorCode)();
-                process.stdout.write(bgCode);
-                if (uiState.forceFullRender) {
-                    ui_1.CursorUtils.clearScreen();
-                    ui_1.CursorUtils.hide();
-                }
-                else {
-                    ui_1.CursorUtils.moveToHome();
-                }
-                // If theme modal is open, render only the theme selector
-                if (uiState.showThemeModal) {
-                    const terminalWidth = process.stdout.columns || 80;
-                    const terminalHeight = this.getTerminalHeight();
-                    const themeManager = stateManager.getThemeManager();
-                    const modalLines = this.renderer.renderThemeSelectorModal(themeManager.getCurrentTheme(), themeManager.getPreviewTheme(), terminalWidth, terminalHeight);
-                    renderModalViewport('theme-modal', SHORTCUTS.closeTheme, modalLines, terminalWidth, terminalHeight, bgCode);
-                }
-                else if (uiState.showDebugModal) {
-                    const terminalWidth = process.stdout.columns || 80;
-                    const terminalHeight = this.getTerminalHeight();
-                    const snapshot = (0, debug_1.getPerformanceTracker)().snapshot();
-                    const result = (0, debug_1.renderPerformanceModal)(snapshot, terminalWidth, Math.max(8, terminalHeight - 4), uiState.debugModalScrollOffset);
-                    debugModalMaxScrollOffset = result.maxScrollOffset;
-                    stateManager.clampDebugModalScrollOffset(debugModalMaxScrollOffset);
-                    const debugHints = [
-                        result.usesInternalScroll && result.maxScrollOffset > 0 ? SHORTCUTS.scroll : '',
-                        SHORTCUTS.closeInfo,
-                    ].filter(Boolean).join(sep);
-                    renderModalViewport('info-modal', debugHints, result.lines, terminalWidth, terminalHeight, bgCode);
-                }
-                else if (uiState.showInfoModal &&
-                    uiState.infoModalRow >= 0 &&
-                    uiState.infoModalRow < filteredStates.length) {
-                    const selectedState = filteredStates[uiState.infoModalRow];
-                    const terminalWidth = process.stdout.columns || 80;
-                    const terminalHeight = this.getTerminalHeight();
-                    if (uiState.isLoadingModalInfo) {
-                        // Show loading state
-                        const result = this.renderer.renderPackageInfoLoading(selectedState, terminalWidth, Math.max(8, terminalHeight - 4));
-                        infoModalMaxScrollOffset = result.maxScrollOffset;
-                        renderModalViewport('info-modal', SHORTCUTS.closeInfo, result.lines, terminalWidth, terminalHeight, bgCode);
-                    }
-                    else {
-                        // Show full info with scroll support
-                        const activeTab = uiState.infoModalTab;
-                        const result = this.renderer.renderPackageInfoModal(selectedState, terminalWidth, Math.max(8, terminalHeight - 4), uiState.infoModalScrollOffset, activeTab);
-                        infoModalMaxScrollOffset = result.maxScrollOffset;
-                        stateManager.clampInfoModalScrollOffset(infoModalMaxScrollOffset);
-                        const hints = [
-                            result.usesInternalScroll && result.maxScrollOffset > 0 ? SHORTCUTS.scroll : '',
-                            activeTab === 'info' ? SHORTCUTS.version : '',
-                            SHORTCUTS.switchTab,
-                            SHORTCUTS.closeInfo,
-                        ].filter(Boolean).join(sep);
-                        renderModalViewport('info-modal', hints, result.lines, terminalWidth, terminalHeight, bgCode);
-                    }
-                }
-                else {
-                    // Normal list view (flat rendering - no grouping)
-                    const terminalWidth = process.stdout.columns || 80;
-                    const terminalHeight = this.getTerminalHeight();
-                    const activeFilterLabel = stateManager.getActiveFilterLabel();
-                    const lines = this.renderer.renderInterface(filteredStates, uiState.currentRow, uiState.scrollOffset, uiState.maxVisibleItems, uiState.forceFullRender, [], // No renderable items - use flat rendering
-                    activeFilterLabel, // Show current dependency type filter state
-                    this.packageManager, // Pass package manager info for header
-                    uiState.filterMode, uiState.filterQuery, states.length, terminalWidth, loadingProgress, auditProgress, packageListRenderOptions);
-                    renderViewport(lines, terminalWidth, terminalHeight, bgCode);
-                    previousViewportMode = 'list';
-                    previousModalViewportLineCount = null;
-                    stateManager.markRendered(lines);
-                }
-                stateManager.setInitialRender(false);
-            };
-            const handleResize = () => {
-                // On resize (width or height change), always trigger a re-render
-                // This prevents layout breaking when terminal width changes
-                // The action handler will update height and force a full re-render
-                inputHandler.handleResize(this.getTerminalHeight());
-            };
-            // Setup keypress handling
-            try {
-                claimInteractiveScreen();
-                this.refreshView = () => {
-                    if (!isResolved) {
-                        renderInterface();
-                    }
-                };
-                attachRefresh?.(() => {
-                    if (!isResolved) {
-                        renderInterface();
-                    }
-                });
-                const keypressSession = ui_1.TerminalInput.startKeypressSession(keypressHandler);
-                const previousCleanup = cleanupInteractiveSession;
-                cleanupInteractiveSession = () => {
-                    keypressSession.close();
-                    previousCleanup();
-                };
-                // Setup resize handler
-                process.on('SIGWINCH', handleResize);
-                // Update terminal height directly before initial render to ensure correct dimensions
-                // This handles cases where process.stdout.rows might not be accurate at startup
-                const currentHeight = this.getTerminalHeight();
-                if (stateManager.updateTerminalHeight(currentHeight)) {
-                    const initialFiltered = stateManager.getFilteredStates(states, vulnerabilityDisplayOptions);
-                    stateManager.resetForResize(initialFiltered.length);
-                }
-                // Initial render
-                renderInterface();
-                this.enqueueSecurityAudit(states);
-            }
-            catch (error) {
-                process.off('exit', emergencyCleanup);
-                releaseInteractiveScreen();
-                // Reset terminal colors
-                process.stdout.write((0, themes_colors_1.getTerminalResetCode)());
-                this.refreshView = undefined;
-                // Fallback to simple interface if raw mode fails
-                console.log(chalk_1.default.yellow('Raw mode not available, using fallback interface...'));
-                resolve(states);
-            }
-        });
-    }
     async confirmUpgrade(choices) {
         console.log(this.renderer.renderConfirmation(choices));
         return new Promise((resolve) => {