ngpt 3.6.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

ngpt/cli/args.py

@@ -69,6 +69,8 @@ def setup_argument_parser():
                               help='Model to use')
     global_group.add_argument('--web-search', action='store_true', 
                       help='Enable web search capability using DuckDuckGo to enhance prompts with relevant information')
+    global_group.add_argument('--pipe', action='store_true',
+                      help='Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content. Can be used with any mode option except --text and --interactive')
     global_group.add_argument('--temperature', type=float, default=0.7,
                       help='Set temperature (controls randomness, default: 0.7)')
     global_group.add_argument('--top_p', type=float, default=1.0,
@@ -119,8 +121,6 @@ def setup_argument_parser():
                                       help='Generate code')
     mode_exclusive_group.add_argument('-t', '--text', action='store_true', 
                                       help='Enter multi-line text input (submit with Ctrl+D)')
-    mode_exclusive_group.add_argument('-p', '--pipe', action='store_true',
-                                      help='Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content')
     mode_exclusive_group.add_argument('-r', '--rewrite', action='store_true',
                                       help='Rewrite text from stdin to be more natural while preserving tone and meaning')
     mode_exclusive_group.add_argument('-g', '--gitcommsg', action='store_true',
@@ -167,7 +167,11 @@ def validate_args(args):
     if args.stream_prettify and not has_markdown_renderer('rich'):
         raise ValueError("--stream-prettify requires Rich to be installed. Install with: pip install \"ngpt[full]\" or pip install rich")
     
-    # If stdin mode is used, check if input is available
+    # Check for incompatible --pipe flag with certain modes
+    if args.pipe and (args.text or args.interactive):
+        raise ValueError("--pipe flag cannot be used with --text or --interactive modes. These modes already handle input directly.")
+    
+    # If pipe flag is used, check if input is available
     if args.pipe and sys.stdin.isatty():
         raise ValueError("--pipe was specified but no input is piped. Use echo 'content' | ngpt --pipe 'prompt with {}'")
     

ngpt/cli/main.py

@@ -550,13 +550,6 @@ def main():
             # Text mode (multiline input)
             text_mode(client, args, logger=logger)
         
-        elif args.pipe:
-            # Apply CLI config for pipe mode (similar to chat mode)
-            args = apply_cli_config(args, "all")
-            
-            # Pipe mode (using the chat mode with stdin input)
-            chat_mode(client, args, logger=logger)
-        
         elif args.rewrite:
             # Apply CLI config for rewrite mode
             args = apply_cli_config(args, "all")
@@ -571,8 +564,8 @@ def main():
             # Git commit message generation mode
             gitcommsg_mode(client, args, logger=logger)
         
+        # Choose chat mode by default if no other specific mode is selected
         else:
-            # Default to chat mode
             # Apply CLI config for default chat mode
             args = apply_cli_config(args, "all")
             

ngpt/cli/modes/chat.py

@@ -1,7 +1,7 @@
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown
 from ..ui import spinner
-from ...utils import enhance_prompt_with_web_search
+from ...utils import enhance_prompt_with_web_search, process_piped_input
 import sys
 import threading
 
@@ -13,43 +13,20 @@ def chat_mode(client, args, logger=None):
         args: The parsed command-line arguments
         logger: Optional logger instance
     """
+    # Get the prompt
+    if args.prompt is None:
+        try:
+            print("Enter your prompt: ", end='')
+            prompt = input()
+        except KeyboardInterrupt:
+            print("\nInput cancelled by user. Exiting gracefully.")
+            sys.exit(130)
+    else:
+        prompt = args.prompt
+    
     # Handle pipe mode
     if args.pipe:
-        # Read input from stdin
-        stdin_content = sys.stdin.read().strip()
-        
-        # Get the prompt - either use provided one or ask user
-        if args.prompt is None:
-            try:
-                print("Enter your prompt (use {} as placeholder for stdin): ", end='')
-                prompt = input()
-            except KeyboardInterrupt:
-                print("\nInput cancelled by user. Exiting gracefully.")
-                sys.exit(130)
-        else:
-            prompt = args.prompt
-        
-        # Replace the placeholder in the prompt with stdin content
-        placeholder = "{}"
-        
-        # Check if the placeholder exists in the prompt
-        if placeholder not in prompt:
-            print(f"{COLORS['yellow']}Warning: Placeholder '{placeholder}' not found in prompt. Appending stdin content to the end.{COLORS['reset']}")
-            prompt = f"{prompt} {stdin_content}"
-        else:
-            prompt = prompt.replace(placeholder, stdin_content)
-    # Handle regular chat mode
-    else:
-        # Get the prompt
-        if args.prompt is None:
-            try:
-                print("Enter your prompt: ", end='')
-                prompt = input()
-            except KeyboardInterrupt:
-                print("\nInput cancelled by user. Exiting gracefully.")
-                sys.exit(130)
-        else:
-            prompt = args.prompt
+        prompt = process_piped_input(prompt, logger=logger)
     
     # Log the user message if logging is enabled
     if logger:

ngpt/cli/modes/code.py

@@ -1,7 +1,7 @@
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer, show_available_renderers
 from ..ui import spinner, copy_to_clipboard
-from ...utils import enhance_prompt_with_web_search
+from ...utils import enhance_prompt_with_web_search, process_piped_input
 import sys
 import threading
 
@@ -97,6 +97,10 @@ def code_mode(client, args, logger=None):
     else:
         prompt = args.prompt
     
+    # Apply piped input if --pipe is enabled
+    if args.pipe:
+        prompt = process_piped_input(prompt, logger=logger)
+    
     # Log the user prompt if logging is enabled
     if logger:
         logger.log("user", prompt)

ngpt/cli/modes/gitcommsg.py

@@ -11,6 +11,7 @@ from ..formatters import COLORS
 from ..ui import spinner, copy_to_clipboard
 from ...utils.log import create_gitcommsg_logger
 from ...utils.cli_config import get_cli_config_option
+from ...utils import process_piped_input
 
 def get_diff_content(diff_file=None):
     """Get git diff content from file or git staged changes.
@@ -964,6 +965,39 @@ REMINDER:
 
 DO NOT ask for the original diff or add explanations outside the commit message format."""
 
+def is_git_diff(content):
+    """Check if the content looks like a git diff.
+    
+    Args:
+        content: The content to check
+        
+    Returns:
+        bool: True if the content looks like a git diff, False otherwise
+    """
+    # Check for common git diff patterns
+    diff_patterns = [
+        r'diff --git a/.*? b/.*?',  # diff --git a/file b/file
+        r'index [a-f0-9]+\.\.[a-f0-9]+',  # index hash..hash
+        r'--- a/.*?',  # --- a/file
+        r'\+\+\+ b/.*?',  # +++ b/file
+        r'@@ -\d+,\d+ \+\d+,\d+ @@'  # @@ -line,count +line,count @@
+    ]
+    
+    # Check if the content contains at least one of these patterns
+    for pattern in diff_patterns:
+        if re.search(pattern, content):
+            return True
+    
+    # Check if the content contains lines starting with + or - (changes)
+    lines = content.splitlines()
+    plus_minus_lines = [line for line in lines if line.startswith('+') or line.startswith('-')]
+    
+    # If there are many +/- lines, it's likely a diff
+    if len(plus_minus_lines) > 5 and len(plus_minus_lines) / len(lines) > 0.1:
+        return True
+    
+    return False
+
 def gitcommsg_mode(client, args, logger=None):
     """Handle the Git commit message generation mode.
     
@@ -987,16 +1021,47 @@ def gitcommsg_mode(client, args, logger=None):
         active_logger.debug(f"Args: {args}")
     
     try:
+        # Process piped input as diff content when --pipe flag is set
+        piped_diff_content = None
+        if args.pipe:
+            if active_logger:
+                active_logger.info("Processing piped input as diff content")
+            
+            if not sys.stdin.isatty():
+                piped_diff_content = sys.stdin.read().strip()
+                if not piped_diff_content:
+                    print(f"{COLORS['yellow']}Warning: No diff content received from stdin.{COLORS['reset']}")
+                else:
+                    # Validate that the piped content looks like a git diff
+                    if not is_git_diff(piped_diff_content):
+                        print(f"{COLORS['red']}Error: The piped content doesn't appear to be a git diff. Exiting.{COLORS['reset']}")
+                        if active_logger:
+                            active_logger.error("Piped content doesn't appear to be a git diff. Aborting.")
+                        return
+                    elif active_logger:
+                        active_logger.info(f"Received {len(piped_diff_content.splitlines())} lines of diff content from stdin")
+            else:
+                print(f"{COLORS['yellow']}Error: --pipe was specified but no input is piped.{COLORS['reset']}")
+                return
+        
         # Check if --diff was explicitly passed on the command line
         diff_option_provided = '--diff' in sys.argv
         diff_path_provided = diff_option_provided and args.diff is not None and args.diff is not True
         
+        # If piped diff content is available, use it directly
+        if piped_diff_content:
+            diff_content = piped_diff_content
+            if active_logger:
+                active_logger.info("Using diff content from stdin")
         # If --diff wasn't explicitly provided on the command line, don't use the config value
-        if not diff_option_provided:
+        elif not diff_option_provided:
             # Even if diff is in CLI config, don't use it unless --diff flag is provided
             diff_file = None
             if active_logger:
                 active_logger.info("Not using diff file from CLI config because --diff flag was not provided")
+            
+            # Get diff content from git staged changes
+            diff_content = get_diff_content(diff_file)
         else:
             # --diff flag was provided on command line
             if args.diff is True:
@@ -1013,9 +1078,9 @@ def gitcommsg_mode(client, args, logger=None):
                 diff_file = args.diff
                 if active_logger:
                     active_logger.info(f"Using explicitly provided diff file: {diff_file}")
-        
-        # Get diff content
-        diff_content = get_diff_content(diff_file)
+            
+            # Get diff content from file
+            diff_content = get_diff_content(diff_file)
         
         if not diff_content:
             print(f"{COLORS['red']}No diff content available. Exiting.{COLORS['reset']}")

ngpt/cli/modes/rewrite.py

@@ -4,7 +4,7 @@ import time
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown
 from ..ui import get_multiline_input, spinner, copy_to_clipboard
-from ...utils import enhance_prompt_with_web_search
+from ...utils import enhance_prompt_with_web_search, process_piped_input
 
 # System prompt for rewriting text
 REWRITE_SYSTEM_PROMPT = """You are an expert text editor and rewriter. Your task is to rewrite the user's text to improve readability and flow while carefully preserving the original meaning, tone, and style.
@@ -78,14 +78,17 @@ def rewrite_mode(client, args, logger=None):
         args: The parsed command-line arguments
         logger: Optional logger instance
     """
-    # Determine the input source (stdin pipe, command-line argument, or multiline input)
-    if not sys.stdin.isatty():
+    # Check if using --pipe flag with a specific placeholder
+    if args.pipe and args.prompt:
+        input_text = process_piped_input(args.prompt, logger=logger)
+    # Normal rewrite mode functionality (direct stdin piping without --pipe flag)
+    elif not sys.stdin.isatty():
         # Read from stdin if data is piped
         input_text = sys.stdin.read().strip()
         
-        # If stdin is empty but prompt is provided, use the prompt
-        if not input_text and args.prompt:
-            input_text = args.prompt
+        # If prompt is also provided, append it to the piped input
+        if args.prompt:
+            input_text = f"{input_text}\n\n{args.prompt}"
     elif args.prompt:
         # Use the command-line argument if provided
         input_text = args.prompt

ngpt/cli/modes/shell.py

@@ -1,7 +1,7 @@
 from ..formatters import COLORS
 from ..ui import spinner, copy_to_clipboard
-from ..renderers import prettify_markdown, has_markdown_renderer
-from ...utils import enhance_prompt_with_web_search
+from ..renderers import prettify_markdown, has_markdown_renderer, prettify_streaming_markdown, show_available_renderers
+from ...utils import enhance_prompt_with_web_search, process_piped_input
 import subprocess
 import sys
 import threading
@@ -9,6 +9,7 @@ import platform
 import os
 import shutil
 import re
+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.
@@ -131,6 +132,251 @@ def detect_shell():
         else:
             return "bash", "bash", operating_system
 
+def setup_streaming(args, logger=None):
+    """Set up streaming configuration based on command-line arguments.
+    
+    Args:
+        args: The parsed command-line arguments
+        logger: Optional logger instance for logging
+        
+    Returns:
+        tuple: (should_stream, use_stream_prettify, use_regular_prettify, 
+                stream_setup) - Configuration settings and streaming components
+    """
+    # Default values - initialize all at once
+    stream_callback = live_display = stop_spinner_func = None
+    stop_spinner = spinner_thread = stop_spinner_event = None
+    should_stream = True  # Default to streaming
+    use_stream_prettify = use_regular_prettify = False
+    first_content_received = False
+    
+    # Determine final behavior based on flag priority
+    if args.stream_prettify:
+        # Highest priority: stream-prettify
+        if has_markdown_renderer('rich'):
+            should_stream = True
+            use_stream_prettify = True
+            live_display, stream_callback, setup_spinner = prettify_streaming_markdown(args.renderer)
+            if not live_display:
+                # Fallback if live display fails
+                use_stream_prettify = False
+                use_regular_prettify = True
+                should_stream = False 
+                print(f"{COLORS['yellow']}Live display setup failed. Falling back to regular prettify mode.{COLORS['reset']}")
+        else:
+            # Rich not available for stream-prettify
+            print(f"{COLORS['yellow']}Warning: Rich is not available for --stream-prettify. Install with: pip install \"ngpt[full]\".{COLORS['reset']}")
+            print(f"{COLORS['yellow']}Falling back to default streaming without prettify.{COLORS['reset']}")
+            should_stream = True
+            use_stream_prettify = False
+    elif args.no_stream:
+        # Second priority: no-stream
+        should_stream = False
+        use_regular_prettify = False # No prettify if no streaming
+    elif args.prettify:
+        # Third priority: prettify (requires disabling stream)
+        if has_markdown_renderer(args.renderer):
+            should_stream = False
+            use_regular_prettify = True
+            print(f"{COLORS['yellow']}Note: Using standard markdown rendering (--prettify). For streaming markdown rendering, use --stream-prettify instead.{COLORS['reset']}")
+        else:
+            # Renderer not available for prettify
+            print(f"{COLORS['yellow']}Warning: Renderer '{args.renderer}' not available for --prettify.{COLORS['reset']}")
+            show_available_renderers()
+            print(f"{COLORS['yellow']}Falling back to default streaming without prettify.{COLORS['reset']}")
+            should_stream = True 
+            use_regular_prettify = False
+    
+    # Create a wrapper for the stream callback that will stop the spinner on first content
+    if stream_callback:
+        original_callback = stream_callback
+        
+        def spinner_handling_callback(content, **kwargs):
+            nonlocal first_content_received
+            
+            # 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()
+            
+            # Call the original callback to update the display
+            if original_callback:
+                original_callback(content, **kwargs)
+        
+        # Use our wrapper callback
+        if use_stream_prettify and live_display:
+            stream_callback = spinner_handling_callback
+            
+            # Set up the spinner if we have a live display
+            stop_spinner_event = threading.Event()
+            stop_spinner_func = setup_spinner(stop_spinner_event, color=COLORS['cyan'])
+    
+    # Create spinner for non-stream-prettify modes EXCEPT no-stream
+    if not use_stream_prettify and not args.no_stream:
+        # Prepare spinner (but don't start it yet - will be started in generate_with_model)
+        stop_spinner = threading.Event()
+        spinner_thread = threading.Thread(
+            target=spinner, 
+            args=("Generating...",), 
+            kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
+        )
+        spinner_thread.daemon = True
+    
+    # Create a stream_setup dict to hold all the variables - use a dict comprehension
+    stream_setup = {
+        'stream_callback': stream_callback,
+        'live_display': live_display,
+        'stop_spinner_func': stop_spinner_func,
+        'stop_spinner': stop_spinner,
+        'spinner_thread': spinner_thread,
+        'stop_spinner_event': stop_spinner_event,
+        'first_content_received': first_content_received
+    }
+    
+    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):
+    """Generate content using the model with proper streaming and spinner handling.
+    
+    Args:
+        client: The NGPTClient instance
+        prompt: The prompt to send to the model
+        messages: The formatted messages to send
+        args: The parsed command-line arguments
+        stream_setup: The streaming setup from setup_streaming
+        use_stream_prettify: Whether to use stream prettify
+        should_stream: Whether to stream the response
+        spinner_message: Message to show in the spinner
+        temp_override: Optional temperature override
+        logger: Optional logger instance
+        
+    Returns:
+        str: The generated content
+    """
+    # Extract variables from stream_setup - only unpack what we need
+    stream_callback = stream_setup['stream_callback']
+    stop_spinner = stream_setup['stop_spinner']
+    spinner_thread = stream_setup['spinner_thread']
+    stop_spinner_event = stream_setup['stop_spinner_event']
+    stop_spinner_func = stream_setup['stop_spinner_func']
+    
+    # Show spinner for all modes except no-stream
+    if not args.no_stream:
+        # Two possible spinner types:
+        # 1. Rich spinner for stream_prettify
+        # 2. Regular spinner for all other modes (including --prettify)
+        
+        if use_stream_prettify and stop_spinner_func:
+            # Rich spinner is handled by callbacks
+            pass
+        elif spinner_thread and stop_spinner:
+            # Start the regular spinner thread
+            spinner_thread._args = (spinner_message,)
+            if not spinner_thread.is_alive():
+                spinner_thread.start()
+    else:
+        # No-stream mode just gets a status message
+        print(spinner_message)
+    
+    # Set temperature
+    temp = args.temperature if temp_override is None else temp_override
+    
+    try:
+        # Make the API call
+        return client.chat(
+            prompt=prompt,
+            stream=should_stream,
+            messages=messages,
+            temperature=temp,
+            top_p=args.top_p,
+            max_tokens=args.max_tokens,
+            stream_callback=stream_callback
+        )
+    except KeyboardInterrupt:
+        print("\nRequest cancelled by user.")
+        return ""
+    except Exception as e:
+        print(f"Error generating content: {e}")
+        return ""
+    finally:
+        # Stop the spinner
+        if use_stream_prettify and stop_spinner_event:
+            # Stop rich spinner
+            if not stream_setup['first_content_received']:
+                stop_spinner_event.set()
+        elif stop_spinner:
+            # Stop regular spinner
+            stop_spinner.set()
+            if spinner_thread and spinner_thread.is_alive():
+                spinner_thread.join()
+            
+            # Clear the spinner line completely
+            sys.stdout.write("\r" + " " * 100 + "\r")
+            sys.stdout.flush()
+
+def display_content(content, content_type, highlight_lang, args, use_stream_prettify, use_regular_prettify):
+    """Display generated content with appropriate formatting.
+    
+    Args:
+        content: The content to display
+        content_type: Type of content ('command' or 'description')
+        highlight_lang: Language for syntax highlighting
+        args: The parsed command-line arguments
+        use_stream_prettify: Whether stream prettify is enabled
+        use_regular_prettify: Whether regular prettify is enabled
+    """
+    if not content:
+        return
+    
+    # Define title based on content type - use a lookup instead of if-else
+    titles = {
+        'command': "Generated Command",
+        'description': "Command Description"
+    }
+    title = titles.get(content_type, "Generated Content")
+        
+    # Format content appropriately - create formatted content only when needed
+    if use_regular_prettify and has_markdown_renderer(args.renderer):
+        if content_type == 'command':
+            formatted_content = f"### {title}\n\n```{highlight_lang}\n{content}\n```"
+        else:  # description
+            formatted_content = f"### {title}\n\n{content}"
+    
+    # Only show formatted content if not already shown by stream-prettify
+    if not use_stream_prettify:
+        if use_regular_prettify and has_markdown_renderer(args.renderer):
+            # Use rich renderer for pretty output
+            prettify_markdown(formatted_content, args.renderer)
+        elif args.no_stream:
+            # Simple output for no-stream mode (no box)
+            if content_type == 'command':
+                print(f"\n{title}:\n{COLORS['green']}{content}{COLORS['reset']}\n")
+            else:
+                print(f"\n{title}:\n{content}\n")
+        else:
+            # Regular display or fallback
+            if content_type == 'command':
+                # Box formatting for commands in regular mode - calculate once
+                term_width = shutil.get_terminal_size().columns
+                box_width = min(term_width - 4, len(content) + 8)
+                horizontal_line = "─" * box_width
+                spacing = box_width - len(title) - 11
+                content_spacing = box_width - len(content) - 2
+                
+                print(f"\n┌{horizontal_line}┐")
+                print(f"│ {COLORS['bold']}{title}:{COLORS['reset']}  {' ' * spacing}│")
+                print(f"│ {COLORS['green']}{content}{COLORS['reset']}{' ' * content_spacing}│")
+                print(f"└{horizontal_line}┘\n")
+            else:
+                # Simple display for descriptions
+                print(f"\n{content}\n")
+
 def shell_mode(client, args, logger=None):
     """Handle the shell command generation mode.
     
@@ -139,6 +385,7 @@ def shell_mode(client, args, logger=None):
         args: The parsed command-line arguments
         logger: Optional logger instance
     """
