v0.1.1 release

Author: stylebending

.github/workflows/release.yml

@@ -32,7 +32,7 @@ jobs:
         uses: softprops/action-gh-release@v2
         with:
           name: Release ${{ steps.get_version.outputs.VERSION }}
-          files: target/release/aperture.exe
+          files: target/release/Aperture.exe
           generate_release_notes: true
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Cargo.lock

@@ -1,9 +1,9 @@
 [package]
-name = "aperture"
-version = "0.1.0"
-edition = "2021"
-description = "Windows-native diagnostic TUI for power users"
-authors = ["Winsight"]
+name = "Aperture"
+version = "0.1.1"
+edition = "2024"
+description = "Diagnostic tui for Windows power users"
+authors = ["stylebending"]
 license = "MIT"
 
 [dependencies]
@@ -21,6 +21,7 @@ windows = { version = "0.58", features = [
     "Win32_Security",
     "Win32_Storage_FileSystem",
     "Win32_System_Diagnostics_Debug",
+    "Win32_System_SystemInformation",
 ] }
 
 [profile.release]

Cargo.toml

@@ -1,63 +1,25 @@
 # Aperture
 
-A high-performance Windows-native diagnostic TUI for power users and developers.
+Diagnostic tui for Windows power users
 
-Aperture bridges the gap between the Linux `btop`/`lsof` experience and Windows' deep diagnostic capabilities (Processes, Services, and Network). Unlike cross-platform tools, Aperture focuses on Windows-specific pain points: file locks, service management, and process-to-socket mapping.
-
-## Features
-
-### The Locker (Process Management)
-- View all running processes with PID, name, path, CPU%, and memory usage
-- Real-time CPU and memory metrics with intelligent caching
-- **Sort by**: Name, PID, CPU usage, Memory usage
-- **Filter** processes by name, path, or PID
-- **Kill processes** (requires admin - press `K`)
-- **Find file locks** - Identify which processes are locking specific files (press `f`)
-
-### The Controller (Service Management)
-- List all Windows services with status, start type, and process ID
-- **Start/Stop services** (requires admin - press `Enter`)
-- **Sort by**: Name, Status, Service Type
-- **Filter** services by name or display name
-
-### The Nexus (Network Monitor)
-- Real-time TCP/UDP connection listing
-- Map connections to process PIDs and names
-- View connection states (ESTABLISHED, LISTENING, etc.)
-- **Sort by**: Connection State, PID, Protocol
-- **Filter** connections by address, port, or PID
+## Installation
 
-### UI Features
-- **Permanent sidebar** with context-aware keybindings
-- **Smart data caching** - All tabs preload for instant switching
-- **50ms navigation debounce** - Smooth cursor movement without jitter
-- **Change detection** - Only updates when data actually changes
-- **Cached metrics** - CPU/memory values persist during temporary data unavailability
+### Requirements
 
-## Installation
+- Windows 10/11
 
-### From Source
-```bash
-cd aperture
-cargo build --release
-```
+### Download and rune the latest release
 
