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

ngpt/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import main
+
+__all__ = ['main']

ngpt/cli/config_manager.py

@@ -0,0 +1,71 @@
+import sys
+from ..config import get_config_path, load_configs, add_config_entry, remove_config_entry
+from .formatters import COLORS
+
+def show_config_help():
+    """Display help information about configuration."""
+    print(f"\n{COLORS['green']}{COLORS['bold']}Configuration Help:{COLORS['reset']}")
+    print(f"  1. {COLORS['cyan']}Create a config file at one of these locations:{COLORS['reset']}")
+    if sys.platform == "win32":
+        print(f"     - {COLORS['yellow']}%APPDATA%\\ngpt\\ngpt.conf{COLORS['reset']}")
+    elif sys.platform == "darwin":
+        print(f"     - {COLORS['yellow']}~/Library/Application Support/ngpt/ngpt.conf{COLORS['reset']}")
+    else:
+        print(f"     - {COLORS['yellow']}~/.config/ngpt/ngpt.conf{COLORS['reset']}")
+    
+    print(f"  2. {COLORS['cyan']}Format your config file as JSON:{COLORS['reset']}")
+    print(f"""{COLORS['yellow']}     [
+       {{
+         "api_key": "your-api-key-here",
+         "base_url": "https://api.openai.com/v1/",
+         "provider": "OpenAI",
+         "model": "gpt-3.5-turbo"
+       }},
+       {{
+         "api_key": "your-second-api-key",
+         "base_url": "http://localhost:1337/v1/",
+         "provider": "Another Provider",
+         "model": "different-model"
+       }}
+     ]{COLORS['reset']}""")
+    
+    print(f"  3. {COLORS['cyan']}Or set environment variables:{COLORS['reset']}")
+    print(f"     - {COLORS['yellow']}OPENAI_API_KEY{COLORS['reset']}")
+    print(f"     - {COLORS['yellow']}OPENAI_BASE_URL{COLORS['reset']}")
+    print(f"     - {COLORS['yellow']}OPENAI_MODEL{COLORS['reset']}")
+    
+    print(f"  4. {COLORS['cyan']}Or provide command line arguments:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --api-key your-key --base-url https://api.example.com --model your-model \"Your prompt\"{COLORS['reset']}")
+    
+    print(f"  5. {COLORS['cyan']}Use --config-index to specify which configuration to use or edit:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --config-index 1 \"Your prompt\"{COLORS['reset']}")
+    
+    print(f"  6. {COLORS['cyan']}Use --provider to specify which configuration to use by provider name:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --provider Gemini \"Your prompt\"{COLORS['reset']}")
+    
+    print(f"  7. {COLORS['cyan']}Use --config without arguments to add a new configuration:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --config{COLORS['reset']}")
+    print(f"     Or specify an index or provider to edit an existing configuration:")
+    print(f"     {COLORS['yellow']}ngpt --config --config-index 1{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --config --provider Gemini{COLORS['reset']}")
+
+    print(f"  8. {COLORS['cyan']}Remove a configuration by index or provider:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --config --remove --config-index 1{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --config --remove --provider Gemini{COLORS['reset']}")
+
+    print(f"  9. {COLORS['cyan']}List available models for the current configuration:{COLORS['reset']}")
+    print(f"     {COLORS['yellow']}ngpt --list-models{COLORS['reset']}")
+
+def check_config(config):
+    """Check config for common issues and provide guidance."""
+    if not config.get("api_key"):
+        print(f"{COLORS['yellow']}{COLORS['bold']}Error: API key is not set.{COLORS['reset']}")
+        show_config_help()
+        return False
+        
+    # Check for common URL mistakes
+    base_url = config.get("base_url", "")
+    if base_url and not (base_url.startswith("http://") or base_url.startswith("https://")):
+        print(f"{COLORS['yellow']}Warning: Base URL '{base_url}' doesn't start with http:// or https://{COLORS['reset']}")
+    
+    return True 

ngpt/cli/formatters.py