+    # Get the user prompt more efficiently
     if args.prompt is None:
         try:
             print("Enter shell command description: ", end='')
@@ -149,15 +396,20 @@ def shell_mode(client, args, logger=None):
     else:
         prompt = args.prompt
     
+    # Process piped input if --pipe flag is set
+    if args.pipe:
+        prompt = process_piped_input(prompt, logger=logger)
+    
     # Log the user prompt if logging is enabled
     if logger:
         logger.log("user", prompt)
     
-    # Enhance prompt with web search if enabled
+    # Enhance prompt with web search if enabled - reuse variables
     if args.web_search:
+        original_prompt = prompt
+        web_search_succeeded = False
+        
         try:
-            original_prompt = prompt
-            
             # Start spinner for web search
             stop_spinner = threading.Event()
             spinner_thread = threading.Thread(
@@ -170,23 +422,23 @@ def shell_mode(client, args, logger=None):
             
             try:
                 prompt = enhance_prompt_with_web_search(prompt, logger=logger, disable_citations=True)
-                # Stop the spinner
+                web_search_succeeded = True
+            finally:
+                # Always stop the spinner
                 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.")
-            except Exception as e:
-                # Stop the spinner before re-raising
-                stop_spinner.set()
-                spinner_thread.join()
-                raise e
             
-            # Log the enhanced prompt if logging is enabled
-            if logger:
-                # Use "web_search" role instead of "system" for clearer logs
-                logger.log("web_search", prompt.replace(original_prompt, "").strip())
+            if web_search_succeeded:
+                print("Enhanced input with web search results.")
+                
+                # Log the enhanced prompt if logging is enabled
+                if logger:
+                    # Use "web_search" role instead of "system" for clearer logs
+                    logger.log("web_search", prompt.replace(original_prompt, "").strip())
         except Exception as e:
             print(f"{COLORS['yellow']}Warning: Failed to enhance prompt with web search: {str(e)}{COLORS['reset']}")
             # Continue with the original prompt if web search fails
@@ -224,36 +476,21 @@ def shell_mode(client, args, logger=None):
     if logger:
         logger.log("system", system_prompt)
     
-    # Start spinner while waiting for command generation
-    stop_spinner = threading.Event()
-    spinner_thread = threading.Thread(
-        target=spinner, 
-        args=("Generating command...",), 
-        kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
-    )
-    spinner_thread.daemon = True
-    spinner_thread.start()
+    # Set up streaming once and reuse for both command and description
+    should_stream, use_stream_prettify, use_regular_prettify, stream_setup = setup_streaming(args)
     
-    try:
-        command = client.chat(
-            prompt=prompt,
-            stream=False,
-            messages=messages,
-            temperature=args.temperature,
-            top_p=args.top_p,
-            max_tokens=args.max_tokens
-        )
-    except Exception as e:
-        print(f"Error generating shell command: {e}")
-        command = ""
-    finally:
-        # Stop the spinner
-        stop_spinner.set()
-        spinner_thread.join()
-        
-        # Clear the spinner line completely
-        sys.stdout.write("\r" + " " * 100 + "\r")
-        sys.stdout.flush()
+    # Generate the command
+    command = generate_with_model(
+        client=client, 
+        prompt=prompt, 
+        messages=messages, 
+        args=args, 
+        stream_setup=stream_setup, 
+        use_stream_prettify=use_stream_prettify, 
+        should_stream=should_stream,
+        spinner_message="Generating command...",
+        logger=logger
+    )
     
     if not command:
         return  # Error already printed by client
@@ -265,30 +502,45 @@ def shell_mode(client, args, logger=None):
     # Get the most up-to-date shell type at command generation time
     _, highlight_lang, _ = detect_shell()
     
-    # Create a markdown-formatted display of the command with appropriate syntax highlighting
-    formatted_command = f"### Generated Command\n\n```{highlight_lang}\n{command}\n```"
+    # Format with proper syntax highlighting for streaming prettify - only if needed
+    if use_stream_prettify and stream_setup['stream_callback'] and command:
+        # Create properly formatted markdown for streaming display
+        formatted_command = f"```{highlight_lang}\n{command}\n```"
+        # Update the live display with the formatted command
+        stream_setup['stream_callback'](formatted_command, complete=True)
     
-    # Check if we can use rich rendering
-    if has_markdown_renderer('rich'):
-        # Use rich renderer for pretty output
-        prettify_markdown(formatted_command, 'rich')
-    else:
-        # Fallback to simpler formatting
-        term_width = shutil.get_terminal_size().columns
-        box_width = min(term_width - 4, len(command) + 8)
-        horizontal_line = "─" * box_width
-        
-        print(f"\n┌{horizontal_line}┐")
-        print(f"│ {COLORS['bold']}Generated Command:{COLORS['reset']}  {' ' * (box_width - 20)}│")
-        print(f"│ {COLORS['green']}{command}{COLORS['reset']}{' ' * (box_width - len(command) - 2)}│")
-        print(f"└{horizontal_line}┘\n")
-    
-    # Display options with better formatting
-    print(f"{COLORS['bold']}Options:{COLORS['reset']}")
-    print(f"  {COLORS['cyan']}c{COLORS['reset']} - Copy to clipboard")
-    print(f"  {COLORS['cyan']}e{COLORS['reset']} - Execute command")
-    print(f"  {COLORS['cyan']}n{COLORS['reset']} - Cancel (default)")
-    print(f"\nWhat would you like to do? [{COLORS['cyan']}c{COLORS['reset']}/{COLORS['cyan']}e{COLORS['reset']}/N] ", end='')
+    # Display the command
+    display_content(
+        content=command,
+        content_type='command',
+        highlight_lang=highlight_lang,
+        args=args,
+        use_stream_prettify=use_stream_prettify,
+        use_regular_prettify=use_regular_prettify
+    )
+    
+    # Display options with better formatting - prepare strings once
+    options_text = f"{COLORS['bold']}Options:{COLORS['reset']}"
+    options = [
+        f"  {COLORS['cyan']}C{COLORS['reset']} - Copy       - Copy the command to clipboard",
+        f"  {COLORS['cyan']}E{COLORS['reset']} - Execute    - Run the command in your shell",
+        f"  {COLORS['cyan']}D{COLORS['reset']} - Describe   - Explain what this command does",
+        f"  {COLORS['cyan']}A{COLORS['reset']} - Abort      - Cancel and return to prompt"
+    ]
+    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)
+
+    # Print prompt and flush to ensure it appears
+    print(prompt_text, end='', flush=True)
     
     try:
         response = input().lower()
