diffwatch 1.0.8 → 1.1.0

package/AGENTS.md

@@ -0,0 +1,201 @@
+# DiffWatch Agent Guidelines
+
+This document provides coding standards and operational guidelines for agentic coding assistants working on the DiffWatch project.
+
+## Build, Lint, and Test Commands
+
+### Primary Commands
+- **Build**: `npm run build` - Compiles TypeScript to JavaScript using `tsc`
+- **Test**: `npm test` - Runs Jest test suite
+- **Dev**: `npm run dev` - Runs the application in development mode with `ts-node`
+- **Start**: `npm start` - Runs the compiled application from `dist/`
+
+### Testing Specific Files
+- Run a single test file: `npm test -- tests/git.test.ts`
+- Run tests matching a pattern: `npm test -- --testNamePattern="should return file status"`
+
+### Linting and Type Checking
+- **Type Check**: `npx tsc --noEmit` - TypeScript type checking without compilation
+- **No explicit linting configured** - TypeScript strict mode serves as the primary code quality gate
+
+## Code Style Guidelines
+
+### Language and Module System
+- **Language**: TypeScript with strict mode enabled
+- **Target**: ES6 JavaScript output
+- **Module System**: CommonJS output (`"type": "commonjs"` in package.json)
+- **Source**: ES6 modules with `import`/`export` syntax
+
+### Import/Export Style
+```typescript
+// ES6 imports at the top of files
+import { simpleGit, SimpleGit, StatusResult } from 'simple-git';
+import fs from 'fs/promises';
+import chalk from 'chalk';
+
+// Named exports for utilities
+export interface FileStatus {
+  path: string;
+  status: 'modified' | 'added' | 'deleted' | 'unstaged' | 'unknown' | 'unchanged';
+  mtime?: Date;
+}
+
+// Default export for main classes
+export class GitHandler {
+  // ...
+}
+```
+
+### Naming Conventions
+- **Variables/Functions**: camelCase (`filePath`, `getStatus`, `updateFileList`)
+- **Classes/Interfaces**: PascalCase (`GitHandler`, `FileStatus`)
+- **Constants**: UPPER_CASE (not commonly used in this codebase)
+- **Files**: kebab-case for directories (`diff-formatter.ts`), camelCase for utilities
+- **Test Files**: Match source filename with `.test.ts` extension (`git.test.ts`)
+
+### Code Structure and Patterns
+- **Async/Await**: Preferred over Promises for asynchronous operations
+- **Error Handling**: Try-catch blocks with descriptive error messages
+- **Type Safety**: Use interfaces for data structures, avoid `any` type
+- **Class Design**: Private properties with public methods, constructor injection
+- **Functional Programming**: Pure functions where possible, avoid side effects
+
+### Formatting and Style
+- **Indentation**: 2 spaces (no tabs)
+- **Semicolons**: Not used (TypeScript ASI)
+- **Quotes**: Single quotes for strings (`'string'`)
+- **Line Length**: No strict limit, break long lines naturally
+- **Blank Lines**: Use sparingly between logical code blocks
+- **Comments**: Minimal comments, rely on descriptive naming
+- **Braces**: Same line for functions/classes, new line for control structures
+
+### Example Code Style
+```typescript
+export class GitHandler {
+  private git: SimpleGit;
+
+  constructor(workingDir: string = process.cwd()) {
+    this.git = simpleGit(workingDir);
+  }
+
+  async getStatus(): Promise<FileStatus[]> {
+    const status: StatusResult = await this.git.status();
+    const uniqueFiles = new Map<string, FileStatus>();
+
+    status.modified.forEach(path => {
+      uniqueFiles.set(path, { path, status: 'modified' });
+    });
+
+    // Process and return sorted results
+    const fileArray = Array.from(uniqueFiles.values());
+    return fileArray.sort((a, b) => {
+      const timeDiff = (b.mtime || new Date(0)).getTime() - (a.mtime || new Date(0)).getTime();
+      return timeDiff !== 0 ? timeDiff : a.path.localeCompare(b.path);
+    });
+  }
+}
+```
+
+### Error Handling Patterns
+```typescript
+async getFileContent(filePath: string): Promise<string> {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch (error) {
+    return `Error reading file: ${error}`;
+  }
+}
+
+async isRepo(): Promise<boolean> {
+  try {
+    return await this.git.checkIsRepo();
+  } catch {
+    return false;
+  }
+}
+```
+
+### Testing Guidelines
+- **Framework**: Jest with ts-jest for TypeScript support
+- **Mocking**: Mock external dependencies (simple-git, fs/promises)
+- **Test Structure**: `describe` blocks for classes, `it` blocks for methods
+- **Assertions**: Use Jest matchers (`expect().toBe()`, `expect().toEqual()`)
+- **Test Naming**: Descriptive sentences starting with "should"
+- **Coverage**: Aim for critical path coverage, especially Git operations
+
+```typescript
+describe('GitHandler', () => {
+  let gitHandler: GitHandler;
+  let mockGit: any;
+
+  beforeEach(() => {
+    mockGit = { checkIsRepo: jest.fn() };
+    (simpleGit as jest.Mock).mockReturnValue(mockGit);
+    gitHandler = new GitHandler();
+  });
+
+  it('should return true if directory is a repo', async () => {
+    mockGit.checkIsRepo.mockResolvedValue(true);
+    const result = await gitHandler.isRepo();
+    expect(result).toBe(true);
+  });
+});
+```
+
+### File Organization
+- **Source Code**: `src/` directory with subdirectories for utilities
+- **Tests**: `tests/` directory mirroring source structure
+- **Build Output**: `dist/` directory (gitignored)
+- **Configuration**: Root level for `package.json`, `tsconfig.json`, `jest.config.js`
+
+### TypeScript Configuration
+- **Strict Mode**: Enabled for type safety
+- **Source Maps**: Enabled for debugging
+- **Declaration Files**: Generated for library usage
+- **Module Resolution**: Node.js style
+- **ES Module Interop**: Enabled for compatibility
+
+### Dependencies
+- **Runtime**: chalk (colors), simple-git (Git operations), neo-neo-blessed (TUI)
+- **Dev**: Jest, ts-jest, ts-node, TypeScript
+- **Keep dependencies minimal** - only add when necessary for functionality
+
+### Git and Version Control
+- **Branching**: Feature branches for development
+- **Commits**: Descriptive messages focusing on "why" rather than "what"
+- **Tags**: Semantic versioning (current: 1.0.8)
+- **Hooks**: No custom hooks configured
+
+### Security Considerations
+- **Input Validation**: Validate file paths and user inputs
+- **Error Messages**: Avoid exposing sensitive system information
+- **Dependencies**: Keep updated, audit regularly
+- **Secrets**: Never commit sensitive data
+
+### Performance Guidelines
+- **Async Operations**: Use efficient patterns, avoid blocking operations
+- **Memory Management**: Clean up resources, avoid memory leaks
+- **File I/O**: Handle large files appropriately
+- **Real-time Updates**: Debounce rapid operations (150ms in current code)
+
+### Code Review Checklist
+- [ ] TypeScript compiles without errors
+- [ ] Tests pass and cover new functionality
+- [ ] Follows established naming and style conventions
+- [ ] Error handling appropriate for use case
+- [ ] No console.log statements in production code
+- [ ] Dependencies justified and minimal
+- [ ] Documentation updated if public API changes</content>
+<parameter name="filePath">D:\SystemFolders\Downloads\Dev\node\diffwatch\AGENTS.md
+
+<!-- GENERAL-RULES-RULES-START -->
+
+## You must always follow these rules:
+
+- If you are unsure about any requirement, behavior, or implementation detail, ask clarifying questions **before** writing code.
+- At every step, provide a **high-level explanation** of what changes were made and why.
+- After implementing changes or new features, always provide a list of **suggestions or improvements**, even if they differ from the user's original request.
+- If the user requests a change or feature that is an **anti-pattern** or violates well-established best practices, clearly explain the issue and ask for confirmation before proceeding.
+- Always use Context7 MCP when I need library/API documentation, code generation, setup or configuration steps without me having to explicitly ask.
+
+<!-- GENERAL-RULES-RULES-END -->

