ngpt 2.9.0__py3-none-any.whl → 2.9.2__py3-none-any.whl

ngpt/cli/modes/code.py

@@ -0,0 +1,97 @@
+from ..formatters import COLORS
+from ..renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer, show_available_renderers
+import sys
+
+def code_mode(client, args):
+    """Handle the code generation mode.
+    
+    Args:
+        client: The NGPTClient instance
+        args: The parsed command-line arguments
+    """
+    if args.prompt is None:
+        try:
+            print("Enter code description: ", end='')
+            prompt = input()
+        except KeyboardInterrupt:
+            print("\nInput cancelled by user. Exiting gracefully.")
+            sys.exit(130)
+    else:
+        prompt = args.prompt
+
+    # Setup for streaming and prettify logic
+    stream_callback = None
+    live_display = None
+    should_stream = True # Default to streaming
+    use_stream_prettify = False
+    use_regular_prettify = 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 = 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: Streaming disabled to enable regular markdown rendering (--prettify).{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
+    # else: Default is should_stream = True
+    
+    print("\nGenerating code...")
+    
+    # Start live display if using stream-prettify
+    if use_stream_prettify and live_display:
+        live_display.start()
+        
+    generated_code = client.generate_code(
+        prompt=prompt, 
+        language=args.language, 
+        web_search=args.web_search,
+        temperature=args.temperature, 
+        top_p=args.top_p,
+        max_tokens=args.max_tokens,
+        # Request markdown from API if any prettify option is active
+        markdown_format=use_regular_prettify or use_stream_prettify,
+        stream=should_stream,
+        stream_callback=stream_callback
+    )
+    
+    # Stop live display if using stream-prettify
+    if use_stream_prettify and live_display:
+        live_display.stop()
+        
+    # 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}") 

ngpt/cli/modes/shell.py

@@ -0,0 +1,46 @@
+from ..formatters import COLORS
+import subprocess
+import sys
+
+def shell_mode(client, args):
+    """Handle the shell command generation mode.
+    
+    Args:
+        client: The NGPTClient instance
+        args: The parsed command-line arguments
+    """
+    if args.prompt is None:
+        try:
+            print("Enter shell command description: ", end='')
+            prompt = input()
+        except KeyboardInterrupt:
+            print("\nInput cancelled by user. Exiting gracefully.")
+            sys.exit(130)
+    else:
+        prompt = args.prompt
+        
+    command = client.generate_shell_command(prompt, web_search=args.web_search, 
+                                         temperature=args.temperature, top_p=args.top_p,
+                                         max_tokens=args.max_tokens)
+    if not command:
+        return  # Error already printed by client
+        
+    print(f"\nGenerated command: {command}")
+    
+    try:
+        print("Do you want to execute this command? [y/N] ", end='')
+        response = input().lower()
+    except KeyboardInterrupt:
+        print("\nCommand execution cancelled by user.")
+        return
+        
+    if response == 'y' or response == 'yes':
+        try:
+            try:
+                print("\nExecuting command... (Press Ctrl+C to cancel)")
+                result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+                print(f"\nOutput:\n{result.stdout}")
+            except KeyboardInterrupt:
+                print("\nCommand execution cancelled by user.")
+        except subprocess.CalledProcessError as e:
+            print(f"\nError:\n{e.stderr}") 

ngpt/cli/modes/text.py

@@ -0,0 +1,72 @@
+from ..formatters import COLORS
+from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..ui import get_multiline_input
+
+def text_mode(client, args):
+    """Handle the multi-line text input mode.
+    
+    Args:
+        client: The NGPTClient instance
+        args: The parsed command-line arguments
+    """
+    if args.prompt is not None:
+        prompt = args.prompt
+    else:
+        prompt = get_multiline_input()
+        if prompt is None:
+            # Input was cancelled or empty
+            print("Exiting.")
+            return
+    
+    print("\nSubmission successful. Waiting for response...")
+    
+    # Create messages array with preprompt if available
+    messages = None
+    if args.preprompt:
+        messages = [
+            {"role": "system", "content": args.preprompt},
+            {"role": "user", "content": prompt}
+        ]
+    
+    # Set default streaming behavior based on --no-stream and --prettify arguments
+    should_stream = not args.no_stream and not args.prettify
+    
+    # If stream-prettify is enabled
+    stream_callback = None
+    live_display = None
+    
+    if args.stream_prettify:
+        should_stream = True  # Enable streaming
+        # This is the standard mode, not interactive
+        live_display, stream_callback = prettify_streaming_markdown(args.renderer)
+        if not live_display:
+            # Fallback to normal prettify if live display setup failed
+            args.prettify = True
+            args.stream_prettify = False
+            should_stream = False
+            print(f"{COLORS['yellow']}Falling back to regular prettify mode.{COLORS['reset']}")
+    
+    # If regular prettify is enabled with streaming, inform the user
+    if args.prettify and not args.no_stream:
+        print(f"{COLORS['yellow']}Note: Streaming disabled to enable markdown rendering.{COLORS['reset']}")
+    
+    # Start live display if using stream-prettify
+    if args.stream_prettify and live_display:
+        live_display.start()
+    
+    response = client.chat(prompt, stream=should_stream, web_search=args.web_search,
+                       temperature=args.temperature, top_p=args.top_p,
+                       max_tokens=args.max_tokens, messages=messages,
+                       markdown_format=args.prettify or args.stream_prettify,
+                       stream_callback=stream_callback)
+    
+    # Stop live display if using stream-prettify
+    if args.stream_prettify and live_display:
+        live_display.stop()
+        
+    # 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) 

ngpt/cli/renderers.py

@@ -0,0 +1,258 @@
+import sys
+import os
+import shutil
+import subprocess
+import tempfile
+from .formatters import COLORS
+
+# Try to import markdown rendering libraries
+try:
+    import rich
+    from rich.markdown import Markdown
+    from rich.console import Console
+    from rich.live import Live
+    from rich.text import Text
+    from rich.panel import Panel
+    import rich.box
+    HAS_RICH = True
+except ImportError:
+    HAS_RICH = False
+
+# Try to import the glow command if available
+def has_glow_installed():
+    """Check if glow is installed in the system."""
+    return shutil.which("glow") is not None
+
+HAS_GLOW = has_glow_installed()
+
+def has_markdown_renderer(renderer='auto'):
+    """Check if the specified markdown renderer is available.
+    
+    Args:
+        renderer (str): Which renderer to check: 'auto', 'rich', or 'glow'
+    
+    Returns:
+        bool: True if the renderer is available, False otherwise
+    """
+    if renderer == 'auto':
+        return HAS_RICH or HAS_GLOW
+    elif renderer == 'rich':
+        return HAS_RICH
+    elif renderer == 'glow':
+        return HAS_GLOW
+    else:
+        return False
+
+def show_available_renderers():
+    """Show which markdown renderers are available and their status."""
+    print(f"\n{COLORS['cyan']}{COLORS['bold']}Available Markdown Renderers:{COLORS['reset']}")
+    
+    if HAS_GLOW:
+        print(f"  {COLORS['green']}✓ Glow{COLORS['reset']} - Terminal-based Markdown renderer")
+    else:
+        print(f"  {COLORS['yellow']}✗ Glow{COLORS['reset']} - Not installed (https://github.com/charmbracelet/glow)")
+        
+    if HAS_RICH:
+        print(f"  {COLORS['green']}✓ Rich{COLORS['reset']} - Python library for terminal formatting (Recommended)")
+    else:
+        print(f"  {COLORS['yellow']}✗ Rich{COLORS['reset']} - Not installed (pip install \"ngpt[full]\" or pip install rich)")
+        
+    if not HAS_GLOW and not HAS_RICH:
+        print(f"\n{COLORS['yellow']}To enable prettified markdown output, install one of the above renderers.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}For Rich: pip install \"ngpt[full]\" or pip install rich{COLORS['reset']}")
+    else:
+        renderers = []
+        if HAS_RICH:
+            renderers.append("rich")
+        if HAS_GLOW:
+            renderers.append("glow")
+        print(f"\n{COLORS['green']}Usage examples:{COLORS['reset']}")
+        print(f"  ngpt --prettify \"Your prompt here\"                {COLORS['gray']}# Beautify markdown responses{COLORS['reset']}")
+        print(f"  ngpt -c --prettify \"Write a sort function\"        {COLORS['gray']}# Syntax highlight generated code{COLORS['reset']}")
+        if renderers:
+            renderer = renderers[0]
+            print(f"  ngpt --prettify --renderer={renderer} \"Your prompt\"  {COLORS['gray']}# Specify renderer{COLORS['reset']}")
+    
+    print("")
+
+def warn_if_no_markdown_renderer(renderer='auto'):
+    """Warn the user if the specified markdown renderer is not available.
+    
+    Args:
+        renderer (str): Which renderer to check: 'auto', 'rich', or 'glow'
+    
+    Returns:
+        bool: True if the renderer is available, False otherwise
+    """
+    if has_markdown_renderer(renderer):
+        return True
+    
+    if renderer == 'auto':
+        print(f"{COLORS['yellow']}Warning: No markdown rendering library available.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Install with: pip install \"ngpt[full]\"{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Or install 'glow' from https://github.com/charmbracelet/glow{COLORS['reset']}")
+    elif renderer == 'rich':
+        print(f"{COLORS['yellow']}Warning: Rich is not available.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Install with: pip install \"ngpt[full]\" or pip install rich{COLORS['reset']}")
+    elif renderer == 'glow':
+        print(f"{COLORS['yellow']}Warning: Glow is not available.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Install from https://github.com/charmbracelet/glow{COLORS['reset']}")
+    else:
+        print(f"{COLORS['yellow']}Error: Invalid renderer '{renderer}'. Use 'auto', 'rich', or 'glow'.{COLORS['reset']}")
+    
+    return False
+
+def prettify_markdown(text, renderer='auto'):
+    """Render markdown text with beautiful formatting using either Rich or Glow.
+    
+    The function handles both general markdown and code blocks with syntax highlighting.
+    For code generation mode, it automatically wraps the code in markdown code blocks.
+    
+    Args:
+        text (str): Markdown text to render
+        renderer (str): Which renderer to use: 'auto', 'rich', or 'glow'
+        
+    Returns:
+        bool: True if rendering was successful, False otherwise
+    """
+    # For 'auto', prefer rich if available, otherwise use glow
+    if renderer == 'auto':
+        if HAS_RICH:
+            return prettify_markdown(text, 'rich')
+        elif HAS_GLOW:
+            return prettify_markdown(text, 'glow')
+        else:
+            return False
+    
+    # Use glow for rendering
+    elif renderer == 'glow':
+        if not HAS_GLOW:
+            print(f"{COLORS['yellow']}Warning: Glow is not available. Install from https://github.com/charmbracelet/glow{COLORS['reset']}")
+            # Fall back to rich if available
+            if HAS_RICH:
+                print(f"{COLORS['yellow']}Falling back to Rich renderer.{COLORS['reset']}")
+                return prettify_markdown(text, 'rich')
+            return False
+            
+        # Use glow
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.md', delete=False) as temp:
+            temp_filename = temp.name
+            temp.write(text)
+            
+        try:
+            # Execute glow on the temporary file
+            subprocess.run(["glow", temp_filename], check=True)
+            os.unlink(temp_filename)
+            return True
+        except Exception as e:
+            print(f"{COLORS['yellow']}Error using glow: {str(e)}{COLORS['reset']}")
+            os.unlink(temp_filename)
+            
+            # Fall back to rich if available
+            if HAS_RICH:
+                print(f"{COLORS['yellow']}Falling back to Rich renderer.{COLORS['reset']}")
+                return prettify_markdown(text, 'rich')
+            return False
+    
+    # Use rich for rendering
+    elif renderer == 'rich':
+        if not HAS_RICH:
+            print(f"{COLORS['yellow']}Warning: Rich is not available.{COLORS['reset']}")
+            print(f"{COLORS['yellow']}Install with: pip install \"ngpt[full]\" or pip install rich{COLORS['reset']}")
+            # Fall back to glow if available
+            if HAS_GLOW:
+                print(f"{COLORS['yellow']}Falling back to Glow renderer.{COLORS['reset']}")
+                return prettify_markdown(text, 'glow')
+            return False
+            
+        # Use rich
+        try:
+            console = Console()
+            md = Markdown(text)
+            console.print(md)
+            return True
+        except Exception as e:
+            print(f"{COLORS['yellow']}Error using rich for markdown: {str(e)}{COLORS['reset']}")
+            return False
+    
+    # Invalid renderer specified
+    else:
+        print(f"{COLORS['yellow']}Error: Invalid renderer '{renderer}'. Use 'auto', 'rich', or 'glow'.{COLORS['reset']}")
+        return False
+
+def prettify_streaming_markdown(renderer='rich', is_interactive=False, header_text=None):
+    """Set up streaming markdown rendering.
+    
+    This function creates a live display context for rendering markdown
+    that can be updated in real-time as streaming content arrives.
+    
+    Args:
+        renderer (str): Which renderer to use (currently only 'rich' is supported for streaming)
+        is_interactive (bool): Whether this is being used in interactive mode
+        header_text (str): Header text to include at the top (for interactive mode)
+        
+    Returns:
+        tuple: (live_display, update_function) if successful, (None, None) otherwise
+    """
+    # Only warn if explicitly specifying a renderer other than 'rich' or 'auto'
+    if renderer != 'rich' and renderer != 'auto':
+        print(f"{COLORS['yellow']}Warning: Streaming prettify only supports 'rich' renderer currently.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Falling back to Rich renderer.{COLORS['reset']}")
+    
+    # Always use rich for streaming prettify
+    renderer = 'rich'
+    
+    if not HAS_RICH:
+        print(f"{COLORS['yellow']}Warning: Rich is not available for streaming prettify.{COLORS['reset']}")
+        print(f"{COLORS['yellow']}Install with: pip install \"ngpt[full]\" or pip install rich{COLORS['reset']}")
+        return None, None
+        
+    try:
+        from rich.live import Live
+        from rich.markdown import Markdown
+        from rich.console import Console
+        from rich.text import Text
+        from rich.panel import Panel
+        import rich.box
+        
+        console = Console()
+        
+        # Create an empty markdown object to start with
+        if is_interactive and header_text:
+            # For interactive mode, include header in a panel
+            # Clean up the header text to avoid duplication - use just "🤖 nGPT" instead of "╭─ 🤖 nGPT"
+            clean_header = "🤖 nGPT"
+            panel_title = Text(clean_header, style="cyan bold")
+            
+            # Create a nicer, more compact panel
+            padding = (1, 1)  # Less horizontal padding (left, right)
+            md_obj = Panel(
+                Markdown(""),
+                title=panel_title,
+                title_align="left",
+                border_style="cyan",
+                padding=padding,
+                width=console.width - 4,  # Make panel slightly narrower than console
+                box=rich.box.ROUNDED
+            )
+        else:
+            md_obj = Markdown("")
+        
+        # Initialize the Live display with an empty markdown
+        live = Live(md_obj, console=console, refresh_per_second=10)
+        
+        # Define an update function that will be called with new content
+        def update_content(content):
+            nonlocal md_obj
+            if is_interactive and header_text:
+                # Update the panel content
+                md_obj.renderable = Markdown(content)
+                live.update(md_obj)
+            else:
+                md_obj = Markdown(content)
+                live.update(md_obj)
+            
+        return live, update_content
+    except Exception as e:
+        print(f"{COLORS['yellow']}Error setting up Rich streaming display: {str(e)}{COLORS['reset']}")
+        return None, None 

ngpt/cli/ui.py

@@ -0,0 +1,155 @@
+import sys
+import shutil
+from .formatters import COLORS
+
+# Optional imports for enhanced UI
+try:
+    from prompt_toolkit import prompt as pt_prompt
+    from prompt_toolkit.styles import Style
+    from prompt_toolkit.key_binding import KeyBindings
+    from prompt_toolkit.formatted_text import HTML
+    from prompt_toolkit.layout.containers import HSplit, Window
+    from prompt_toolkit.layout.layout import Layout
+    from prompt_toolkit.layout.controls import FormattedTextControl
+    from prompt_toolkit.application import Application
+    from prompt_toolkit.widgets import TextArea
+    from prompt_toolkit.layout.margins import ScrollbarMargin
+    from prompt_toolkit.filters import to_filter
+    from prompt_toolkit.history import InMemoryHistory
+    HAS_PROMPT_TOOLKIT = True
+except ImportError:
+    HAS_PROMPT_TOOLKIT = False
+
+def create_multiline_editor():
+    """Create a multi-line editor with prompt_toolkit.
+    
+    Returns:
+        tuple: (app, has_prompt_toolkit) - the editor application and a boolean
+               indicating if prompt_toolkit is available
+    """
+    if not HAS_PROMPT_TOOLKIT:
+        return None, False
+        
+    try:
+        # Create key bindings
+        kb = KeyBindings()
+        
+        # Explicitly bind Ctrl+D to exit
+        @kb.add('c-d')
+        def _(event):
+            event.app.exit(result=event.app.current_buffer.text)
+            
+        # Explicitly bind Ctrl+C to exit
+        @kb.add('c-c')
+        def _(event):
+            event.app.exit(result=None)
+            print("\nInput cancelled by user. Exiting gracefully.")
+            sys.exit(130)
+        
+        # Get terminal dimensions
+        term_width, term_height = shutil.get_terminal_size()
+        
+        # Create a styled TextArea
+        text_area = TextArea(
+            style="class:input-area",
+            multiline=True,
+            wrap_lines=True,
+            width=term_width - 10,
+            height=min(15, term_height - 10),
+            prompt=HTML("<ansicyan><b>> </b></ansicyan>"),
+            scrollbar=True,
+            focus_on_click=True,
+            lexer=None,
+        )
+        text_area.window.right_margins = [ScrollbarMargin(display_arrows=True)]
+        
+        # Create a title bar
+        title_bar = FormattedTextControl(
+            HTML("<ansicyan><b> nGPT Multi-line Editor </b></ansicyan>")
+        )
+        
+        # Create a status bar with key bindings info
+        status_bar = FormattedTextControl(
+            HTML("<ansiblue><b>Ctrl+D</b></ansiblue>: Submit | <ansiblue><b>Ctrl+C</b></ansiblue>: Cancel | <ansiblue><b>↑↓←→</b></ansiblue>: Navigate")
+        )
+        
+        # Create the layout
+        layout = Layout(
+            HSplit([
+                Window(title_bar, height=1),
+                Window(height=1, char="─", style="class:separator"),
+                text_area,
+                Window(height=1, char="─", style="class:separator"),
+                Window(status_bar, height=1),
+            ])
+        )
+        
+        # Create a style
+        style = Style.from_dict({
+            "separator": "ansicyan",
+            "input-area": "fg:ansiwhite",
+            "cursor": "bg:ansiwhite fg:ansiblack",
+        })
+        
+        # Create and return the application
+        app = Application(
+            layout=layout,
+            full_screen=False,
+            key_bindings=kb,
+            style=style,
+            mouse_support=True,
+        )
+        
+        return app, True
+        
+    except Exception as e:
+        print(f"Error creating editor: {e}")
+        return None, False
+
+def get_multiline_input():
+    """Get multi-line input from the user using either prompt_toolkit or standard input.
+    
+    Returns:
+        str: The user's input text, or None if cancelled
+    """
+    editor_app, has_editor = create_multiline_editor()
+    
+    if has_editor and editor_app:
+        print("\033[94m\033[1m" + "Multi-line Input Mode" + "\033[0m")
+        print("Press Ctrl+D to submit, Ctrl+C to exit")
+        print("Use arrow keys to navigate, Enter for new line")
+        
+        try:
+            prompt = editor_app.run()
+            if not prompt or not prompt.strip():
+                print("Empty prompt. Exiting.")
+                return None
+            return prompt
+        except KeyboardInterrupt:
+            print("\nInput cancelled by user. Exiting gracefully.")
+            return None
+    else:
+        # Fallback to standard input with a better implementation
+        print("Enter your multi-line prompt (press Ctrl+D to submit):")
+        if not HAS_PROMPT_TOOLKIT:
+            print("Note: Install 'prompt_toolkit' package for an enhanced input experience")
+        
+        # Use a more robust approach for multiline input without prompt_toolkit
+        lines = []
+        try:
+            while True:
+                try:
+                    line = input()
+                    lines.append(line)
+                except EOFError:  # Ctrl+D was pressed
+                    break
+            
+            prompt = "\n".join(lines)
+            if not prompt.strip():
+                print("Empty prompt. Exiting.")
+                return None
+            return prompt
+            
+        except KeyboardInterrupt:
+            print("\nInput cancelled by user. Exiting gracefully.")
+            return None