@@ -0,0 +1,239 @@
+import sys
+import os
+import shutil
+import argparse
+import re
+import textwrap
+import ctypes
+
+# ANSI color codes for terminal output
+COLORS = {
+    "reset": "\033[0m",
+    "bold": "\033[1m",
+    "cyan": "\033[36m",
+    "green": "\033[32m", 
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "gray": "\033[90m",
+    "bg_blue": "\033[44m",
+    "bg_cyan": "\033[46m"
+}
+
+# Check if ANSI colors are supported
+def supports_ansi_colors():
+    """Check if the current terminal supports ANSI colors."""
+    
+    # If not a TTY, probably redirected, so no color
+    if not sys.stdout.isatty():
+        return False
+        
+    # Windows specific checks
+    if sys.platform == "win32":
+        try:
+            # Windows 10+ supports ANSI colors in cmd/PowerShell
+            kernel32 = ctypes.windll.kernel32
+            
+            # Try to enable ANSI color support
+            kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+            
+            # Check if TERM_PROGRAM is set (WSL/ConEmu/etc.)
+            if os.environ.get('TERM_PROGRAM') or os.environ.get('WT_SESSION'):
+                return True
+                
+            # Check Windows version - 10+ supports ANSI natively
+            winver = sys.getwindowsversion()
+            if winver.major >= 10:
+                return True
+                
+            return False
+        except Exception:
+            return False
+    
+    # Most UNIX systems support ANSI colors
+    return True
+
+# Initialize color support
+HAS_COLOR = supports_ansi_colors()
+
+# If we're on Windows, use brighter colors that work better in PowerShell
+if sys.platform == "win32" and HAS_COLOR:
+    COLORS["magenta"] = "\033[95m"  # Bright magenta for metavars
+    COLORS["cyan"] = "\033[96m"     # Bright cyan for options
+
+# If no color support, use empty color codes
+if not HAS_COLOR:
+    for key in COLORS:
+        COLORS[key] = ""
+
+# Custom help formatter with color support
+class ColoredHelpFormatter(argparse.HelpFormatter):
+    """Help formatter that properly handles ANSI color codes without breaking alignment."""
+    
+    def __init__(self, prog):
+        # Get terminal size for dynamic width adjustment
+        try:
+            self.term_width = shutil.get_terminal_size().columns
+        except:
+            self.term_width = 80  # Default if we can't detect terminal width
+        
+        # Calculate dynamic layout values based on terminal width
+        self.formatter_width = self.term_width - 2  # Leave some margin
+        
+        # For very wide terminals, limit the width to maintain readability
+        if self.formatter_width > 120:
+            self.formatter_width = 120
+            
+        # Calculate help position based on terminal width (roughly 1/3 of width)
+        self.help_position = min(max(20, int(self.term_width * 0.33)), 36)
+        
+        # Initialize the parent class with dynamic values
+        super().__init__(prog, max_help_position=self.help_position, width=self.formatter_width)
+        
+        # Calculate wrap width based on remaining space after help position
+        self.wrap_width = self.formatter_width - self.help_position - 5
+        
+        # Set up the text wrapper for help text
+        self.ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+        self.wrapper = textwrap.TextWrapper(width=self.wrap_width)
+        
+    def _strip_ansi(self, s):
+        """Strip ANSI escape sequences for width calculations"""
+        return self.ansi_escape.sub('', s)
+        
+    def _colorize(self, text, color, bold=False):
+        """Helper to consistently apply color with optional bold"""
+        if bold:
+            return f"{COLORS['bold']}{COLORS[color]}{text}{COLORS['reset']}"
+        return f"{COLORS[color]}{text}{COLORS['reset']}"
+        
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            # For positional arguments
+            metavar = self._format_args(action, action.dest.upper())
+            return self._colorize(metavar, 'cyan', bold=True)
+        else:
+            # For optional arguments with different color for metavar
+            if action.nargs != argparse.SUPPRESS:
+                default = self._get_default_metavar_for_optional(action)
+                args_string = self._format_args(action, default)
+                
+                # Color option name and metavar differently
+                option_part = ', '.join(action.option_strings)
+                colored_option = self._colorize(option_part, 'cyan', bold=True)
+                
+                if args_string:
+                    # Make metavars more visible with brackets and color
+                    # If HAS_COLOR is False, brackets will help in PowerShell
+                    if not HAS_COLOR:
+                        # Add brackets to make metavars stand out even without color
+                        formatted_args = f"<{args_string}>"
+                    else:
+                        # Use color for metavar
+                        formatted_args = self._colorize(args_string, 'magenta')
+                    
+                    return f"{colored_option} {formatted_args}"
+                else:
+                    return colored_option
+            else:
+                return self._colorize(', '.join(action.option_strings), 'cyan', bold=True)
+        
+    def _format_usage(self, usage, actions, groups, prefix):
+        usage_text = super()._format_usage(usage, actions, groups, prefix)
+        
+        # Replace "usage:" with colored version
+        colored_usage = self._colorize("usage:", 'green', bold=True)
+        usage_text = usage_text.replace("usage:", colored_usage)
+        
+        # We won't color metavars in usage text as it breaks the formatting
+        # Just return with the colored usage prefix
+        return usage_text
+    
+    def _join_parts(self, part_strings):
+        """Override to fix any potential formatting issues with section joins"""
+        return '\n'.join([part for part in part_strings if part])
+        
+    def start_section(self, heading):
+        # Remove the colon as we'll add it with color
+        if heading.endswith(':'):
+            heading = heading[:-1]
+        heading_text = f"{self._colorize(heading, 'yellow', bold=True)}:"
+        super().start_section(heading_text)
+            
+    def _get_help_string(self, action):
+        # Add color to help strings
+        help_text = action.help
+        if help_text:
+            return help_text.replace('(default:', f"{COLORS['gray']}(default:") + COLORS['reset']
+        return help_text
+        
+    def _wrap_help_text(self, text, initial_indent="", subsequent_indent="  "):
+        """Wrap long help text to prevent overflow"""
+        if not text:
+            return text
+            
+        # Strip ANSI codes for width calculation
+        clean_text = self._strip_ansi(text)
+        
+        # If the text is already short enough, return it as is
+        if len(clean_text) <= self.wrap_width:
+            return text
+            
+        # Handle any existing ANSI codes
+        has_ansi = text != clean_text
+        wrap_text = clean_text
+        
+        # Wrap the text
+        lines = self.wrapper.wrap(wrap_text)
+        
+        # Add indentation to all but the first line
+        wrapped = lines[0]
+        for line in lines[1:]:
+            wrapped += f"\n{subsequent_indent}{line}"
+            
+        # Re-add the ANSI codes if they were present
+        if has_ansi and text.endswith(COLORS['reset']):
+            wrapped += COLORS['reset']
+            
+        return wrapped
+        
+    def _format_action(self, action):
+        # For subparsers, just return the regular formatting
+        if isinstance(action, argparse._SubParsersAction):
+            return super()._format_action(action)
+            
+        # Get the action header with colored parts (both option names and metavars)
+        # The coloring is now done in _format_action_invocation
+        action_header = self._format_action_invocation(action)
+        
+        # Format help text
+        help_text = self._expand_help(action)
+        
+        # Get the raw lengths without ANSI codes for formatting
+        raw_header_len = len(self._strip_ansi(action_header))
+        
+        # Calculate the indent for the help text
+        help_position = min(self._action_max_length + 2, self._max_help_position)
+        help_indent = ' ' * help_position
+        
+        # If the action header is too long, put help on the next line
+        if raw_header_len > help_position:
+            # An action header that's too long gets a line break
+            # Wrap the help text with proper indentation
+            wrapped_help = self._wrap_help_text(help_text, subsequent_indent=help_indent)
+            line = f"{action_header}\n{help_indent}{wrapped_help}"
+        else:
+            # Standard formatting with proper spacing
+            padding = ' ' * (help_position - raw_header_len)
+            # Wrap the help text with proper indentation
+            wrapped_help = self._wrap_help_text(help_text, subsequent_indent=help_indent)
+            line = f"{action_header}{padding}{wrapped_help}"
+            
+        # Handle subactions
+        if action.help is argparse.SUPPRESS:
+            return line
+            
+        if not action.help:
+            return line
+            
+        return line 