@@ -296,7 +548,7 @@ def shell_mode(client, args, logger=None):
         print("\nCommand execution cancelled by user.")
         return
         
-    if response == 'e' or response == 'execute':
+    if response == 'e':
         # Log the execution if logging is enabled
         if logger:
             logger.log("system", f"Executing command: {command}")
@@ -326,7 +578,7 @@ def shell_mode(client, args, logger=None):
                 logger.log("system", f"Command error: {error}")
                 
             print(f"\nError:\n{error}")
-    elif response == 'c' or response == 'copy':
+    elif response == 'c':
         # Copy command to clipboard without confirmation prompt
         copied = copy_to_clipboard(command, skip_confirmation=True)
         if not copied:
@@ -334,4 +586,93 @@ def shell_mode(client, args, logger=None):
         
         # Log the copy if logging is enabled
         if logger:
-            logger.log("system", "Command copied to clipboard") 
+            logger.log("system", "Command copied to clipboard") 
+    elif response == 'd':
+        # Ask LLM to describe what the command does
+        describe_prompt = f"Please explain this command: {command}"
+        
+        # Create system prompt for description that includes OS and shell info
+        describe_system_prompt = f"You are a helpful assistant explaining shell commands. The user is running {shell_name} on {operating_system}. Explain what the following shell command does in detail, considering this specific environment. Include any potential risks, side effects, or compatibility issues with this OS/shell combination."
+        
+        # Prepare messages for the chat API
+        describe_messages = [
+            {"role": "system", "content": describe_system_prompt},
+            {"role": "user", "content": describe_prompt}
+        ]
+        
+        # Log the system prompt if logging is enabled
+        if logger:
+            logger.log("system", f"Command description requested for {operating_system}/{shell_name}")
+        
+        # Set up fresh streaming for description - reuse existing setup when possible
+        # We only need to refresh the streaming setup if we're using stream_prettify
+        if use_stream_prettify:
+            _, use_stream_prettify_desc, use_regular_prettify_desc, stream_setup_desc = setup_streaming(args)
+        else:
+            # Reuse the existing setup for non-prettify streaming
+            use_stream_prettify_desc = use_stream_prettify
+            use_regular_prettify_desc = use_regular_prettify
+            
+            # Always create a fresh spinner for description
+            stop_spinner = threading.Event()
+            spinner_thread = threading.Thread(
+                target=spinner, 
+                args=("Generating command description...",), 
+                kwargs={"stop_event": stop_spinner, "color": COLORS['cyan']}
+            )
+            spinner_thread.daemon = True
+            
+            # Create a new stream setup with the fresh spinner
+            stream_setup_desc = {
+                'stream_callback': stream_setup.get('stream_callback'),
+                'live_display': stream_setup.get('live_display'),
+                'stop_spinner_func': stream_setup.get('stop_spinner_func'),
+                'stop_spinner': stop_spinner,
+                'spinner_thread': spinner_thread,
+                'stop_spinner_event': stream_setup.get('stop_spinner_event'),
+                'first_content_received': False
+            }
+        
+        # Generate the description
+        description = generate_with_model(
+            client=client, 
+            prompt=describe_prompt, 
+            messages=describe_messages, 
+            args=args, 
+            stream_setup=stream_setup_desc, 
+            use_stream_prettify=use_stream_prettify_desc, 
+            should_stream=should_stream,
+            spinner_message="Generating command description...",
+            temp_override=0.3,
+            logger=logger
+        )
+        
+        if not description:
+            return  # Error already printed
+        
+        # Log the generated description if logging is enabled
+        if logger:
+            logger.log("assistant", description)
+        
+        # Format with proper markdown for streaming prettify - only if needed
+        if use_stream_prettify_desc and stream_setup_desc['stream_callback'] and description:
+            # Format description as markdown for prettier display
+            md_description = f"### Command Description\n\n{description}"
+            # Update the live display with the formatted description
+            stream_setup_desc['stream_callback'](md_description, complete=True)
+        
+        # Display the description
+        display_content(
+            content=description,
+            content_type='description',
+            highlight_lang=highlight_lang,
+            args=args,
+            use_stream_prettify=use_stream_prettify_desc,
+            use_regular_prettify=use_regular_prettify_desc
+        )
+    elif response == 'a' or response == '':
+        print("\nCommand aborted.")
+        
+        # Log the abort if logging is enabled
+        if logger:
+            logger.log("system", "Command aborted by user") 

