ngpt 3.8.1__py3-none-any.whl → 3.8.3__py3-none-any.whl

ngpt/cli/modes/chat.py

@@ -1,5 +1,5 @@
 from ..formatters import COLORS
-from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..renderers import prettify_markdown, prettify_streaming_markdown, TERMINAL_RENDER_LOCK
 from ..ui import spinner
 from ...utils import enhance_prompt_with_web_search, process_piped_input
 import sys
@@ -53,9 +53,10 @@ def chat_mode(client, args, logger=None):
                 stop_spinner.set()
                 spinner_thread.join()
                 # Clear the spinner line completely
-                sys.stdout.write("\r" + " " * 100 + "\r")
-                sys.stdout.flush()
-                print("Enhanced input with web search results.")
+                with TERMINAL_RENDER_LOCK:
+                    sys.stdout.write("\r" + " " * 100 + "\r")
+                    sys.stdout.flush()
+                    print("Enhanced input with web search results.")
             except Exception as e:
                 # Stop the spinner before re-raising
                 stop_spinner.set()
@@ -129,11 +130,14 @@ def chat_mode(client, args, logger=None):
         # On first content, stop the spinner 
         if not first_content_received and stop_spinner_func:
             first_content_received = True
-            # Stop the spinner
-            stop_spinner_func()
-            # Ensure spinner message is cleared with an extra blank line
-            sys.stdout.write("\r" + " " * 100 + "\r")
-            sys.stdout.flush()
+            
+            # Use lock to prevent terminal rendering conflicts
+            with TERMINAL_RENDER_LOCK:
+                # Stop the spinner
+                stop_spinner_func()
+                # Ensure spinner message is cleared with an extra blank line
+                sys.stdout.write("\r" + " " * 100 + "\r")
+                sys.stdout.flush()
         
         # Call the original callback to update the display
         if original_callback:
@@ -165,7 +169,8 @@ def chat_mode(client, args, logger=None):
         
     # Handle non-stream response or regular prettify
     if (args.no_stream or args.prettify) and response:
-        if args.prettify:
-            prettify_markdown(response, args.renderer)
-        else:
-            print(response) 
+        with TERMINAL_RENDER_LOCK:
+            if args.prettify:
+                prettify_markdown(response, args.renderer)
+            else:
+                print(response) 

ngpt/cli/modes/code.py

@@ -1,5 +1,5 @@
 from ..formatters import COLORS
-from ..renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer, show_available_renderers
+from ..renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer, show_available_renderers, TERMINAL_RENDER_LOCK
 from ..ui import spinner, copy_to_clipboard
 from ...utils import enhance_prompt_with_web_search, process_piped_input
 import sys
@@ -126,9 +126,10 @@ def code_mode(client, args, logger=None):
                 stop_spinner.set()
                 spinner_thread.join()
                 # Clear the spinner line completely
-                sys.stdout.write("\r" + " " * 100 + "\r")
-                sys.stdout.flush()
-                print("Enhanced input with web search results.")
+                with TERMINAL_RENDER_LOCK:
+                    sys.stdout.write("\r" + " " * 100 + "\r")
+                    sys.stdout.flush()
+                    print("Enhanced input with web search results.")
             except Exception as e:
                 # Stop the spinner before re-raising
                 stop_spinner.set()
@@ -211,11 +212,14 @@ def code_mode(client, args, logger=None):
         # On first content, stop the spinner 
         if not first_content_received and stop_spinner_func:
             first_content_received = True
-            # Stop the spinner
-            stop_spinner_func()
-            # Ensure spinner message is cleared with an extra blank line
-            sys.stdout.write("\r" + " " * 100 + "\r")
-            sys.stdout.flush()
+            
+            # Use lock to prevent terminal rendering conflicts
+            with TERMINAL_RENDER_LOCK:
+                # Stop the spinner
+                stop_spinner_func()
+                # Ensure spinner message is cleared with an extra blank line
+                sys.stdout.write("\r" + " " * 100 + "\r")
+                sys.stdout.flush()
         
         # Call the original callback to update the display
         if original_callback:
@@ -297,12 +301,13 @@ def code_mode(client, args, logger=None):
         
     # Print non-streamed output if needed
     if generated_code and not should_stream:
-        if use_regular_prettify:
-            print("\nGenerated code:")
-            prettify_markdown(generated_code, args.renderer)
-        else:
-            # Should only happen if --no-stream was used without prettify
-            print(f"\nGenerated code:\n{generated_code}") 
+        with TERMINAL_RENDER_LOCK:
+            if use_regular_prettify:
+                print("\nGenerated code:")
+                prettify_markdown(generated_code, args.renderer)
+            else:
+                # Should only happen if --no-stream was used without prettify
+                print(f"\nGenerated code:\n{generated_code}")
             
     # Offer to copy to clipboard
     if generated_code and not args.no_stream:

ngpt/cli/modes/interactive.py

@@ -5,7 +5,7 @@ import threading
 import sys
 import time
 from ..formatters import COLORS
-from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..renderers import prettify_markdown, prettify_streaming_markdown, TERMINAL_RENDER_LOCK
 from ..ui import spinner
 from ...utils import enhance_prompt_with_web_search
 
@@ -78,8 +78,9 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
     def print_separator():
         # Make sure there's exactly one newline before and after
         # Use sys.stdout.write for direct control, avoiding any extra newlines
-        sys.stdout.write(f"\n{separator}\n")
-        sys.stdout.flush()
+        with TERMINAL_RENDER_LOCK:
+            sys.stdout.write(f"\n{separator}\n")
+            sys.stdout.flush()
     
     # Initialize conversation history
     system_prompt = preprompt if preprompt else "You are a helpful assistant."
@@ -111,35 +112,37 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
     
     # Function to display conversation history
     def display_history():
-        if len(conversation) <= 1:  # Only system message
-            print(f"\n{COLORS['yellow']}No conversation history yet.{COLORS['reset']}")
-            return
-            
-        print(f"\n{COLORS['cyan']}{COLORS['bold']}Conversation History:{COLORS['reset']}")
-        print(separator)
-        
-        # Skip system message
-        message_count = 0
-        for i, msg in enumerate(conversation):
-            if msg["role"] == "system":
-                continue
+        with TERMINAL_RENDER_LOCK:
+            if len(conversation) <= 1:  # Only system message
+                print(f"\n{COLORS['yellow']}No conversation history yet.{COLORS['reset']}")
+                return
                 
