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

ngpt/cli/modes/shell.py

@@ -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:
@@ -537,7 +804,7 @@ def shell_mode(client, args, logger=None):
     # Add a small delay to ensure terminal rendering is complete,
     # especially important for stream-prettify mode
     if use_stream_prettify:
-        time.sleep(0.2)
+        time.sleep(0.5)
 
     # Print prompt and flush to ensure it appears
     sys.stdout.write(prompt_text)
@@ -550,9 +817,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 +832,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/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.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 3.8.1
+Version: 3.8.2
 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.2.dist-info}/RECORD

@@ -7,14 +7,14 @@ ngpt/cli/config_manager.py,sha256=NQQcWnjUppAAd0s0p9YAf8EyKS1ex5-0EB4DvKdB4dk,36
 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/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/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/shell.py,sha256=nXkUbLLNdXQrdsOqGXMwdfnr2y7MtqbmBkYlwZbI5JA,41415
 ngpt/cli/modes/text.py,sha256=7t5WWXMFxGkBM5HMP4irbN9aQwxE2YgywjiVPep710k,6417
 ngpt/utils/__init__.py,sha256=_92f8eGMMOtQQA3uwgSRVwUEl1EIRFjWPUjcfGgI-eI,1244
 ngpt/utils/cli_config.py,sha256=Ug8cECBTIuzOwkBWidLTfs-OAdOsCMJ2bNa70pOADfw,11195
@@ -22,8 +22,8 @@ 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.2.dist-info/METADATA,sha256=2LazTO2smhA2gBILZQ9vA0Xqqn2RByEIfclp999Y6KA,28919
+ngpt-3.8.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-3.8.2.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-3.8.2.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-3.8.2.dist-info/RECORD,,