feat: implement Rich UI, process aggregation, and robust input handling

- Fix input detection issues by implementing immediate multi-byte sequence (no longer does it spam characaters FINALLY)
- Implement persistent UI configuration using Windows Registry to avoid  external JSON files in PyInstaller builds.
- Fixed artifacts surrounding startup and screen resizing by sending os.system('cls') on resize and startup_ok
- Refined some stuff and checked compatability with dogfooding

Author: ThatOneFBIAgent

README.md

@@ -53,8 +53,11 @@ A text based user interface (TUI) task manager for Windows, inspired by `htop`.
 | `export [file]` | Export process list to file (default: `processes.txt`) |
 | `quit` | Exit the application |
 | `showdrives` | Toggle display of all drives |
+| `procfull` | Toggle full process info (default: complete) |
+| `rich` | Toggle the use of the Rich UI version (restart required) |
 
-Do be warned that faster refresh rates (above superfast) cause delta calculations to drift heavily, making the general values less accurate and for the bars to jump unexpectedly.
+> [!NOTE]  
+> Fast refresh rates may cause delta calculation (for CPU cores) to drift, I've done my best to mitigate this but it's not perfect.
 
 ### Controls
 
@@ -71,8 +74,9 @@ Do be warned that faster refresh rates (above superfast) cause delta calculation
 
 Simply go to releases and download the latest installer or use the ps1 files attached, choose your options (ps1 does not support this) and you're ready to use winhtop in the terminal. Uninstalling should be easy aswell thru the installer, or the uninstall ps1 file.
 