-            if msg["role"] == "user":
-                message_count += 1
-                print(f"\n{user_header()}")
-                print(f"{COLORS['cyan']}│ [{message_count}] {COLORS['reset']}{msg['content']}")
-            elif msg["role"] == "assistant":
-                print(f"\n{ngpt_header()}")
-                print(f"{COLORS['green']}│ {COLORS['reset']}{msg['content']}")
-        
-        print(f"\n{separator}")  # Consistent separator at the end
+            print(f"\n{COLORS['cyan']}{COLORS['bold']}Conversation History:{COLORS['reset']}")
+            print(separator)
+            
+            # Skip system message
+            message_count = 0
+            for i, msg in enumerate(conversation):
+                if msg["role"] == "system":
+                    continue
+                    
+                if msg["role"] == "user":
+                    message_count += 1
+                    print(f"\n{user_header()}")
+                    print(f"{COLORS['cyan']}│ [{message_count}] {COLORS['reset']}{msg['content']}")
+                elif msg["role"] == "assistant":
+                    print(f"\n{ngpt_header()}")
+                    print(f"{COLORS['green']}│ {COLORS['reset']}{msg['content']}")
+            
+            print(f"\n{separator}")  # Consistent separator at the end
     
     # Function to clear conversation history
     def clear_history():
         nonlocal conversation
         conversation = [{"role": "system", "content": system_prompt}]
-        print(f"\n{COLORS['yellow']}Conversation history cleared.{COLORS['reset']}")
-        print(separator)  # Add separator for consistency
+        with TERMINAL_RENDER_LOCK:
+            print(f"\n{COLORS['yellow']}Conversation history cleared.{COLORS['reset']}")
+            print(separator)  # Add separator for consistency
     
     try:
         while True:
@@ -249,10 +252,11 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
 
             # Print the header if needed
             if should_print_header:
-                if not no_stream and not stream_prettify:
-                    print(f"\n{ngpt_header()}: {COLORS['reset']}", end="", flush=True)
-                elif not stream_prettify:
-                    print(f"\n{ngpt_header()}: {COLORS['reset']}", flush=True)
+                with TERMINAL_RENDER_LOCK:
+                    if not no_stream and not stream_prettify:
+                        print(f"\n{ngpt_header()}: {COLORS['reset']}", end="", flush=True)
+                    elif not stream_prettify:
+                        print(f"\n{ngpt_header()}: {COLORS['reset']}", flush=True)
             
             # Determine streaming behavior
             if prettify and not no_stream and not stream_prettify:
@@ -294,18 +298,20 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
                         if not first_content_received:
                             first_content_received = True
                             
-                            # Stop the spinner if it's running
-                            if stop_spinner_func:
-                                stop_spinner_func()
+                            # Use lock to prevent terminal rendering conflicts
+                            with TERMINAL_RENDER_LOCK:
+                                # Stop the spinner if it's running
+                                if stop_spinner_func:
+                                    stop_spinner_func()
+                                    
+                                # Clear the spinner line completely without leaving extra newlines
+                                # Use direct terminal control to ensure consistency
+                                sys.stdout.write("\r" + " " * shutil.get_terminal_size().columns + "\r")
+                                sys.stdout.flush()
                                 
-                            # Clear the spinner line completely without leaving extra newlines
-                            # Use direct terminal control to ensure consistency
-                            sys.stdout.write("\r" + " " * shutil.get_terminal_size().columns + "\r")
-                            sys.stdout.flush()
-                            
-                            # Now start the live display
-                            if live_display:
-                                live_display.start()
+                                # Now start the live display
+                                if live_display:
+                                    live_display.start()
                         
                         # Call the original callback to update content
                         if original_callback:
@@ -351,11 +357,12 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
                 
                 # Print response if not streamed (either due to no_stream or prettify)
                 if no_stream or prettify:
-                    if prettify:
-                        # For pretty formatting with rich, don't print any header text as the rich renderer already includes it
-                        prettify_markdown(response, renderer)
-                    else:
-                        print(response)
+                    with TERMINAL_RENDER_LOCK:
+                        if prettify:
+                            # For pretty formatting with rich, don't print any header text as the rich renderer already includes it
+                            prettify_markdown(response, renderer)
+                        else:
+                            print(response)
                 
                 # Log AI response if logging is enabled
                 if logger:

ngpt/cli/modes/rewrite.py

@@ -2,7 +2,7 @@ import sys
 import threading
 import time
 from ..formatters import COLORS
-from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..renderers import prettify_markdown, prettify_streaming_markdown, TERMINAL_RENDER_LOCK
 from ..ui import get_multiline_input, spinner, copy_to_clipboard
 from ...utils import enhance_prompt_with_web_search, process_piped_input
 
@@ -127,9 +127,10 @@ def rewrite_mode(client, args, logger=None):
                 stop_spinner.set()
                 spinner_thread.join()
                 # Clear the spinner line completely
-                sys.stdout.write("\r" + " " * 100 + "\r")
-                sys.stdout.flush()
-                print("Enhanced input with web search results.")
+                with TERMINAL_RENDER_LOCK:
+                    sys.stdout.write("\r" + " " * 100 + "\r")
+                    sys.stdout.flush()
+                    print("Enhanced input with web search results.")
             except Exception as e:
                 # Stop the spinner before re-raising
                 stop_spinner.set()
@@ -197,11 +198,14 @@ def rewrite_mode(client, args, logger=None):
         # On first content, stop the spinner 
         if not first_content_received and stop_spinner_func:
             first_content_received = True
-            # Stop the spinner
-            stop_spinner_func()
-            # Ensure spinner message is cleared with an extra blank line
-            sys.stdout.write("\r" + " " * 100 + "\r\n")
-            sys.stdout.flush()
+            
+            # Use lock to prevent terminal rendering conflicts
+            with TERMINAL_RENDER_LOCK:
+                # Stop the spinner
+                stop_spinner_func()
+                # Ensure spinner message is cleared with an extra blank line
+                sys.stdout.write("\r" + " " * 100 + "\r\n")
+                sys.stdout.flush()
         
         # Call the original callback to update the display
         if original_callback:
@@ -241,10 +245,11 @@ def rewrite_mode(client, args, logger=None):
         
     # Handle non-stream response or regular prettify
     if (args.no_stream or args.prettify) and response:
-        if args.prettify:
-            prettify_markdown(response, args.renderer)
-        else:
-            print(response)
+        with TERMINAL_RENDER_LOCK:
+            if args.prettify:
+                prettify_markdown(response, args.renderer)
+            else:
+                print(response)
             
     # Offer to copy to clipboard if not in a redirected output
     if not args.no_stream and response:

ngpt/cli/modes/shell.py