ngpt/utils/__init__.py

@@ -27,6 +27,7 @@ from .web_search import (
     get_web_search_results,
     format_web_search_results_for_prompt
 )
+from .pipe import process_piped_input
 
 __all__ = [
     "create_logger", "Logger",
@@ -35,5 +36,6 @@ __all__ = [
     "load_cli_config", "set_cli_config_option", "get_cli_config_option", 
     "unset_cli_config_option", "apply_cli_config", "list_cli_config_options",
     "CLI_CONFIG_OPTIONS", "get_cli_config_dir", "get_cli_config_path",
-    "enhance_prompt_with_web_search", "get_web_search_results", "format_web_search_results_for_prompt"
+    "enhance_prompt_with_web_search", "get_web_search_results", "format_web_search_results_for_prompt",
+    "process_piped_input"
 ]

ngpt/utils/pipe.py

@@ -0,0 +1,52 @@
+import sys
+
+def process_piped_input(prompt, logger=None):
+    """Process piped input to be used with a prompt.
+    
+    Args:
+        prompt: The prompt string which may contain a {} placeholder
+        logger: Optional logger instance
+    
+    Returns:
+        str: The processed prompt with piped input inserted at placeholder, or appended
+    """
+    # Import COLORS here to avoid circular imports
+    from ..cli.formatters import COLORS
+    
+    # Only process if stdin is not a TTY (i.e., if we're receiving piped input)
+    if not sys.stdin.isatty():
+        # Read input from stdin
+        stdin_content = sys.stdin.read().strip()
+        
+        # If we have stdin content and prompt is provided
+        if stdin_content and prompt:
+            placeholder = "{}"
+            
+            # Check if the placeholder exists in the prompt
+            if placeholder not in prompt:
+                print(f"{COLORS['yellow']}Warning: Placeholder '{placeholder}' not found in prompt. Appending stdin content to the end.{COLORS['reset']}")
+                processed_prompt = f"{prompt}\n\n{stdin_content}"
+            else:
+                # Replace the placeholder in the prompt with stdin content
+                processed_prompt = prompt.replace(placeholder, stdin_content)
+                
+            # Log if a logger is provided
+            if logger:
+                logger.log("info", f"Processed piped input: Combined prompt with stdin content")
+                
+            return processed_prompt
+        
+        # If we have stdin content but no prompt, just use the stdin content
+        elif stdin_content:
+            return stdin_content
+        elif prompt:
+            # We have prompt but stdin is empty
+            print(f"{COLORS['yellow']}Warning: No stdin content received. Using only the provided prompt.{COLORS['reset']}")
+            return prompt
+        else:
+            # No stdin content and no prompt
+            print(f"{COLORS['yellow']}Error: No stdin content and no prompt provided.{COLORS['reset']}")
+            return ""
+    
+    # If no stdin or no content in stdin, just return the original prompt
+    return prompt 

{ngpt-3.6.0.dist-info → ngpt-3.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 3.6.0
+Version: 3.8.0
 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
@@ -150,7 +150,19 @@ ngpt --code --stream-prettify "function to calculate the Fibonacci sequence"
 ngpt --shell "list all files in the current directory"
 
 # Read from stdin and use the content in your prompt
-echo "What is this text about?" | ngpt -p "Analyze the following text: {}"
+echo "What is this text about?" | ngpt --pipe "Analyze the following text: {}"
+
+# Using here-string (<<<) for quick single-line input 
+ngpt --pipe {} <<< "What is the best way to learn shell redirects?"
+
+# Using standard input redirection to process file contents
+ngpt --pipe "summarise {}" < README.md
+
+# Using here-document (<<EOF) for multiline input
+ngpt --pipe {} << EOF                                              
+What is the best way to learn Golang?
+Provide simple hello world example.
+EOF
 
 # Rewrite text to improve quality while preserving tone and meaning
 echo "your text" | ngpt -r
@@ -173,6 +185,9 @@ ngpt -g --rec-chunk
 # Process a diff file instead of staged changes
 ngpt -g --diff /path/to/changes.diff
 
+# Use piped diff content for commit message generation
+git diff HEAD~1 | ngpt -g --pipe
+
 # Generate a commit message with logging for debugging
 ngpt -g --log commit_log.txt
 
@@ -201,7 +216,7 @@ ngpt --interactive --log conversation.log
 ngpt --log "Tell me about quantum computing"
 
 # Process text from stdin using the {} placeholder
-cat README.md | ngpt -p "Summarize this document: {}"
+cat README.md | ngpt --pipe "Summarize this document: {}"
 
 # Use different model providers by specifying the provider name
 ngpt --provider Groq "Explain quantum computing"
@@ -249,13 +264,14 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 
 ```console
 ❯ ngpt -h
+
 usage: ngpt [-h] [-v] [--language LANGUAGE] [--config [CONFIG]] [--config-index CONFIG_INDEX] [--provider PROVIDER]
             [--remove] [--show-config] [--all] [--list-models] [--list-renderers] [--cli-config [COMMAND ...]]
-            [--api-key API_KEY] [--base-url BASE_URL] [--model MODEL] [--web-search] [--temperature TEMPERATURE]
-            [--top_p TOP_P] [--max_tokens MAX_TOKENS] [--log [FILE]] [--preprompt PREPROMPT] [--no-stream | --prettify |
-            --stream-prettify] [--renderer {auto,rich,glow}] [--rec-chunk] [--diff [FILE]] [--chunk-size CHUNK_SIZE]
-            [--analyses-chunk-size ANALYSES_CHUNK_SIZE] [--max-msg-lines MAX_MSG_LINES]
-            [--max-recursion-depth MAX_RECURSION_DEPTH] [-i | -s | -c | -t | -p | -r | -g]
+            [--api-key API_KEY] [--base-url BASE_URL] [--model MODEL] [--web-search] [--pipe]
+            [--temperature TEMPERATURE] [--top_p TOP_P] [--max_tokens MAX_TOKENS] [--log [FILE]] [--preprompt PREPROMPT]
+            [--no-stream | --prettify | --stream-prettify] [--renderer {auto,rich,glow}] [--rec-chunk] [--diff [FILE]]
+            [--chunk-size CHUNK_SIZE] [--analyses-chunk-size ANALYSES_CHUNK_SIZE] [--max-msg-lines MAX_MSG_LINES]
+            [--max-recursion-depth MAX_RECURSION_DEPTH] [-i | -s | -c | -t | -r | -g]
             [prompt]
 
 nGPT - Interact with AI language models via OpenAI-compatible APIs
@@ -288,6 +304,7 @@ Global Options::
 --base-url BASE_URL                 Base URL for the API
 --model MODEL                       Model to use
 --web-search                        Enable web search capability using DuckDuckGo to enhance prompts with relevant information
+--pipe                              Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content. Can be used with any mode option except --text and --interactive
 --temperature TEMPERATURE           Set temperature (controls randomness, default: 0.7)
 --top_p TOP_P                       Set top_p (controls diversity, default: 1.0)
 --max_tokens MAX_TOKENS             Set max response length in tokens
@@ -308,7 +325,7 @@ Git Commit Message Options::
 --chunk-size CHUNK_SIZE             Number of lines per chunk when chunking is enabled (default: 200)
 --analyses-chunk-size ANALYSES_CHUNK_SIZE Number of lines per chunk when recursively chunking analyses (default: 200)
 --max-msg-lines MAX_MSG_LINES       Maximum number of lines in commit message before condensing (default: 20)
---max-recursion-depth MAX_RECURSION_DEPTH Maximum recursion depth for commit message condensing (default: 3)
+--max-recursion-depth MAX_RECURSION_DEPTH  Maximum recursion depth for commit message condensing (default: 3)
 
 Modes (mutually exclusive)::
 
@@ -316,9 +333,9 @@ Modes (mutually exclusive)::
 -s, --shell                         Generate and execute shell commands
 -c, --code                          Generate code
 -t, --text                          Enter multi-line text input (submit with Ctrl+D)
--p, --pipe                          Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content
 -r, --rewrite                       Rewrite text from stdin to be more natural while preserving tone and meaning
 -g, --gitcommsg                     Generate AI-powered git commit messages from staged changes or diff file
+
 ```
 
 > **Note**: For better visualization of conventional commit messages on GitHub, you can use the [GitHub Commit Labels](https://greasyfork.org/en/scripts/526153-github-commit-labels) userscript, which adds colorful labels to your commits.

{ngpt-3.6.0.dist-info → ngpt-3.8.0.dist-info}/RECORD

@@ -2,27 +2,28 @@ ngpt/__init__.py,sha256=kpKhViLakwMdHZkuLht2vWcjt0uD_5gR33gvMhfXr6w,664
 ngpt/__main__.py,sha256=j3eFYPOtCCFBOGh7NK5IWEnADnTMMSEB9GLyIDoW724,66
 ngpt/client.py,sha256=XjpA2UnvrRvzk6_DzVEddUTzoPlF8koQ-cZURpHoT7c,9041
 ngpt/cli/__init__.py,sha256=hebbDSMGiOd43YNnQP67uzr67Ue6rZPwm2czynr5iZY,43
-ngpt/cli/args.py,sha256=Gjpu6GLgdb0nsV9e54mgrA1wTg9PDR8NwkBA-c0BBKw,12406
+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=oKX7ryTIrsvQRJHVnH2a763pGyNZthq81wkrRILwHLw,28932
+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/modes/__init__.py,sha256=KP7VR6Xw9k1p5Jcu0F38RDxSFvFIzH3j1ThDLNwznUI,363
-ngpt/cli/modes/chat.py,sha256=jfKkrtSkx1gKPsKXDMxZ7BiJiMsCtFHyZCGIdmNQ0fk,7816
-ngpt/cli/modes/code.py,sha256=3avR9OM-D3r4HHfVm2bTfCOlsYQoqgtvU49zGzYfUqw,12513
-ngpt/cli/modes/gitcommsg.py,sha256=Alm1OLxXkuteiDSnDxjmnPvlSggGG2sTlUBAqJaYaN4,46739
+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=EKCPZwvu0MTDpD-nj_oty8vjVQpaF4ucwmTG99LJT6M,10736
-ngpt/cli/modes/shell.py,sha256=kOfOi7uREd98FLHCcON3UuyeUcbQmk8ylOgsELoD810,14168
+ngpt/cli/modes/rewrite.py,sha256=yPmJPPkMHNxrnV-eoM0j6lMNRhdSAMXmcw2s9xG6TIo,10918
+ngpt/cli/modes/shell.py,sha256=Bi5MDteUCOLc-KTecJtyUZKaY9Qab94xpN7qYz1_dOA,29487
 ngpt/cli/modes/text.py,sha256=7t5WWXMFxGkBM5HMP4irbN9aQwxE2YgywjiVPep710k,6417
-ngpt/utils/__init__.py,sha256=qu_66I1Vtav2f1LDiPn5J3DUsbK7o1CSScMcTkYqxoM,1179
+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.6.0.dist-info/METADATA,sha256=cUXBG4wlN36T0SsClQPpfT-SfeLYFdg2iy_n3Krrpx4,23912
-ngpt-3.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-3.6.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
-ngpt-3.6.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-3.6.0.dist-info/RECORD,,
+ngpt-3.8.0.dist-info/METADATA,sha256=O_lTxBgnFYmKUftGTShWc7MFdHzjXRPURp2QJVhtbmo,24503
+ngpt-3.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-3.8.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-3.8.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-3.8.0.dist-info/RECORD,,