package/dist/index.js

@@ -18,27 +18,38 @@ const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
 const git_1 = require("./utils/git");
 const diff_formatter_1 = require("./utils/diff-formatter");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const packageJson = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)((0, path_1.dirname)(__filename), '..', 'package.json'), 'utf-8'));
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         const args = process.argv.slice(2);
         let repoPath = process.cwd();
         const showHelp = () => {
-            console.log(`
-Usage: diffwatch [path] [options]
-
-Arguments:
-  path               Path to the git repository (default: current directory)
-
-Options:
-  -h, --help         Show help information
+            console.log(`
+Usage: diffwatch [path]
+
+Arguments:
+  path               Path to the git repository (default: current directory)
+
+Options:
+  -h, --help         Show help information
+  -v, --version      Show version information
     `);
             process.exit(0);
         };
+        const showVersion = () => {
+            console.log(`diffwatch v${packageJson.version}`);
+            process.exit(0);
+        };
         const positionalArgs = [];
         for (let i = 0; i < args.length; i++) {
             if (args[i] === '-h' || args[i] === '--help') {
                 showHelp();
             }
+            else if (args[i] === '-v' || args[i] === '--version') {
+                showVersion();
+            }
             else if (args[i].startsWith('-')) {
                 // Ignore unknown flags or handle them if needed
             }
@@ -72,7 +83,7 @@ Options:
         });
         // Explicitly enable mouse tracking
         screen.program.enableMouse();
-        const fileList = blessed.list({
+        let fileList = blessed.list({
             top: 0,
             left: 0,
             width: '30%',
@@ -93,6 +104,38 @@ Options:
             },
             border: { type: 'line' },
         });
+        const createFileList = () => {
+            const newList = blessed.list({
+                top: 0,
+                left: 0,
+                width: '30%',
+                height: '99%',
+                label: 'Files (0)',
+                keys: true,
+                vi: true,
+                mouse: true,
+                tags: true,
+                scrollbar: {
+                    ch: ' ',
+                    track: { bg: 'white' },
+                    style: { bg: 'blue' },
+                },
+                style: {
+                    selected: { fg: 'black', bg: 'white' },
+                    border: { fg: 'white' },
+                },
+                border: { type: 'line' },
+            });
+            newList.on('select item', () => {
+                scheduleDiffUpdate();
+            });
+            newList.key(['up', 'down'], () => {
+                scheduleDiffUpdate();
+            });
+            newList.on('wheeldown', () => handleScroll('down'));
+            newList.on('wheelup', () => handleScroll('up'));
+            return newList;
+        };
         const diffView = blessed.scrollabletext({
             top: 0,
             left: '30%',
@@ -115,7 +158,7 @@ Options:
         });
         const searchBox = blessed.box({
             top: 'center',
-            left: 'center',
+            left: '40%', // Center of right pane (30% + 70%/2 = 65%)
             width: '50%',
             height: 3,
             label: ' Search ',
@@ -136,11 +179,11 @@ Options:
         // Confirmation dialog for revert
         const confirmDialog = blessed.box({
             top: 'center',
-            left: 'center',
+            left: '45%', // Center of right pane (30% + 70%/2 = 65%)
             width: '38%',
             label: ' Confirm Revert ',
             height: 3,
-            content: 'Press ENTER key to confirm revert or ESC to cancel.',
+            content: 'Press SPACE key to confirm revert or ESC to cancel.',
             border: { type: 'line' },
             style: {
                 fg: 'yellow',
@@ -149,22 +192,70 @@ Options:
             },
             hidden: true,
         });
+        const notificationBox = blessed.box({
+            top: 'center',
+            left: '45%', // Center of right pane (30% + 70%/2 = 65%)
+            width: '38%',
+            height: 3,
+            label: ' Notification ',
+            border: { type: 'line' },
+            style: {
+                fg: 'green',
+                bg: 'black',
+                border: { fg: 'green' }
+            },
+            hidden: true,
+        });
+        const showNotification = (message, color = 'green') => {
+            const previouslyFocused = screen.focused;
+            notificationBox.setContent(message);
+            notificationBox.style = {
+                fg: color,
+                bg: 'black',
+                border: { fg: color }
+            };
+            notificationBox.show();
+            notificationBox.setFront();
+            screen.render();
+            setTimeout(() => {
+                notificationBox.hide();
+                if (previouslyFocused && previouslyFocused !== notificationBox) {
+                    previouslyFocused.focus();
+                }
+                else {
+                    fileList.focus();
+                }
+                updateBorders();
+                screen.render();
+            }, 3000);
+        };
+        // Branch display in bottom right
+        const branchBox = blessed.box({
+            bottom: 0,
+            right: 0,
+            width: 'shrink',
+            height: 1,
+            align: 'left',
+            content: chalk_1.default.cyan('Branch: '),
+            style: {
+                fg: 'white',
+            },
+        });
         // Footer box to show shortcuts - aligned with the panes
         const footer = blessed.box({
             bottom: 0,
             left: 0,
             width: '100%',
             height: 1,
-            align: 'center',
             content: chalk_1.default.green('←→') + ' Switch |' + chalk_1.default.green(' ⏎') + ' Open | ' + chalk_1.default.green('S') + ' Search | ' + chalk_1.default.green('R') + ' Revert | ' + chalk_1.default.green('Q') + ' Quit ',
         });
-        // Adjust footer to align with the panes
-        // Note: We'll adjust this after screen initialization
         screen.append(fileList);
         screen.append(diffView);
         screen.append(searchBox);
+        screen.append(notificationBox);
         screen.append(confirmDialog);
         screen.append(footer);
+        screen.append(branchBox);
         const updateBorders = () => {
             fileList.style.border.fg = screen.focused === fileList ? 'yellow' : 'white';
             diffView.style.border.fg = screen.focused === diffView ? 'yellow' : 'white';
@@ -174,6 +265,9 @@ Options:
         let lastSelectedPath = null;
         let diffUpdateTimeout = null;
         let currentSearchTerm = '';
+        let currentBranch = '';
+        let lastFilePaths = [];
+        let isUpdatingList = false;
         const scheduleDiffUpdate = () => {
             if (diffUpdateTimeout)
                 clearTimeout(diffUpdateTimeout);
@@ -182,17 +276,18 @@ Options:
             }), 150); // 150ms debounce
         };
         const handleScroll = (direction) => {
-            if (screen.focused === fileList) {
+            const focused = screen.focused;
+            if (focused === fileList) {
                 if (direction === 'up') {
-                    fileList.up(1);
+                    focused.up(1);
                 }
                 else {
-                    fileList.down(1);
+                    focused.down(1);
                 }
                 scheduleDiffUpdate();
                 screen.render();
             }
-            else if (screen.focused === diffView) {
+            else if (focused === diffView) {
                 const scrollAmount = direction === 'up' ? -2 : 2;
                 diffView.scroll(scrollAmount);
                 screen.render();
@@ -206,9 +301,9 @@ Options:
         // Attach custom scroll handlers to widgets (captures wheel even if hovering specific widget)
         // We use widget-level listeners now that screen.mouse is true.
         // We attach to both to ensure the event is caught regardless of where the mouse is.
+        // We use widget-level listeners now that screen.mouse is true.
+        // We attach to both to ensure the event is caught regardless of where the mouse is.
         // The handleScroll function will then decide WHAT to scroll based on focus.
-        fileList.on('wheeldown', () => handleScroll('down'));
-        fileList.on('wheelup', () => handleScroll('up'));
         diffView.on('wheeldown', () => handleScroll('down'));
         diffView.on('wheelup', () => handleScroll('up'));
         // Also listen on screen for events that might miss the widgets (margins, borders)
@@ -230,9 +325,25 @@ Options:
                 console.error(`Failed to open ${filePath}: ${error}`);
             }
         };
+        const updateBranch = () => __awaiter(this, void 0, void 0, function* () {
+            const branch = yield gitHandler.getBranch();
+            if (branch !== currentBranch) {
+                currentBranch = branch;
+                branchBox.setContent(chalk_1.default.cyan('Branch: ') + chalk_1.default.yellow(branch));
+                screen.render();
+            }
+        });
         const updateDiff = () => __awaiter(this, void 0, void 0, function* () {
             const selectedIndex = fileList.selected;
             const selectedFile = currentFiles[selectedIndex];
+            if (!selectedFile) {
+                // No valid file selected, clear diff view
+                diffView.setContent('Select a file to view diff.');
+                diffView.setLabel(' Diff () ');
+                lastSelectedPath = null;
+                screen.render();
+                return;
+            }
             if (selectedFile) {
                 let content = '';
                 let label = ` Diff (${selectedFile.path}) `;
@@ -284,9 +395,10 @@ Options:
         });
         const updateFileList = () => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            // Preserve selected file path and scroll positions
+            if (isUpdatingList)
+                return;
+            isUpdatingList = true;
             const selectedPath = (_a = currentFiles[fileList.selected]) === null || _a === void 0 ? void 0 : _a.path;
-            const diffScroll = diffView.scrollTop;
             let files;
             if (currentSearchTerm) {
                 files = yield gitHandler.searchFiles(currentSearchTerm);
@@ -295,7 +407,7 @@ Options:
                 files = yield gitHandler.getStatus();
             }
             currentFiles = files;
-            const items = files.map(f => {
+            const items = files.map((f) => {
                 let color = '{white-fg}';
                 if (f.status === 'added')
                     color = '{green-fg}';
@@ -307,61 +419,62 @@ Options:
                     color = '{white-fg}';
                 else if (f.status === 'unchanged')
                     color = '{grey-fg}';
-                return `${color}${f.path}{/}`;
+                let statusSymbol = '';
+                if (f.status === 'added')
+                    statusSymbol = 'A ';
+                else if (f.status === 'deleted')
+                    statusSymbol = 'D ';
+                else if (f.status === 'modified')
+                    statusSymbol = 'M ';
+                else if (f.status === 'unstaged')
+                    statusSymbol = '? ';
+                else if (f.status === 'unchanged')
+                    statusSymbol = '  ';
+                return `${color}${statusSymbol}${f.path}{/}`;
             });
-            fileList.setItems(items);
             const labelTitle = currentSearchTerm ? `Files (${files.length}) - Searching: "${currentSearchTerm}"` : `Files (${files.length})`;
-            fileList.setLabel(labelTitle);
+            const newFilePaths = files.map(f => f.path);
+            const selectedFileStillExists = selectedPath ? newFilePaths.includes(selectedPath) : false;
+            const listChanged = lastFilePaths.length !== newFilePaths.length ||
+                lastFilePaths.some(path => !newFilePaths.includes(path)) ||
+                newFilePaths.some(path => !lastFilePaths.includes(path));
             if (items.length > 0) {
-                // Restore selection by path if possible
                 const newSelectedIndex = selectedPath ? currentFiles.findIndex(f => f.path === selectedPath) : -1;
-                fileList.select(newSelectedIndex >= 0 ? newSelectedIndex : 0);
-                // Cancel any pending diff update and update immediately
+                const oldFileList = fileList;
+                const newFileList = createFileList();
+                newFileList.setLabel(labelTitle);
+                newFileList.setItems(items);
+                newFileList.select(newSelectedIndex >= 0 ? newSelectedIndex : 0);
+                if (!selectedFileStillExists || listChanged) {
+                    lastSelectedPath = null;
+                }
+                lastFilePaths = newFilePaths;
                 if (diffUpdateTimeout) {
                     clearTimeout(diffUpdateTimeout);
                     diffUpdateTimeout = null;
                 }
                 yield updateDiff();
+                oldFileList.destroy();
+                screen.remove(oldFileList);
+                fileList = newFileList;
+                screen.append(fileList);
             }
             else {
-                // Clear the file list when there are no files
-                fileList.clearItems();
+                const oldFileList = fileList;
+                const newFileList = createFileList();
+                newFileList.setLabel(labelTitle);
+                newFileList.setItems([]);
                 diffView.setContent(currentSearchTerm ? `No files match "${currentSearchTerm}".` : 'No changes detected.');
                 diffView.setLabel(' Diff () ');
+                lastSelectedPath = null;
+                lastFilePaths = [];
+                oldFileList.destroy();
+                screen.remove(oldFileList);
+                fileList = newFileList;
+                screen.append(fileList);
             }
-            // Restore scroll positions if reasonably possible (reset if list changed drastically)
-            // Actually, if we filter, the scroll position might be invalid.
-            // Ideally we keep it 0 if it was 0 or just let the select() call handle scrolling to the item.
-            // The previous implementation blindly restored scrollTop.
-            // If the list shrunk, select() should have brought it into view.
-            // We only explicitly restore if items.length > 0
-            // But setting scroll to previous value might be wrong if the list is now shorter.
-            // Safe to only restore diffView scroll as it depends on content, fileList is handled by select.
-            diffView.scrollTop = diffScroll;
             screen.render();
-        });
-        fileList.on('select item', () => {
-            scheduleDiffUpdate();
-        });
-        fileList.key(['up', 'down'], () => {
-            scheduleDiffUpdate();
-        });
-        screen.key(['escape', 'q', 'C-c'], () => {
-            if (!searchBox.hidden) {
-                searchBox.hide();
-                screen.render();
-                fileList.focus();
-            }
-            else if (!confirmDialog.hidden) {
-                // Close the confirmation dialog if it's open
-                confirmDialog.hide();
-                fileList.focus();
-                screen.render();
-            }
-            else {
-                screen.destroy();
-                process.exit(0);
-            }
+            isUpdatingList = false;
         });
         screen.key(['s'], () => {
             searchBox.show();
@@ -392,12 +505,16 @@ Options:
             updateBorders();
         });
         screen.key(['left'], () => {
-            fileList.focus();
-            updateBorders();
+            if (screen.focused !== fileList) {
+                fileList.focus();
+                updateBorders();
+            }
         });
         screen.key(['right'], () => {
-            diffView.focus();
-            updateBorders();
+            if (screen.focused !== diffView) {
+                diffView.focus();
+                updateBorders();
+            }
         });
         screen.key(['enter'], () => {
             const selectedIndex = fileList.selected;
@@ -411,44 +528,74 @@ Options:
             const selectedIndex = fileList.selected;
             const selectedFile = currentFiles[selectedIndex];
             if (selectedFile) {
-                confirmDialog.setContent(`Press SPACE key to confirm revert or ESC to cancel.`);
                 confirmDialog.show();
+                confirmDialog.setFront();
                 confirmDialog.focus();
                 screen.render();
             }
         }));
-        // Handle confirmation dialog response with SPACE key
+        // Handle dialog keys
         confirmDialog.key(['space'], () => __awaiter(this, void 0, void 0, function* () {
-            confirmDialog.hide();
             const selectedIndex = fileList.selected;
             const selectedFile = currentFiles[selectedIndex];
             if (selectedFile) {
                 try {
                     yield gitHandler.revertFile(selectedFile.path);
-                    console.log(chalk_1.default.green(`File ${selectedFile.path} reverted successfully.`));
-                    // Refresh the file list after reverting
+                    showNotification(`File ${selectedFile.path} reverted successfully.`, 'green');
                     yield updateFileList();
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
-                    console.error(chalk_1.default.red(`Error reverting file: ${errorMessage}`));
+                    showNotification(`Error reverting file: ${errorMessage}`, 'red');
                 }
             }
+            confirmDialog.hide();
             fileList.focus();
             screen.render();
         }));
-        // Handle cancellation with ESC key
-        confirmDialog.key(['escape', 'q'], () => {
+        confirmDialog.key(['escape'], () => {
             confirmDialog.hide();
             fileList.focus();
             screen.render();
         });
-        setInterval(() => __awaiter(this, void 0, void 0, function* () {
-            yield updateFileList();
-        }), 5000);
+        yield updateBranch();
         yield updateFileList();
         fileList.focus();
         updateBorders();
+        // Set up periodic updates to detect new git changes
+        const updateInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            const currentlyFocused = screen.focused;
+            const wasFileListFocused = currentlyFocused === fileList;
+            yield updateBranch();
+            yield updateFileList();
+            // Restore focus to the same pane it was on before the update
+            if (wasFileListFocused) {
+                fileList.focus();
+            }
+            else if (currentlyFocused === diffView) {
+                diffView.focus();
+            }
+            updateBorders();
+        }), 2000); // Check for changes every 2 seconds
+        // Clean up interval on exit
+        screen.key(['escape', 'q', 'C-c'], () => {
+            // Don't handle ESC if confirmation dialog has focus or is visible
+            if (screen.focused === confirmDialog || !confirmDialog.hidden) {
+                return false;
+            }
+            if (!searchBox.hidden) {
+                searchBox.hide();
+                screen.render();
+                fileList.focus();
+                return false;
+            }
+            else {
+                // Clear interval only when actually exiting
+                clearInterval(updateInterval);
+                screen.destroy();
+                process.exit(0);
+            }
+        });
     });
 }
 main().catch(err => {