@@ -1,6 +1,6 @@
 from ..formatters import COLORS
 from ..ui import spinner, copy_to_clipboard, get_terminal_input
-from ..renderers import prettify_markdown, has_markdown_renderer, prettify_streaming_markdown, show_available_renderers
+from ..renderers import prettify_markdown, has_markdown_renderer, prettify_streaming_markdown, show_available_renderers, TERMINAL_RENDER_LOCK
 from ...utils import enhance_prompt_with_web_search, process_piped_input
 import subprocess
 import sys
@@ -14,6 +14,9 @@ import time
 # System prompt for shell command generation
 SHELL_SYSTEM_PROMPT = """Your role: Provide only plain text without Markdown formatting. Do not show any warnings or information regarding your capabilities. Do not provide any description. If you need to store any data, assume it will be stored in the chat. Provide only {shell_name} command for {operating_system} without any description. If there is a lack of details, provide most logical solution. Ensure the output is a valid shell command. If multiple steps required try to combine them together.
 
+*** SHELL TYPE: {shell_name} ***
+*** OS: {operating_system} ***
+
 Command:"""
 
 # System prompt to use when preprompt is provided
@@ -34,16 +37,18 @@ If the preprompt contradicts ANY OTHER instruction in this prompt,
 including the {operating_system}/{shell_name} specification below,
 YOU MUST FOLLOW THE PREPROMPT INSTRUCTION INSTEAD. NO EXCEPTIONS.
 
+*** SHELL TYPE: {shell_name} ***
+*** OS: {operating_system} ***
+
 Your role: Provide only plain text without Markdown formatting. Do not show any warnings or information regarding your capabilities. Do not provide any description. If you need to store any data, assume it will be stored in the chat. Provide only {shell_name} command for {operating_system} without any description. If there is a lack of details, provide most logical solution. Ensure the output is a valid shell command. If multiple steps required try to combine them together.
 
 Command:"""
 
-def detect_shell():
-    """Detect the current shell type and OS more accurately.
+def detect_os():
+    """Detect the current operating system with detailed information.
     
     Returns:
-        tuple: (shell_name, highlight_language, operating_system) - the detected shell name,
-               appropriate syntax highlighting language, and operating system
+        tuple: (os_type, operating_system) - the basic OS type and detailed OS description
     """
     os_type = platform.system()
     
@@ -73,60 +78,322 @@ def detect_shell():
     except:
         pass
         
-    # Try to detect the shell by examining environment variables
+    return os_type, operating_system, is_wsl
+
+
+def detect_gitbash_shell(operating_system):
+    """Detect if we're running in a Git Bash / MINGW environment.
+    
+    Args:
+        operating_system: The detected operating system string
+        
+    Returns:
+        tuple or None: (shell_name, highlight_language, operating_system) if Git Bash detected,
+                       None otherwise
+    """
+    # Check for Git Bash / MINGW environments 
+    if any(env_var in os.environ for env_var in ["MSYSTEM", "MINGW_PREFIX"]):
+        # We're definitely in a MINGW environment (Git Bash)
+        return "bash", "bash", operating_system
+        
+    if "MSYSTEM" in os.environ and any(msys_type in os.environ.get("MSYSTEM", "") 
+                                      for msys_type in ["MINGW", "MSYS"]):
+        return "bash", "bash", operating_system
+        
+    # Check command PATH for mingw
+    if os.environ.get("PATH") and any(
+            mingw_pattern in path.lower() 
+            for mingw_pattern in ["/mingw/", "\\mingw\\", "/usr/bin", "\\usr\\bin"] 
+            for path in os.environ.get("PATH", "").split(os.pathsep)
+    ):
+        return "bash", "bash", operating_system
+        
+    return None
+
+
+def detect_unix_shell(operating_system):
+    """Detect shell type on Unix-like systems (Linux, macOS, BSD).
+    
+    Args:
+        operating_system: The detected operating system string
+        
+    Returns:
+        tuple: (shell_name, highlight_language, operating_system) - the detected shell information
+    """
+    # Try multiple methods to detect the shell
+    
+    # Method 1: Check shell-specific environment variables
+    # These are very reliable indicators of the actual shell
+    if "BASH_VERSION" in os.environ:
+        return "bash", "bash", operating_system
+        
+    if "ZSH_VERSION" in os.environ:
+        return "zsh", "zsh", operating_system
+        
+    if "FISH_VERSION" in os.environ:
+        return "fish", "fish", operating_system
+    
+    # Method 2: Try to get shell from process information
     try:
-        # Check for specific shell by examining SHELL_NAME or equivalent
-        if os_type == "Windows" and not is_wsl:
-            # Check for Git Bash or MSYS2/Cygwin
-            if "MINGW" in os.environ.get("MSYSTEM", "") or "MSYS" in os.environ.get("MSYSTEM", ""):
-                return "bash", "bash", operating_system
+        # Try to get parent process name using ps command
+        current_pid = os.getpid()
+        parent_pid = os.getppid()
+        
+        # Method 2a: Try to get the parent process command line from /proc
+        try:
+            with open(f'/proc/{parent_pid}/cmdline', 'r') as f:
+                cmdline = f.read().split('\0')
+                if cmdline and cmdline[0]:
+                    cmd = os.path.basename(cmdline[0])
+                    if "zsh" in cmd:
+                        return "zsh", "zsh", operating_system
+                    elif "bash" in cmd:
+                        return "bash", "bash", operating_system
+                    elif "fish" in cmd:
+                        return "fish", "fish", operating_system
+        except:
+            pass
+        
+        # Method 2b: Try using ps command with different formats
+        for fmt in ["comm=", "command=", "args="]:
+            try:
+                ps_cmd = ["ps", "-p", str(parent_pid), "-o", fmt]
+                result = subprocess.run(ps_cmd, capture_output=True, text=True)
+                process_info = result.stdout.strip()
                 