-The binary will be at `target/release/aperture.exe`.
+Download and run the [latest release .exe](https://github.com/stylebending/Aperture/releases/latest)
+You're all set! Run as admin to access all features.
 
 ### Run from Any Terminal (Add to PATH)
 
-After building, add aperture to your PATH to run it from any terminal:
+If you want to run `aperture` from any terminal just add Aperture to your PATH:
 
-**Option 1: Copy to existing PATH directory**
-```powershell
-# Copy to a directory already in PATH
-copy target\release\aperture.exe C:\Windows\System32\
-```
+**Option 1: Add to user PATH environment variable**
 
-**Option 2: Add to user PATH environment variable**
-```powershell
-# Add aperture's directory to your user PATH environment variable
-```
+**Option 2: Copy the Aperture.exe to existing PATH directory**
 
 Then restart your terminal and run `aperture` from anywhere!
 
@@ -116,30 +78,35 @@ aperture
 ┌────────────────────────────────────────┐
 │         Find Locking Processes         │
 ├────────────────────────────────────────┤
-│ Paths: C:\Users\Me\Documents\file.txt  │
+│ Path: C:\Users\Me\Documents\file.txt   │
 │                                        │
 │   Locking processes:                   │
 │                                        │
 │     PID:   5678  notepad.exe           │
 │   ▶ PID:   9012  chrome.exe            │
 │     PID:  12345  excel.exe             │
 │                                        │
-│ [Enter] Search  [j/k] Navigate         │
-│ [K] Kill (admin)  [Esc] Close          │
+│ [/] Edit Path  [Enter] Search          │
+│ [j/k] Navigate  [K] Kill  [Esc] Close  │
 └────────────────────────────────────────┘
 ```
 
+**Note:** Press `/` to enter input mode and type a file path. Enter a folder path to scan all files in that directory.
+
 ## Quick Start Guide
 
 ### Find What's Locking a File
 
 Can't delete a file because it's "in use"? Aperture can find the culprit:
 
 1. Press `f` to open the **File Lock Search** modal
-2. Type the full path to the file (e.g., `C:\Users\You\file.txt`)
-3. Press `Enter` to search
-4. See which processes have the file locked
-5. Navigate with `j`/`k` and press `K` to kill the process (requires admin)
+2. Press `/` to enter input mode
+3. Type the full path to the file (e.g., `C:\Users\You\file.txt`)
+4. Press `Enter` to search
+5. See which processes have the file locked
+6. Navigate with `j`/`k` and press `K` to kill the process (requires admin)
+
+**Tip:** Enter a folder path to scan all files in that directory and find all locks.
 
 ### Kill a Runaway Process
 
@@ -211,6 +178,10 @@ Each tab supports different sorting:
 | | `f` | Find locks | Global | Open file lock search modal |
 | **Locker** | `K` | Kill process | Locker only | Kill selected process (admin) |
 | **Controller** | `Enter` | Toggle service | Controller only | Start/stop selected service (admin) |
+| **File Lock Modal** | `/` | Edit path | Modal | Enter input mode to type path |
+| | `Enter` | Search | Modal | Execute search |
+| | `j`/`k` | Navigate | Modal | Move up/down results |
+| | `K` | Kill | Modal | Kill selected locking process |
 | **System** | `q` | Quit | Global | Exit application |
 
 ### Search Mode Keybindings
@@ -225,10 +196,15 @@ When in search mode (`/`):
 
 When file lock modal is open (`f`):
 - Type file paths (one per line)
+- `/` - Enter input mode to edit path (any key including j/k can now be typed)
 - `Enter` - Search for locking processes
-- `j`/`k` - Navigate results
+- `j`/`k` or `↑`/`↓` - Navigate results (normal mode only)
 - `K` - Kill selected process (admin)
-- `Esc` - Close modal
+- `Esc` - Close modal (or cancel input mode)
+
+**Directory Scanning:**
+- Enter a folder path to scan all files in that directory
+- Shows "Scanned X files - Found Y locks" with the count of files checked
 
 ## Configuration
 
@@ -263,11 +239,6 @@ Aperture uses direct Win32 APIs instead of WMI for maximum performance:
 - Win32 APIs respond in <50ms
 - Essential for smooth TUI experience with 2-second refresh rates
 
-## Requirements
-
-- Windows 10/11
-- For full functionality (killing processes, managing services), run as Administrator
-
 ## Architecture
 
 ```
@@ -333,6 +304,39 @@ aperture/
 - [ ] Dark/light theme support
   - Currently uses terminal default colors
 
+Aperture bridges the gap between the Linux `btop`/`lsof` experience and Windows' deep diagnostic capabilities (Processes, Services, and Network). Unlike cross-platform tools, Aperture focuses on Windows-specific pain points: file locks, service management, and process-to-socket mapping.
+
+## Features
+
+### The Locker (Process Management)
+- View all running processes with PID, name, path, CPU%, and memory usage
+- Real-time CPU and memory metrics with intelligent caching
+- **Sort by**: Name, PID, CPU usage, Memory usage
+- **Filter** processes by name, path, or PID
+- **Kill processes** (requires admin - press `K`)
+- **Find file locks** - Identify which processes are locking specific files (press `f`)
+
+### The Controller (Service Management)
+- List all Windows services with status, start type, and process ID
+- **Start/Stop services** (requires admin - press `Enter`)
+- **Sort by**: Name, Status, Service Type
+- **Filter** services by name or display name
+
+### The Nexus (Network Monitor)
+- Real-time TCP/UDP connection listing
+- Map connections to process PIDs and names
+- View connection states (ESTABLISHED, LISTENING, etc.)
+- **Sort by**: Connection State, PID, Protocol
+- **Filter** connections by address, port, or PID
+
+### UI Features
+- **Vim Motions** keybindings for easy navigation
+- **Permanent sidebar** with context-aware keybindings
+- **Smart data caching** - All tabs preload for instant switching
+- **50ms navigation debounce** - Smooth cursor movement without jitter
+- **Change detection** - Only updates when data actually changes
+- **Cached metrics** - CPU/memory values persist during temporary data unavailability
+
 ## License
 
 MIT

README.md

@@ -53,6 +53,8 @@ pub enum Modal {
         selected: usize,
         loading: bool,
         error: Option<String>,
+        is_directory: bool,
+        files_scanned: Option<usize>,
     },
 }
 