-Small disclaimer:
-Some security vendors may block the main .exe due using the same headers as malware (this is a known pyinstaller [issue](https://github.com/pyinstaller/pyinstaller/issues/6754), i'll be looking into using a different method), but rest assured it can't do anything malicious.
+
+> [!IMPORTANT]  
+> Some security vendors may block the main .exe due using the same headers as malware (this is a known pyinstaller [issue](https://github.com/pyinstaller/pyinstaller/issues/6754), i'll be looking into using a different method), but rest assured it can't do anything malicious.
 
 ## Requirements
 
@@ -140,11 +144,11 @@ setx PATH "%PATH:;%LOCALAPPDATA%\Programs\WinHtop=%"
 
 This program (or the installer attached) is unable to:
 
-- Change registry values (apart from uninstall marking)
+- Change registry values (It makes an uninstall key from Inno setup and a DWORD for Rich configuration)
 - Sniff the network
 - Or other malicious activities
 
-It is not my responsibility if you also run `kill csrss.exe`, most important system processes are blacklisted/protected from this command though, killing the wrong process can cause system instability or you to be logged out.
-This program is provided as-is, without any warranty. Use at your own risk.
+> [!CAUTION]  
+> It is not my responsibility if you also run `kill csrss.exe`, most important system processes are blacklisted/protected from this command though, killing the wrong process can cause system instability or you to be logged out. This program is provided as-is, without any warranty. Use at your own risk.
 
 Also it may be a bit slow on some lower end systems, but it should work fine for when you need it.

Winhtop-installer.iss

@@ -3,7 +3,7 @@
 ; =========================================================
 
 #define MyAppName "WinHtop"
-#define MyAppVersion "1.1.0"
+#define MyAppVersion "1.2.0"
 #define MyAppPublisher "Iza Carlos"
 #define MyAppExeName "winhtop.exe"
 #define MyAppId "C6E2A3B4-D1F2-4EBA-BD3F-6A7C10B7B7C2"

dist.installer/WinHtopInstaller.exe

@@ -25,3 +25,29 @@
     # so for about 60 fps:
     "party": 0.0167
 }
+
+# UI Mode Toggle - stored in registry for persistence across runs
+# Uses HKEY_CURRENT_USER\Software\WinHTop\UseRichUI
+import winreg
+
+def _get_rich_ui_pref():
+    """Load USE_RICH_UI from Windows registry."""
+    try:
+        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\WinHTop", 0, winreg.KEY_READ)
+        value, _ = winreg.QueryValueEx(key, "UseRichUI")
+        winreg.CloseKey(key)
+        return bool(value)
+    except (FileNotFoundError, OSError):
+        return True  # Default to Rich UI
+
+def _set_rich_ui_pref(enabled: bool):
+    """Save USE_RICH_UI to Windows registry."""
+    try:
+        key = winreg.CreateKey(winreg.HKEY_CURRENT_USER, r"Software\WinHTop")
+        winreg.SetValueEx(key, "UseRichUI", 0, winreg.REG_DWORD, 1 if enabled else 0)
+        winreg.CloseKey(key)
+    except OSError:
+        pass  # Silently fail if can't write
+
+# Load preference on import
+USE_RICH_UI = _get_rich_ui_pref()

dist/winhtop.exe

@@ -9,6 +9,7 @@
 import msvcrt
 import psutil
 from .state import state
+from . import config
 from .config import *
 from .processes import get_process_tree_info
 try:
@@ -111,7 +112,7 @@ def execute_command(cmd_str):
         return
 
     if cmd == "help":
-        state.status_message = "kill|suspend|resume|info, sort, filter, speed, showdrives, export, quit"
+        state.status_message = "Commands: kill|suspend|resume|info, sort, filter, speed, showdrives, procfull, rich, export, quit"
         return
 
     if cmd == "showdrives":
@@ -123,6 +124,26 @@ def execute_command(cmd_str):
             state.status_message = "Showing only C: drive"
         return
 
+    if cmd == "procfull":
+        if arg.lower() == "true":
+            state.procfull_mode = True
+        elif arg.lower() == "false":
+            state.procfull_mode = False
+        else:
+            state.procfull_mode = not state.procfull_mode
+        state.scroll_offset = 0
+        if state.procfull_mode:
+            state.status_message = "Showing parent processes with aggregated children"
+        else:
+            state.status_message = "Showing all processes normally"
+        return
+    
+    if cmd == "rich":
+        config.USE_RICH_UI = not config.USE_RICH_UI
+        config._set_rich_ui_pref(config.USE_RICH_UI)  # Persist to registry
+        state.status_message = f"Rich UI: {'enabled' if config.USE_RICH_UI else 'disabled'} (takes effect on restart)"
+        return
+    
     if cmd == "speed":
         speeds = [k for k in REFRESH_RATES.keys() if k != "party"]
         key = arg.lower()
@@ -267,10 +288,19 @@ def execute_command(cmd_str):
     state.status_message = f"{action_names[cmd]} {success}, Errors: {errors}"
 
 def handle_input():
-    """Handle keyboard input (non-blocking)."""
+    """Handle keyboard input (non-blocking).
+    
+    Arrow keys and special keys send a two-byte sequence:
+    First byte: \x00 or \xe0 (prefix)
+    Second byte: key code (e.g., 72=Up, 80=Down)
+    
+    We must read the second byte immediately after detecting the prefix,
+    not wait for it to appear in a later kbhit() check.
+    """
     while msvcrt.kbhit():
         ch = msvcrt.getwch()
 
+        # Handle confirmation prompts
         if state.pending_confirmation is not None:
             if ch.lower() == 'y':
                 execute_pending_action()
@@ -282,27 +312,35 @@ def handle_input():
                 state.input_buffer = ""
                 return
             else:
+                # Consume but ignore other keys during confirmation
                 continue
 
+        # Handle special keys (arrow keys, function keys, etc.)
+        # These come as two-character sequences: \x00 or \xe0 followed by the key code
         if ch in ('\x00', '\xe0'):
-            if msvcrt.kbhit():
-                key2 = msvcrt.getwch()
-                if key2 == 'H':
-                    state.scroll_offset = max(0, state.scroll_offset - 1)
-                elif key2 == 'P': # Down
-                    state.scroll_offset += 1
-                elif key2 == 'I': # PgUp
-                    state.scroll_offset = max(0, state.scroll_offset - 10)
-                elif key2 == 'Q': # PgDn
-                    state.scroll_offset += 10
-                elif key2 == 'G': # Home
-                    state.scroll_offset = 0
-                elif key2 == 'O': # End
-                    state.scroll_offset = max(0, len(state.processes) - 5)
-                elif key2 == 'S': # Del
-                    state.input_buffer = state.input_buffer[:-1]
+            # IMMEDIATELY read the second byte - don't wait for kbhit()
+            # The second byte is always sent right after the prefix
+            key2 = msvcrt.getwch()
+            key_code = ord(key2)
+            
+            if key_code == 72:  # Up arrow
+                state.scroll_offset = max(0, state.scroll_offset - 1)
+            elif key_code == 80:  # Down arrow
+                state.scroll_offset += 1
+            elif key_code == 73:  # PgUp
+                state.scroll_offset = max(0, state.scroll_offset - 10)
+            elif key_code == 81:  # PgDn
+                state.scroll_offset += 10
+            elif key_code == 71:  # Home
+                state.scroll_offset = 0
+            elif key_code == 79:  # End
+                state.scroll_offset = max(0, len(state.processes) - 5)
+            elif key_code == 83:  # Del
+                state.input_buffer = state.input_buffer[:-1]
+            # All other special keys (F1-F12, Insert, etc.) are silently consumed
             continue
 
+        # Normal key handling
         if ch == '\r':
             execute_command(state.input_buffer)
             state.input_buffer = ""

modules/config.py

@@ -69,6 +69,7 @@ def get_processes():
 
         pinfo = {
             'pid': pid,
+            'ppid': p.get('ppid', 0),  # For procfull aggregation
             'name': p['name'],
             'cpu_percent': p['cpu_percent'],
             'memory_percent': mem_pct,
@@ -78,6 +79,10 @@ def get_processes():
 
         procs.append(pinfo)
 
+    # Aggregate children into parents if procfull_mode is enabled
+    if state.procfull_mode:
+        procs = aggregate_children(procs)
+    
     # Sort
     try:
         if state.sort_key == 'name':
@@ -87,6 +92,64 @@ def get_processes():
     except:
         state.processes = procs
 
+
+def aggregate_children(proc_list):
+    """When procfull_mode is True, aggregate DIRECT child stats into parent entries.
+    
+    This groups processes by their parent, sums CPU/MEM of DIRECT children only
+    into the parent, and marks parents with a child count indicator.
+    
+    Note: Only direct children are aggregated, not all descendants recursively.
+    This matches typical task manager behavior where e.g., chrome.exe shows
+    its immediate child processes, not the entire tree.
+    """
+    # Build a pid -> process info map
+    pid_map = {p['pid']: p for p in proc_list}
+    
+    # Build parent -> direct children map
+    children_map = {}  # parent_pid -> [child_pinfo, ...]
+    child_pids = set()  # Track which pids are children (to exclude from result)
+    
+    for p in proc_list:
+        ppid = p.get('ppid', 0)
+        # Only consider as child if parent exists in our list and isn't self
+        if ppid in pid_map and ppid != p['pid']:
+            if ppid not in children_map:
+                children_map[ppid] = []
+            children_map[ppid].append(p)
+            child_pids.add(p['pid'])
+    
+    # Build result: only parent processes (those not appearing as children)
+    # or processes with no parent in the list
+    aggregated = []
+    
+    for p in proc_list:
+        pid = p['pid']
+        
+        # Skip processes that are children of another process in the list
+        if pid in child_pids:
+            continue
+        
+        # Get direct children of this process
+        direct_children = children_map.get(pid, [])
+        
+        if direct_children:
+            # Aggregate direct children stats
+            child_cpu = sum(c.get('cpu_percent', 0) for c in direct_children)
+            child_mem = sum(c.get('memory_percent', 0) for c in direct_children)
+            
+            agg_entry = p.copy()
+            agg_entry['cpu_percent'] = p.get('cpu_percent', 0) + child_cpu
+            agg_entry['memory_percent'] = p.get('memory_percent', 0) + child_mem
+            agg_entry['_child_count'] = len(direct_children)
+            aggregated.append(agg_entry)
+        else:
+            # No children, just add as-is
+            aggregated.append(p)
+    
+    return aggregated
+
+
 def get_process_tree_info(targets):
     """Build process tree info showing parent-child relationships."""
     tree_lines = []