-            # Check if we're in Git Bash by examining PATH for /mingw/
-            if any("/mingw/" in path.lower() for path in os.environ.get("PATH", "").split(os.pathsep)):
-                return "bash", "bash", operating_system
+                if process_info:
+                    if "zsh" in process_info.lower():
+                        return "zsh", "zsh", operating_system
+                    elif "bash" in process_info.lower():
+                        return "bash", "bash", operating_system
+                    elif "fish" in process_info.lower():
+                        return "fish", "fish", operating_system
+                    elif any(sh in process_info.lower() for sh in ["csh", "tcsh"]):
+                        shell_name = "csh" if "csh" in process_info.lower() else "tcsh"
+                        return shell_name, "csh", operating_system
+                    elif "ksh" in process_info.lower():
+                        return "ksh", "ksh", operating_system
+            except:
+                continue
+        
+        # Method 2c: Try to find parent shell by traversing process hierarchy
+        # This handles Python wrappers, uv run, etc.
+        for _ in range(5):  # Check up to 5 levels up the process tree
+            try:
+                # Try to get process command
+                ps_cmd = ["ps", "-p", str(parent_pid), "-o", "comm="]
+                result = subprocess.run(ps_cmd, capture_output=True, text=True)
+                process_name = result.stdout.strip()
+                
+                # If it's a known shell, return it
+                if process_name:
+                    process_basename = os.path.basename(process_name)
+                    if "bash" in process_basename:
+                        return "bash", "bash", operating_system
+                    elif "zsh" in process_basename:
+                        return "zsh", "zsh", operating_system
+                    elif "fish" in process_basename:
+                        return "fish", "fish", operating_system
+                    elif any(sh in process_basename for sh in ["csh", "tcsh"]):
+                        return process_basename, "csh", operating_system
+                    elif "ksh" in process_basename:
+                        return process_basename, "ksh", operating_system
                 
-            # Check for WSL within Windows
-            if "WSL" in os.environ.get("PATH", "") or "Microsoft" in os.environ.get("PATH", ""):
+                # Check if we've reached init/systemd (PID 1)
+                if parent_pid <= 1:
+                    break
+                    
+                # Move up to next parent
+                try:
+                    # Get the parent of our current parent
+                    with open(f'/proc/{parent_pid}/status', 'r') as f:
+                        for line in f:
+                            if line.startswith('PPid:'):
+                                parent_pid = int(line.split()[1])
+                                break
+                except:
+                    break  # Can't determine next parent, stop here
+            except:
+                break
+    except:
+        # Process detection failed, continue with other methods
+        pass
+        
+    # Method 3: Try running a command that prints info about the parent shell
+    try:
+        # Get parent's process ID and use it to get more info
+        cmd = f"ps -p $PPID -o cmd="
+        result = subprocess.run(['bash', '-c', cmd], capture_output=True, text=True, timeout=1)
+        parent_cmd = result.stdout.strip()
+        
+        if "zsh" in parent_cmd.lower():
+            return "zsh", "zsh", operating_system
+        elif "bash" in parent_cmd.lower():
+            return "bash", "bash", operating_system
+        elif "fish" in parent_cmd.lower():
+            return "fish", "fish", operating_system
+    except:
+        pass
+    
+    # Method 4: Check for shell-specific environment variables beyond the basic ones
+    try:
+        for env_var in os.environ:
+            if env_var.startswith("BASH_"):
                 return "bash", "bash", operating_system
+            elif env_var.startswith("ZSH_"):
+                return "zsh", "zsh", operating_system
+            elif env_var.startswith("FISH_"):
+                return "fish", "fish", operating_system
+    except:
+        pass
+    
+    # Method 5: Check SHELL environment variable 
+    if os.environ.get("SHELL"):
+        shell_path = os.environ.get("SHELL")
+        shell_name = os.path.basename(shell_path)
+        
+        # Match against known shell types - use exact matches first
+        if shell_name == "zsh":
+            return "zsh", "zsh", operating_system
+        elif shell_name == "bash":
+            return "bash", "bash", operating_system
+        elif shell_name == "fish":
+            return "fish", "fish", operating_system
+        elif shell_name in ["csh", "tcsh"]:
+            return shell_name, "csh", operating_system
+        elif shell_name == "ksh":
+            return shell_name, "ksh", operating_system
             
-            # Check for explicit shell path in environment
-            if os.environ.get("SHELL"):
-                shell_path = os.environ.get("SHELL").lower()
-                if "bash" in shell_path:
-                    return "bash", "bash", operating_system
-                elif "zsh" in shell_path:
-                    return "zsh", "zsh", operating_system
-                elif "powershell" in shell_path:
-                    return "powershell.exe", "powershell", operating_system
-                elif "cmd" in shell_path:
+        # If no exact match, try substring
+        if "zsh" in shell_name:
+            return "zsh", "zsh", operating_system
+        elif "bash" in shell_name:
+            return "bash", "bash", operating_system
+        elif "fish" in shell_name:
+            return "fish", "fish", operating_system
+        elif any(sh in shell_name for sh in ["csh", "tcsh"]):
+            return shell_name, "csh", operating_system
+        elif "ksh" in shell_name:
+            return shell_name, "ksh", operating_system
+    
+    # Fallback: default to bash for Unix-like systems if all else fails
+    return "bash", "bash", operating_system
+
+
+def detect_windows_shell(operating_system):
+    """Detect shell type on Windows systems.
+    
+    Args:
+        operating_system: The detected operating system string
+        
+    Returns:
+        tuple: (shell_name, highlight_language, operating_system) - the detected shell information
+    """
+    # First check for the process name - most reliable indicator
+    try:
+        # Check parent process name for the most accurate detection
+        if os.name == 'nt':
+            import ctypes
+            from ctypes import wintypes
+
+            # Get parent process ID
+            GetCurrentProcessId = ctypes.windll.kernel32.GetCurrentProcessId
+            GetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess
+            GetProcessTimes = ctypes.windll.kernel32.GetProcessTimes
+            OpenProcess = ctypes.windll.kernel32.OpenProcess
+            GetModuleFileNameEx = ctypes.windll.psapi.GetModuleFileNameExW
+            QueryFullProcessImageName = ctypes.windll.kernel32.QueryFullProcessImageNameW
+            CloseHandle = ctypes.windll.kernel32.CloseHandle
+            
+            # Try to get process path
+            try:
+                # First try to check current process executable name
+                process_path = sys.executable.lower()
+                if "powershell" in process_path:
+                    if "pwsh" in process_path:
+                        return "pwsh", "powershell", operating_system
+                    else:
+                        return "powershell.exe", "powershell", operating_system
+                elif "cmd.exe" in process_path:
                     return "cmd.exe", "batch", operating_system
-                    
-            # Check for PowerShell vs CMD
+            except Exception as e:
+                pass
+            
+            # If that fails, check environment variables that strongly indicate shell type
+            if "PROMPT" in os.environ and "$P$G" in os.environ.get("PROMPT", ""):
+                # CMD.exe uses $P$G as default prompt
+                return "cmd.exe", "batch", operating_system
+            
             if os.environ.get("PSModulePath"):