@@ -80,6 +82,7 @@ pub struct App {
     pub search_query: String,
     pub status_message: Option<String>,
     pub modal: Option<Modal>,
+    pub handle_search_input_mode: bool,
 }
 
 impl App {
@@ -92,6 +95,7 @@ impl App {
             search_query: String::new(),
             status_message: None,
             modal: None,
+            handle_search_input_mode: false,
         }
     }
 
@@ -236,7 +240,18 @@ impl App {
             selected: 0,
             loading: false,
             error: None,
+            is_directory: false,
+            files_scanned: None,
         });
+        self.handle_search_input_mode = false;
+    }
+
+    pub fn enter_handle_search_input_mode(&mut self) {
+        self.handle_search_input_mode = true;
+    }
+
+    pub fn exit_handle_search_input_mode(&mut self) {
+        self.handle_search_input_mode = false;
     }
 
     pub fn handle_search_modal_char(&mut self, c: char) {
@@ -269,34 +284,67 @@ impl App {
         }
 
         let input_str = file_paths.join("\n");
-        let file_refs: Vec<&str> = file_paths.iter().map(|s| s.as_str()).collect();
+        let first_path = file_paths.first().map(|p| p.as_str()).unwrap_or("");
+        let path = std::path::Path::new(first_path);
+
+        let is_directory = path.is_dir();
 
         self.modal = Some(Modal::HandleSearch {
             input: input_str.clone(),
             results: Vec::new(),
             selected: 0,
             loading: true,
             error: None,
+            is_directory,
+            files_scanned: None,
         });
 
-        let result = sys::handle::find_locking_processes(&file_refs);
-
-        self.modal = Some(match result {
-            Ok(locking_procs) => Modal::HandleSearch {
-                input: input_str,
-                results: locking_procs,
-                selected: 0,
-                loading: false,
-                error: None,
-            },
-            Err(e) => Modal::HandleSearch {
-                input: input_str,
-                results: Vec::new(),
-                selected: 0,
-                loading: false,
-                error: Some(e.to_string()),
-            },
-        });
+        if is_directory {
+            let result = sys::handle::find_locking_processes_in_directory(first_path);
+            self.modal = Some(match result {
+                Ok((locking_procs, scanned_count)) => Modal::HandleSearch {
+                    input: input_str,
+                    results: locking_procs,
+                    selected: 0,
+                    loading: false,
+                    error: None,
+                    is_directory,
+                    files_scanned: Some(scanned_count),
+                },
+                Err(e) => Modal::HandleSearch {
+                    input: input_str,
+                    results: Vec::new(),
+                    selected: 0,
+                    loading: false,
+                    error: Some(e.to_string()),
+                    is_directory: false,
+                    files_scanned: None,
+                },
+            });
+        } else {
+            let file_refs: Vec<&str> = file_paths.iter().map(|s| s.as_str()).collect();
+            let result = sys::handle::find_locking_processes(&file_refs);
+            self.modal = Some(match result {
+                Ok(locking_procs) => Modal::HandleSearch {
+                    input: input_str,
+                    results: locking_procs,
+                    selected: 0,
+                    loading: false,
+                    error: None,
+                    is_directory,
+                    files_scanned: None,
+                },
+                Err(e) => Modal::HandleSearch {
+                    input: input_str,
+                    results: Vec::new(),
+                    selected: 0,
+                    loading: false,
+                    error: Some(e.to_string()),
+                    is_directory: false,
+                    files_scanned: None,
+                },
+            });
+        }
     }
 
     pub fn handle_search_modal_select_next(&mut self) {