ngpt/cli/interactive.py

@@ -0,0 +1,275 @@
+import sys
+import shutil
+import datetime
+import traceback
+from .formatters import COLORS
+from .renderers import prettify_markdown, prettify_streaming_markdown
+
+# 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.history import InMemoryHistory
+    HAS_PROMPT_TOOLKIT = True
+except ImportError:
+    HAS_PROMPT_TOOLKIT = False
+
+def interactive_chat_session(client, web_search=False, no_stream=False, temperature=0.7, top_p=1.0, max_tokens=None, log_file=None, preprompt=None, prettify=False, renderer='auto', stream_prettify=False):
+    """Start an interactive chat session with the AI.
+    
+    Args:
+        client: The NGPTClient instance
+        web_search: Whether to enable web search capability
+        no_stream: Whether to disable streaming
+        temperature: Controls randomness in the response
+        top_p: Controls diversity via nucleus sampling
+        max_tokens: Maximum number of tokens to generate in each response
+        log_file: Optional filepath to log conversation to
+        preprompt: Custom system prompt to control AI behavior
+        prettify: Whether to enable markdown rendering
+        renderer: Which markdown renderer to use
+        stream_prettify: Whether to enable streaming with prettify
+    """
+    # Get terminal width for better formatting
+    try:
+        term_width = shutil.get_terminal_size().columns
+    except:
+        term_width = 80  # Default fallback
+    
+    # Improved visual header with better layout
+    header = f"{COLORS['cyan']}{COLORS['bold']}🤖 nGPT Interactive Chat Session 🤖{COLORS['reset']}"
+    print(f"\n{header}")
+    
+    # Create a separator line - use a consistent separator length for all lines
+    separator_length = min(40, term_width - 10)
+    separator = f"{COLORS['gray']}{'─' * separator_length}{COLORS['reset']}"
+    print(separator)
+    
+    # Group commands into categories with better formatting
+    print(f"\n{COLORS['cyan']}Navigation:{COLORS['reset']}")
+    print(f"  {COLORS['yellow']}↑/↓{COLORS['reset']} : Browse input history")
+    
+    print(f"\n{COLORS['cyan']}Session Commands:{COLORS['reset']}")
+    print(f"  {COLORS['yellow']}history{COLORS['reset']} : Show conversation history")
+    print(f"  {COLORS['yellow']}clear{COLORS['reset']}   : Reset conversation")
+    print(f"  {COLORS['yellow']}exit{COLORS['reset']}    : End session")
+    
+    print(f"\n{separator}\n")
+    
+    # Initialize log file if provided
+    log_handle = None
+    if log_file:
+        try:
+            timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            log_handle = open(log_file, 'a', encoding='utf-8')
+            log_handle.write(f"\n--- nGPT Session Log: {sys.argv} ---\n")
+            log_handle.write(f"Started at: {timestamp}\n\n")
+            print(f"{COLORS['green']}Logging conversation to: {log_file}{COLORS['reset']}")
+        except Exception as e:
+            print(f"{COLORS['yellow']}Warning: Could not open log file: {str(e)}{COLORS['reset']}")
+            log_handle = None
+    
+    # Custom separator - use the same length for consistency
+    def print_separator():
+        print(f"\n{separator}\n")
+    
+    # Initialize conversation history
+    system_prompt = preprompt if preprompt else "You are a helpful assistant."
+    
+    # Add markdown formatting instruction to system prompt if prettify is enabled
+    if prettify:
+        if system_prompt:
+            system_prompt += " You can use markdown formatting in your responses where appropriate."
+        else:
+            system_prompt = "You are a helpful assistant. You can use markdown formatting in your responses where appropriate."
+    
+    conversation = []
+    system_message = {"role": "system", "content": system_prompt}
+    conversation.append(system_message)
+    
+    # Log system prompt if logging is enabled
+    if log_handle and preprompt:
+        log_handle.write(f"System: {system_prompt}\n\n")
+        log_handle.flush()
+    
+    # Initialize prompt_toolkit history
+    prompt_history = InMemoryHistory() if HAS_PROMPT_TOOLKIT else None
+    
+    # Decorative chat headers with rounded corners
+    def user_header():
+        return f"{COLORS['cyan']}{COLORS['bold']}╭─ 👤 You {COLORS['reset']}"
+    
+    def ngpt_header():
+        return f"{COLORS['green']}{COLORS['bold']}╭─ 🤖 nGPT {COLORS['reset']}"
+    
+    # Function to display conversation history
+    def display_history():
+        if len(conversation) <= 1:  # Only system message
+            print(f"\n{COLORS['yellow']}No conversation history yet.{COLORS['reset']}")
+            return
+            
+        print(f"\n{COLORS['cyan']}{COLORS['bold']}Conversation History:{COLORS['reset']}")
+        print(separator)
+        
+        # Skip system message
+        message_count = 0
+        for i, msg in enumerate(conversation):
+            if msg["role"] == "system":
+                continue
+                
+            if msg["role"] == "user":
+                message_count += 1
+                print(f"\n{user_header()}")
+                print(f"{COLORS['cyan']}│ [{message_count}] {COLORS['reset']}{msg['content']}")
+            elif msg["role"] == "assistant":
+                print(f"\n{ngpt_header()}")
+                print(f"{COLORS['green']}│ {COLORS['reset']}{msg['content']}")
+        
+        print(f"\n{separator}")  # Consistent separator at the end
+    
+    # Function to clear conversation history
+    def clear_history():
+        nonlocal conversation
+        conversation = [{"role": "system", "content": system_prompt}]
+        print(f"\n{COLORS['yellow']}Conversation history cleared.{COLORS['reset']}")
+        print(separator)  # Add separator for consistency
+    
+    try:
+        while True:
+            # Get user input
+            if HAS_PROMPT_TOOLKIT:
+                # Custom styling for prompt_toolkit
+                style = Style.from_dict({
+                    'prompt': 'ansicyan bold',
+                    'input': 'ansiwhite',
+                })
+                
+                # Create key bindings for Ctrl+C handling
+                kb = KeyBindings()
+                @kb.add('c-c')
+                def _(event):
+                    event.app.exit(result=None)
+                    raise KeyboardInterrupt()
+                
+                # Get user input with styled prompt - using proper HTML formatting
+                user_input = pt_prompt(
+                    HTML("<ansicyan><b>╭─ 👤 You:</b></ansicyan> "),
+                    style=style,
+                    key_bindings=kb,
+                    history=prompt_history
+                )
+            else:
+                user_input = input(f"{user_header()}: {COLORS['reset']}")
+            
+            # Check for exit commands
+            if user_input.lower() in ('exit', 'quit', 'bye'):
+                print(f"\n{COLORS['green']}Ending chat session. Goodbye!{COLORS['reset']}")
+                break
+            
+            # Check for special commands
+            if user_input.lower() == 'history':
+                display_history()
+                continue
+            
+            if user_input.lower() == 'clear':
+                clear_history()
+                continue
+            
+            # Skip empty messages but don't raise an error
+            if not user_input.strip():
+                print(f"{COLORS['yellow']}Empty message skipped. Type 'exit' to quit.{COLORS['reset']}")
+                continue
+            
+            # Add user message to conversation
+            user_message = {"role": "user", "content": user_input}
+            conversation.append(user_message)
+            
+            # Log user message if logging is enabled
+            if log_handle:
+                log_handle.write(f"User: {user_input}\n")
+                log_handle.flush()
+            
+            # Print assistant indicator with formatting
+            if not no_stream and not stream_prettify:
+                print(f"\n{ngpt_header()}: {COLORS['reset']}", end="", flush=True)
+            elif not stream_prettify:
+                print(f"\n{ngpt_header()}: {COLORS['reset']}", flush=True)
+            
+            # If prettify is enabled with regular streaming
+            if prettify and not no_stream and not stream_prettify:
+                print(f"\n{COLORS['yellow']}Note: Streaming disabled to enable markdown rendering.{COLORS['reset']}")
+                print(f"\n{ngpt_header()}: {COLORS['reset']}", flush=True)
+                should_stream = False
+            else:
+                # Regular behavior with stream-prettify taking precedence
+                should_stream = not no_stream
+            
+            # Setup for stream-prettify
+            stream_callback = None
+            live_display = None
+            
+            if stream_prettify and should_stream:
+                # Get the correct header for interactive mode
+                header = ngpt_header()
+                live_display, stream_callback = prettify_streaming_markdown(renderer, is_interactive=True, header_text=header)
+                if not live_display:
+                    # Fallback to normal prettify if live display setup failed
+                    prettify = True
+                    stream_prettify = False
+                    should_stream = False
+                    print(f"{COLORS['yellow']}Falling back to regular prettify mode.{COLORS['reset']}")
+            
+            # Start live display if using stream-prettify
+            if stream_prettify and live_display:
+                live_display.start()
+            
+            # Get AI response with conversation history
+            response = client.chat(
+                prompt=user_input,
+                messages=conversation,
+                stream=should_stream,
+                web_search=web_search,
+                temperature=temperature,
+                top_p=top_p,
+                max_tokens=max_tokens,
+                markdown_format=prettify or stream_prettify,
+                stream_callback=stream_callback
+            )
+            
+            # Stop live display if using stream-prettify
+            if stream_prettify and live_display:
+                live_display.stop()
+            
+            # Add AI response to conversation history
+            if response:
+                assistant_message = {"role": "assistant", "content": response}
+                conversation.append(assistant_message)
+                
+                # Print response if not streamed (either due to no_stream or prettify)
+                if no_stream or prettify:
+                    if prettify:
+                        prettify_markdown(response, renderer)
+                    else:
+                        print(response)
+                
+                # Log assistant response if logging is enabled
+                if log_handle:
+                    log_handle.write(f"Assistant: {response}\n\n")
+                    log_handle.flush()
+            
+            # Print separator between exchanges
+            print_separator()
+            
+    except KeyboardInterrupt:
+        print(f"\n\n{COLORS['green']}Chat session ended by user. Goodbye!{COLORS['reset']}")
+    except Exception as e:
+        print(f"\n{COLORS['yellow']}Error during chat session: {str(e)}{COLORS['reset']}")
+        # Print traceback for debugging if it's a serious error
+        traceback.print_exc()
+    finally:
+        # Close log file if it was opened
+        if log_handle:
+            log_handle.write(f"\n--- End of Session ---\n")
+            log_handle.close()