-                # Further distinguish PowerShell vs PowerShell Core
+                # PowerShell has this environment variable
                 if "pwsh" in os.environ.get("PSModulePath", "").lower():
                     return "pwsh", "powershell", operating_system
                 else:
                     return "powershell.exe", "powershell", operating_system
-            else:
-                return "cmd.exe", "batch", operating_system
+    except Exception as e:
+        # If process detection fails, continue with environment checks
+        pass
+    
+    # Check for WSL within Windows
+    if any(("wsl" in path.lower() or "microsoft" in path.lower()) for path in os.environ.get("PATH", "").split(os.pathsep)):
+        return "bash", "bash", operating_system
+    
+    # Check for explicit shell path in environment
+    if os.environ.get("SHELL"):
+        shell_path = os.environ.get("SHELL").lower()
+        if "bash" in shell_path:
+            return "bash", "bash", operating_system
+        elif "zsh" in shell_path:
+            return "zsh", "zsh", operating_system
+        elif "powershell" in shell_path:
+            return "powershell.exe", "powershell", operating_system
+        elif "cmd" in shell_path:
+            return "cmd.exe", "batch", operating_system
+    
+    # Final fallback - Check common environment variables that indicate shell type
+    if "ComSpec" in os.environ:
+        comspec = os.environ.get("ComSpec", "").lower()
+        if "powershell" in comspec:
+            return "powershell.exe", "powershell", operating_system
+        elif "cmd.exe" in comspec:
+            return "cmd.exe", "batch", operating_system
+    
+    # Last resort fallback to PowerShell (most common modern Windows shell)
+    return "powershell.exe", "powershell", operating_system
+
+
+def detect_shell():
+    """Detect the current shell type and OS more accurately.
+    
+    Returns:
+        tuple: (shell_name, highlight_language, operating_system) - the detected shell name,
+               appropriate syntax highlighting language, and operating system
+    """
+    try:
+        # First detect the OS
+        os_type, operating_system, is_wsl = detect_os()
+        
+        # Use the appropriate detection method based on OS
+        if os_type in ["Linux", "Darwin", "FreeBSD"] or is_wsl:
+            return detect_unix_shell(operating_system)
+        elif os_type == "Windows":
+            # On Windows, first check for Git Bash / MINGW environment
+            gitbash_result = detect_gitbash_shell(operating_system)
+            if gitbash_result:
+                return gitbash_result
+                
+            # If not Git Bash, use regular Windows shell detection
+            return detect_windows_shell(operating_system)
         else:
-            # Unix-like systems - try to get more specific
-            shell_path = os.environ.get("SHELL", "/bin/bash")
-            shell_name = os.path.basename(shell_path)
-            
-            # Map shell name to syntax highlight language
-            if shell_name == "zsh":
-                return shell_name, "zsh", operating_system
-            elif shell_name == "fish":
-                return shell_name, "fish", operating_system
-            elif "csh" in shell_name:
-                return shell_name, "csh", operating_system
+            # Fallback for unknown OS types
+            if os_type == "Windows":
+                return "powershell.exe", "powershell", operating_system
             else:
-                # Default to bash for sh, bash, and other shells
-                return shell_name, "bash", operating_system
+                return "bash", "bash", operating_system
     except Exception as e:
         # Fall back to simple detection if anything fails
+        os_type = platform.system()
+        operating_system = os_type
         if os_type == "Windows":
             return "powershell.exe", "powershell", operating_system
         else:
@@ -172,7 +439,7 @@ def setup_streaming(args, logger=None):
     elif args.no_stream:
         # Second priority: no-stream
         should_stream = False
-        use_regular_prettify = False # No prettify if no streaming
+        use_regular_prettify = False  # No prettify if no streaming
     elif args.prettify:
         # Third priority: prettify (requires disabling stream)
         if has_markdown_renderer(args.renderer):
@@ -240,8 +507,8 @@ def setup_streaming(args, logger=None):
     return (should_stream, use_stream_prettify, use_regular_prettify, stream_setup)
 
 def generate_with_model(client, prompt, messages, args, stream_setup, 
-                       use_stream_prettify, should_stream, spinner_message="Generating...", 
-                       temp_override=None, logger=None):
+                         use_stream_prettify, should_stream, spinner_message="Generating...",
+                         temp_override=None, logger=None):
     """Generate content using the model with proper streaming and spinner handling.
     
     Args:
@@ -529,19 +796,21 @@ def shell_mode(client, args, logger=None):
     ]
     prompt_text = f"\nWhat would you like to do? [{COLORS['cyan']}C{COLORS['reset']}/{COLORS['cyan']}E{COLORS['reset']}/{COLORS['cyan']}D{COLORS['reset']}/{COLORS['cyan']}A{COLORS['reset']}] "
 
-    # Print options with proper flushing to ensure display
-    print(options_text, flush=True)
-    for option in options:
-        print(option, flush=True)
-
-    # Add a small delay to ensure terminal rendering is complete,
-    # especially important for stream-prettify mode
-    if use_stream_prettify:
-        time.sleep(0.2)
+    # Make sure box rendering is complete before showing options
+    with TERMINAL_RENDER_LOCK:
+        # Add a small delay to ensure terminal rendering is complete,
+        # especially important for stream-prettify mode
+        if use_stream_prettify:
+            time.sleep(0.5)
+            
+        # Print options with proper flushing to ensure display
+        print(options_text, flush=True)
+        for option in options:
+            print(option, flush=True)
 
-    # Print prompt and flush to ensure it appears
-    sys.stdout.write(prompt_text)
-    sys.stdout.flush()
+        # Print prompt and flush to ensure it appears
+        sys.stdout.write(prompt_text)
+        sys.stdout.flush()
     
     try:
         # Use get_terminal_input which opens /dev/tty directly rather than using stdin
@@ -550,9 +819,9 @@ def shell_mode(client, args, logger=None):
         if response:
             response = response.lower()
         else:
-            # If get_terminal_input fails, default to copy
-            print("\nFailed to get terminal input. Defaulting to copy option.")
-            response = 'c'
+            # If get_terminal_input fails, default to abort
+            print("\nFailed to get terminal input. Defaulting to abort option.")
+            response = 'a'
     except KeyboardInterrupt:
         print("\nCommand execution cancelled by user.")
         return
@@ -565,7 +834,21 @@ def shell_mode(client, args, logger=None):
         try:
             try:
                 print("\nExecuting command... (Press Ctrl+C to cancel)")
-                result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+                
+                # Special handling for Windows PowerShell commands
+                if shell_name in ["powershell.exe", "pwsh"] and platform.system() == "Windows":
+                    # Execute PowerShell commands properly on Windows
+                    result = subprocess.run(
+                        ["powershell.exe", "-Command", command], 
+                        shell=True, 
+                        check=True, 
+                        capture_output=True, 
+                        text=True
+                    )
+                else:
+                    # Regular command execution for other shells
+                    result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+                    
                 output = result.stdout
                 
                 # Log the command output if logging is enabled

ngpt/cli/modes/text.py

@@ -1,5 +1,5 @@
 from ..formatters import COLORS
-from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..renderers import prettify_markdown, prettify_streaming_markdown, TERMINAL_RENDER_LOCK
 from ..ui import get_multiline_input, spinner
 from ...utils import enhance_prompt_with_web_search
 import threading
@@ -47,9 +47,10 @@ def text_mode(client, args, logger=None):
                 stop_spinner.set()
                 spinner_thread.join()
                 # Clear the spinner line completely
-                sys.stdout.write("\r" + " " * 100 + "\r")
-                sys.stdout.flush()
-                print("Enhanced input with web search results.")
+                with TERMINAL_RENDER_LOCK:
+                    sys.stdout.write("\r" + " " * 100 + "\r")
+                    sys.stdout.flush()
+                    print("Enhanced input with web search results.")
             except Exception as e:
                 # Stop the spinner before re-raising
                 stop_spinner.set()
@@ -119,11 +120,14 @@ def text_mode(client, args, logger=None):
         # On first content, stop the spinner 
         if not first_content_received and stop_spinner_func:
             first_content_received = True
-            # Stop the spinner
-            stop_spinner_func()
-            # Ensure spinner message is cleared with an extra blank line
-            sys.stdout.write("\r" + " " * 100 + "\r")
-            sys.stdout.flush()
+            
+            # Use lock to prevent terminal rendering conflicts
+            with TERMINAL_RENDER_LOCK:
+                # Stop the spinner
+                stop_spinner_func()
+                # Ensure spinner message is cleared with an extra blank line
+                sys.stdout.write("\r" + " " * 100 + "\r")
+                sys.stdout.flush()
         
         # Call the original callback to update the display
         if original_callback:
@@ -155,7 +159,8 @@ def text_mode(client, args, logger=None):
         
     # Handle non-stream response or regular prettify
     if (args.no_stream or args.prettify) and response:
-        if args.prettify:
-            prettify_markdown(response, args.renderer)
-        else:
-            print(response) 
+        with TERMINAL_RENDER_LOCK:
+            if args.prettify:
+                prettify_markdown(response, args.renderer)
+            else:
+                print(response)

ngpt/cli/renderers.py

@@ -3,8 +3,12 @@ import shutil
 import subprocess
 import tempfile
 import sys
+import threading
 from .formatters import COLORS
 
+# Global lock for terminal rendering to prevent race conditions
+TERMINAL_RENDER_LOCK = threading.Lock()
+
 # Try to import markdown rendering libraries
 try:
     import rich
@@ -308,63 +312,65 @@ def prettify_streaming_markdown(renderer='rich', is_interactive=False, header_te
             # Check if this is the final update (complete flag)
             is_complete = kwargs.get('complete', False)
             
-            # Start live display on first content
-            if first_update:
-                first_update = False
-                # Let the spinner's clean_exit handle the cleanup
-                # No additional cleanup needed here
-                live.start()
-            
-            # Update content in live display
-            if is_interactive and header_text:
-                # Update the panel content - for streaming, only show the last portion that fits in display_height
-                if not is_complete:
-                    # Calculate approximate lines needed (rough estimation)
-                    content_lines = content.count('\n') + 1
-                    available_height = display_height - 4  # Account for panel borders and padding
-                    
-                    if content_lines > available_height:
-                        # If content is too big, show only the last part that fits
-                        lines = content.split('\n')
-                        truncated_content = '\n'.join(lines[-available_height:])
-                        md_obj.renderable = Markdown(truncated_content)
+            # Use lock to prevent terminal rendering conflicts
+            with TERMINAL_RENDER_LOCK:
+                # Start live display on first content
+                if first_update:
+                    first_update = False
+                    # Let the spinner's clean_exit handle the cleanup
+                    # No additional cleanup needed here
+                    live.start()
+                
+                # Update content in live display
+                if is_interactive and header_text:
+                    # Update the panel content - for streaming, only show the last portion that fits in display_height
+                    if not is_complete:
+                        # Calculate approximate lines needed (rough estimation)
+                        content_lines = content.count('\n') + 1
+                        available_height = display_height - 4  # Account for panel borders and padding
+                        
+                        if content_lines > available_height:
+                            # If content is too big, show only the last part that fits
+                            lines = content.split('\n')
+                            truncated_content = '\n'.join(lines[-available_height:])
+                            md_obj.renderable = Markdown(truncated_content)
+                        else:
+                            md_obj.renderable = Markdown(content)
                     else:
                         md_obj.renderable = Markdown(content)
-                else:
-                    md_obj.renderable = Markdown(content)
-                
-                live.update(md_obj)
-            else:
-                # Same logic for non-interactive mode
-                if not is_complete:
-                    # Calculate approximate lines needed
-                    content_lines = content.count('\n') + 1
-                    available_height = display_height - 4  # Account for panel borders and padding
                     
-                    if content_lines > available_height:
-                        # If content is too big, show only the last part that fits
-                        lines = content.split('\n')
-                        truncated_content = '\n'.join(lines[-available_height:])
-                        md_obj.renderable = Markdown(truncated_content)
+                    live.update(md_obj)
+                else:
+                    # Same logic for non-interactive mode
+                    if not is_complete:
+                        # Calculate approximate lines needed
+                        content_lines = content.count('\n') + 1
+                        available_height = display_height - 4  # Account for panel borders and padding
+                        
+                        if content_lines > available_height:
+                            # If content is too big, show only the last part that fits
+                            lines = content.split('\n')
+                            truncated_content = '\n'.join(lines[-available_height:])
+                            md_obj.renderable = Markdown(truncated_content)
+                        else:
+                            md_obj.renderable = Markdown(content)
                     else:
                         md_obj.renderable = Markdown(content)
-                else:
-                    md_obj.renderable = Markdown(content)
+                        
+                    live.update(md_obj)
                     
-                live.update(md_obj)
+                # Ensure the display refreshes with new content
+                live.refresh()
                 
-            # Ensure the display refreshes with new content
-            live.refresh()
-            
-            # If streaming is complete, stop the live display
-            if is_complete:
-                try:
-                    # Just stop the live display when complete - no need to redisplay content
-                    live.stop()
-                except Exception as e:
-                    # Fallback if something goes wrong
-                    sys.stderr.write(f"\nError stopping live display: {str(e)}\n")
-                    sys.stderr.flush()
+                # If streaming is complete, stop the live display
+                if is_complete:
+                    try:
+                        # Just stop the live display when complete - no need to redisplay content
+                        live.stop()
+                    except Exception as e:
+                        # Fallback if something goes wrong
+                        sys.stderr.write(f"\nError stopping live display: {str(e)}\n")
+                        sys.stderr.flush()
         
         # Define a function to set up and start the spinner
         def setup_spinner(stop_event, message="Waiting for AI response...", color=COLORS['cyan']):

ngpt/cli/ui.py

@@ -159,10 +159,39 @@ def get_terminal_input():
         try:
             import msvcrt
             sys.stdout.flush()
-            # Wait for a keypress
-            char = msvcrt.getch().decode('utf-8').lower()
-            print(char)  # Echo the character
-            return char
+            
+            # Wait for a complete line (including Enter key)
+            input_chars = []
+            while True:
+                # Get a character
+                char = msvcrt.getch()
+                
+                # If it's Enter (CR or LF), break the loop
+                if char in [b'\r', b'\n']:
+                    print()  # Move to the next line after Enter
+                    break
+                    
+                # If it's backspace, handle it
+                if char == b'\x08':
+                    if input_chars:
+                        # Remove the last character
+                        input_chars.pop()
+                        # Erase the character on screen (backspace + space + backspace)
+                        sys.stdout.write('\b \b')
+                        sys.stdout.flush()
+                    continue
+                    
+                # For regular characters, add to input and echo
+                try:
+                    char_decoded = char.decode('utf-8').lower()
+                    input_chars.append(char_decoded)
+                    print(char_decoded, end='', flush=True)  # Echo the character without newline
+                except UnicodeDecodeError:
+                    # Skip characters that can't be decoded
+                    continue
+            
+            # Join all characters and return
+            return ''.join(input_chars).strip().lower()
         except ImportError:
             # Fallback if msvcrt is not available
             return None

{ngpt-3.8.1.dist-info → ngpt-3.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 3.8.1
+Version: 3.8.3
 Summary: Swiss army knife for LLMs: powerful CLI and interactive chatbot in one package. Seamlessly work with OpenAI, Ollama, Groq, Claude, Gemini, or any OpenAI-compatible API to generate code, craft git commits, rewrite text, and execute shell commands.
 Project-URL: Homepage, https://github.com/nazdridoy/ngpt
 Project-URL: Repository, https://github.com/nazdridoy/ngpt
@@ -493,6 +493,8 @@ In interactive mode:
 - For security, your API key is not displayed when editing configurations
 - When removing a configuration, you'll be asked to confirm before deletion
 
+![ngpt-sh-c-a](https://raw.githubusercontent.com/nazdridoy/ngpt/main/previews/ngpt-sh-c-a.png)
+
 For more details on configuring nGPT, see the [Configuration Guide](https://nazdridoy.github.io/ngpt/configuration/).
 
 ### Configuration File
@@ -541,6 +543,146 @@ nGPT determines configuration values in the following order (highest priority fi
 4. Main configuration file `ngpt.conf` or `custom-config-file`
 5. Default values
 
+### Real-World Demonstrations with nGPT
+
+Let's see nGPT in action! Here are some practical ways you can use it every day:
+
+#### Quick Q&A and Coding
+
+```bash
+# Get a quick explanation
+ngpt "Explain the difference between threads and processes in Python"
+
+# Generate code with real-time syntax highlighting
+ngpt --code --stream-prettify "Write a Python function to reverse a linked list"
+```
+
+With the `--code` flag, nGPT gives you clean code without explanations or markdown, just what you need to copy and paste into your project. The `--stream-prettify` option shows real-time syntax highlighting as the code comes in.
+
+#### Shell Command Generation (OS-Aware)
+
+```bash
+# Let nGPT generate the correct command for your OS
+ngpt --shell "list all files in the current directory including hidden ones"
+# On Linux/macOS: ls -la
+# On Windows: dir /a
+```
+
+One of my favorite features! No more Googling obscure command flags, nGPT generates the right command for your operating system. It'll even execute it for you if you approve.
+
+![ngpt-s-c](https://raw.githubusercontent.com/nazdridoy/ngpt/main/previews/ngpt-s-c.png)
+
+#### Text Rewriting and Summarization
+
+```bash
+# Pipe text to rewrite it (e.g., improve clarity)
+echo "This is a rough draft of my email." | ngpt -r
+
+# Summarize a file using the pipe placeholder
+cat long-article.txt | ngpt --pipe "Summarize this document concisely: {}"
+```
+
+The text rewriting feature is perfect for quickly improving documentation, emails, or reports. And with pipe placeholders, you can feed in content from files or other commands.
+
+#### Git Commit Message Generation
+
+```bash
+# Stage your changes
+git add .
+
+# Let nGPT generate a conventional commit message based on the diff
+ngpt -g
+
+# Generate git commit message from a diff file
+ngpt -g --diff changes.diff
+```
+
+This is a huge time-saver. nGPT analyzes your git diff and generates a properly formatted conventional commit message that actually describes what you changed. No more staring at the blank commit message prompt!
+
+![ngpt-g](https://raw.githubusercontent.com/nazdridoy/ngpt/main/previews/ngpt-g.png)
+
+#### Web Search Integration
+
+```bash
+# Ask questions that require up-to-date information
+ngpt --web-search "What's the latest news about AI regulation?"
+```
+
+The `--web-search` flag lets nGPT consult the web for recent information, making it useful for questions about current events or topics that might have changed since the AI's training data cutoff.
+
+![ngpt-w](https://raw.githubusercontent.com/nazdridoy/ngpt/main/previews/ngpt-w.png)
+
+### Real-World Integration Examples
+
+Let's look at how nGPT can fit into your everyday workflow with some practical examples:
+
+#### Developer Workflow
+
+As a developer, I use nGPT throughout my day:
+
+**Morning code review**:
+   ```bash
+   # Get explanations of complex code
+   git show | ngpt --pipe "Explain what this code change does and any potential issues: {}"
+   ```
+
+**Debugging help**:
+   ```bash
+   # Help understand a cryptic error message
+   npm run build 2>&1 | grep Error | ngpt --pipe "What does this error mean and how can I fix it: {}"
+   ```
+
+**Documentation generation**:
+   ```bash
+   # Generate JSDoc comments for functions
+   cat src/utils.js | ngpt --pipe "Write proper JSDoc comments for these functions: {}"
+   ```
+
+**Commit messages**:
+   ```bash
+   # After finishing a feature
+   git add .
+   ngpt -g
+   ```
+
+#### Writer's Assistant
+
+For content creators and writers:
+
+**Overcoming writer's block**:
+   ```bash
+   ngpt "Give me 5 different angles to approach an article about sustainable technology"
+   ```
+
+**Editing assistance**:
+   ```bash
+   cat draft.md | ngpt -r
+   ```
+
+**Research summaries**:
+   ```bash
+   curl -s https://example.com/research-paper.html | ngpt --pipe "Summarize the key findings from this research: {}"
+   ```
+
+#### System Administrator
+
+For sysadmins and DevOps folks:
+
+**Generating complex commands**:
+   ```bash
+   ngpt -s "find all log files larger than 100MB that haven't been modified in the last 30 days"
+   ```
+
+*Creating configuration files**:
+   ```bash
+   ngpt --code "Create a Docker Compose file for a Redis, PostgreSQL, and Node.js application"
+   ```
+
+**Troubleshooting systems**:
+   ```bash
+   dmesg | tail -50 | ngpt --pipe "Explain what might be causing the issues based on these system logs: {}"
+   ```
+
 ## Contributing
 
 We welcome contributions to nGPT! Whether it's bug fixes, feature additions, or documentation improvements, your help is appreciated.

{ngpt-3.8.1.dist-info → ngpt-3.8.3.dist-info}/RECORD

@@ -6,24 +6,24 @@ ngpt/cli/args.py,sha256=HYCDHhqP-BI_tibL1qGQ9we4483h_kCa2ksh-QxOeiU,12694
 ngpt/cli/config_manager.py,sha256=NQQcWnjUppAAd0s0p9YAf8EyKS1ex5-0EB4DvKdB4dk,3662
 ngpt/cli/formatters.py,sha256=HBYGlx_7eoAKyzfy0Vq5L0yn8yVKjngqYBukMmXCcz0,9401
 ngpt/cli/main.py,sha256=PVulo8Pm53-oQ2Pgc4G90YhwyPImt8j7HKmY38SJ7CM,28696
-ngpt/cli/renderers.py,sha256=m71BeUXKynpKKGXFzwRSW1XngvyKiZ_xEsdujUbU0MA,16597
-ngpt/cli/ui.py,sha256=tVJGTP1DWjCRq7ONFdOOKPHcVQz0MqiLyJtodKFabTk,9612
+ngpt/cli/renderers.py,sha256=vAoDkpvgG2Fl81zkJDk_-zM1Fsw8E4Uv6m1AI81Fawo,17049
+ngpt/cli/ui.py,sha256=4RFxIf51di5EsytVr7OoyCWF_d40KJ0Mbom0VWgPlCc,10870
 ngpt/cli/modes/__init__.py,sha256=KP7VR6Xw9k1p5Jcu0F38RDxSFvFIzH3j1ThDLNwznUI,363
-ngpt/cli/modes/chat.py,sha256=1mH3nTDwU52qQJRliNUAFSqJWyyiJ6j0T5uVso-VnxE,6828
-ngpt/cli/modes/code.py,sha256=QBFgMRPKJhxkYCmumoSkNSF15XNRGUDum5yuK8aBnyM,12662
+ngpt/cli/modes/chat.py,sha256=x1leClKq7UupA_CdW4tym0AivY2o_II123-I5IcAkxQ,7091
+ngpt/cli/modes/code.py,sha256=Qj59xq6fZqgUDw7SbvmPKX_gdpc7DHJhNkn1sB5qgUU,12932
 ngpt/cli/modes/gitcommsg.py,sha256=iTg3KlZwI0lGMcmUa62b0ashwLcxegdEEvT29PPtpBc,49595
-ngpt/cli/modes/interactive.py,sha256=TtBrZUX45CVfKOPvkb1ya7dIQhXLILtn7ajmfM9ohso,17419
-ngpt/cli/modes/rewrite.py,sha256=yPmJPPkMHNxrnV-eoM0j6lMNRhdSAMXmcw2s9xG6TIo,10918
-ngpt/cli/modes/shell.py,sha256=9Bg-uPDjNgSwLULRzRxDkBXjVd1yPZLZXG-V2kPFm2k,29929
-ngpt/cli/modes/text.py,sha256=7t5WWXMFxGkBM5HMP4irbN9aQwxE2YgywjiVPep710k,6417
+ngpt/cli/modes/interactive.py,sha256=E0c38NA8xnuRKAce40F35uFYcohFDvaqSB8nf1ywS-4,17958
+ngpt/cli/modes/rewrite.py,sha256=QQm453X9aoUQP9CAtmeghlMytMJPlsDZPKef9tGfj6g,11181
+ngpt/cli/modes/shell.py,sha256=it1Brq1-LGeNfPKYBeVAwF-a78g9UP-KscofBZQkbr4,41589
+ngpt/cli/modes/text.py,sha256=rUr7Byds7zkO9ZbMSZWOO_3fWfpeM40Tq1XJAgdapcs,6679
 ngpt/utils/__init__.py,sha256=_92f8eGMMOtQQA3uwgSRVwUEl1EIRFjWPUjcfGgI-eI,1244
 ngpt/utils/cli_config.py,sha256=Ug8cECBTIuzOwkBWidLTfs-OAdOsCMJ2bNa70pOADfw,11195
 ngpt/utils/config.py,sha256=wsArA4osnh8fKqOvtsPqqBxAz3DpdjtaWUFaRtnUdyc,10452
 ngpt/utils/log.py,sha256=f1jg2iFo35PAmsarH8FVL_62plq4VXH0Mu2QiP6RJGw,15934
 ngpt/utils/pipe.py,sha256=qRHF-Ma7bbU0cOcb1Yhe4S-kBavivtnnvLA3EYS4FY4,2162
 ngpt/utils/web_search.py,sha256=w5ke4KJMRxq7r5jtbUXvspja6XhjoPZloVkZ0IvBXIE,30731
-ngpt-3.8.1.dist-info/METADATA,sha256=uiFcgSP1jz1ArOo1CUJ4FQvBZyo5Cq72_EdKzG8JEzM,24503
-ngpt-3.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-3.8.1.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
-ngpt-3.8.1.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-3.8.1.dist-info/RECORD,,
+ngpt-3.8.3.dist-info/METADATA,sha256=GjMEbP2fAxk4J6LdsM7vN0N3vT6ikicEbTRoWRGlNQI,28919
+ngpt-3.8.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-3.8.3.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-3.8.3.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-3.8.3.dist-info/RECORD,,