ngpt 2.9.0__tar.gz → 2.9.2__tar.gz

{ngpt-2.9.0 → ngpt-2.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.9.0
+Version: 2.9.2
 Summary: A lightweight Python CLI and library for interacting with OpenAI-compatible APIs, supporting both official and self-hosted LLM endpoints.
 Project-URL: Homepage, https://github.com/nazdridoy/ngpt
 Project-URL: Repository, https://github.com/nazdridoy/ngpt
@@ -292,7 +292,9 @@ nGPT can also be used as a framework to build your own AI-powered command-line t
 
 ```python
 from ngpt import NGPTClient, load_config
-from ngpt.cli import interactive_chat_session, prettify_markdown, ColoredHelpFormatter
+from ngpt.cli.main import interactive_chat_session
+from ngpt.cli.renderers import prettify_markdown
+from ngpt.cli.formatters import ColoredHelpFormatter
 import argparse
 
 # Create a custom CLI tool with colorized help

{ngpt-2.9.0 → ngpt-2.9.2}/README.md

@@ -257,7 +257,9 @@ nGPT can also be used as a framework to build your own AI-powered command-line t
 
 ```python
 from ngpt import NGPTClient, load_config
-from ngpt.cli import interactive_chat_session, prettify_markdown, ColoredHelpFormatter
+from ngpt.cli.main import interactive_chat_session
+from ngpt.cli.renderers import prettify_markdown
+from ngpt.cli.formatters import ColoredHelpFormatter
 import argparse
 
 # Create a custom CLI tool with colorized help

{ngpt-2.9.0 → ngpt-2.9.2}/docs/examples/cli_components.md

@@ -21,7 +21,8 @@ Here's a simple CLI tool that uses nGPT to generate and explain code:
 import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli import ColoredHelpFormatter, prettify_markdown, has_markdown_renderer
+from ngpt.cli.formatters import ColoredHelpFormatter
+from ngpt.cli.renderers import prettify_markdown, has_markdown_renderer
 
 def main():
     # Create parser with colorized help
@@ -94,7 +95,9 @@ Create a custom chat application with specialized capabilities:
 import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli import interactive_chat_session, ColoredHelpFormatter, has_markdown_renderer
+from ngpt.cli.interactive import interactive_chat_session
+from ngpt.cli.formatters import ColoredHelpFormatter
+from ngpt.cli.renderers import has_markdown_renderer
 
 def main():
     parser = argparse.ArgumentParser(
@@ -180,7 +183,8 @@ import argparse
 import sys
 from pathlib import Path
 from ngpt import NGPTClient, load_config
-from ngpt.cli import prettify_streaming_markdown, ColoredHelpFormatter, has_markdown_renderer
+from ngpt.cli.renderers import prettify_streaming_markdown, has_markdown_renderer
+from ngpt.cli.formatters import ColoredHelpFormatter
 
 def main():
     parser = argparse.ArgumentParser(
@@ -310,7 +314,9 @@ Here's an example of using nGPT's multiline editor for collecting user input:
 import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli import multiline_editor, prettify_markdown, ColoredHelpFormatter
+from ngpt.cli.ui import multiline_editor
+from ngpt.cli.renderers import prettify_markdown
+from ngpt.cli.formatters import ColoredHelpFormatter
 
 def main():
     parser = argparse.ArgumentParser(
@@ -398,7 +404,8 @@ Create a CLI tool with persistent configuration:
 import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli import handle_cli_config, ColoredHelpFormatter
+from ngpt.cli.main import handle_cli_config
+from ngpt.cli.formatters import ColoredHelpFormatter
 
 def main():
     parser = argparse.ArgumentParser(
@@ -551,7 +558,8 @@ import sys
 import os
 from pathlib import Path
 from ngpt import NGPTClient, load_config
-from ngpt.cli import prettify_markdown, supports_ansi_colors, ColoredHelpFormatter
+from ngpt.cli.renderers import prettify_markdown, supports_ansi_colors
+from ngpt.cli.formatters import ColoredHelpFormatter
 
 def main():
     parser = argparse.ArgumentParser(
@@ -657,7 +665,7 @@ import base64
 import os
 from pathlib import Path
 from ngpt import NGPTClient, load_config
-from ngpt.cli import prettify_streaming_markdown, ColoredHelpFormatter, has_markdown_renderer
+from ngpt.cli.renderers import prettify_streaming_markdown, has_markdown_renderer
 
 def encode_image(image_path):
     """Encode image file as base64 string."""

{ngpt-2.9.0 → ngpt-2.9.2}/docs/usage/cli_framework.md

@@ -4,13 +4,14 @@ This guide explains how to leverage nGPT's CLI components to build your own comm
 
 ## Overview
 
-nGPT's `cli.py` module contains several reusable components that you can incorporate into your own CLI applications:
+nGPT's CLI module has been modularized into several components that you can incorporate into your own CLI applications:
 
-- **Interactive Chat Interface**: A fully-featured chat UI with history management
-- **Markdown Rendering**: Beautiful formatting for markdown with syntax highlighting
-- **Real-time Streaming**: Tools for handling streaming content with live updates
-- **CLI Configuration System**: Robust configuration management
-- **Terminal Utilities**: Helpers for colorized output and terminal formatting
+- **Interactive Chat Interface**: A fully-featured chat UI with history management (`ngpt.cli.interactive`)
+- **Markdown Rendering**: Beautiful formatting for markdown with syntax highlighting (`ngpt.cli.renderers`)
+- **Real-time Streaming**: Tools for handling streaming content with live updates (`ngpt.cli.ui`)
+- **CLI Configuration System**: Robust configuration management (`ngpt.cli.main`)
+- **Terminal Utilities**: Helpers for colorized output and terminal formatting (`ngpt.cli.formatters`)
+- **Mode-specific functionality**: Specialized code, shell, chat and text mode handlers (`ngpt.cli.modes`)
 
 ## Getting Started
 
@@ -33,7 +34,7 @@ The `interactive_chat_session` function provides a complete interactive chat exp
 
 ```python
 from ngpt import NGPTClient, load_config
-from ngpt.cli import interactive_chat_session
+from ngpt.cli.interactive import interactive_chat_session
 
 # Initialize client
 config = load_config()
@@ -80,7 +81,7 @@ except Exception as e:
 nGPT provides utilities for rendering markdown with syntax highlighting:
 
 ```python
-from ngpt.cli import prettify_markdown, has_markdown_renderer
+from ngpt.cli.renderers import prettify_markdown, has_markdown_renderer
 
 # Check if renderer is available
 if has_markdown_renderer(renderer='rich'):
@@ -99,7 +100,7 @@ Available renderers include:
 You can check available renderers:
 
 ```python
-from ngpt.cli import show_available_renderers
+from ngpt.cli.renderers import show_available_renderers
 show_available_renderers()
 ```
 
@@ -126,7 +127,7 @@ else:
 For real-time rendering of streaming content, the `prettify_streaming_markdown` function returns an object with an `update_content` method:
 
 ```python
-from ngpt.cli import prettify_streaming_markdown
+from ngpt.cli.renderers import prettify_streaming_markdown
 from ngpt import NGPTClient, load_config
 
 client = NGPTClient(**load_config())
@@ -153,7 +154,7 @@ This creates a live-updating display that refreshes as new content arrives. The
 nGPT provides tools for managing CLI configurations:
 
 ```python
-from ngpt.cli import handle_cli_config, show_cli_config_help
+from ngpt.cli.main import handle_cli_config, show_cli_config_help
 
 # Show help
 show_cli_config_help()
@@ -187,13 +188,13 @@ except Exception as e:
 Colorize your CLI output with terminal utilities:
 
 ```python
-from ngpt.cli import ColoredHelpFormatter, supports_ansi_colors
+from ngpt.cli.formatters import ColoredHelpFormatter, supports_ansi_colors, COLORS
 import argparse
 
 # Check if terminal supports colors
 if supports_ansi_colors():
     # Use colored output
-    print("\033[1;32mSuccess!\033[0m")
+    print(f"{COLORS['green']}Success!{COLORS['reset']}")
 else:
     # Fallback to plain text
     print("Success!")
@@ -220,13 +221,9 @@ import argparse
 import sys
 from pathlib import Path
 from ngpt import NGPTClient, load_config
-from ngpt.cli import (
-    ColoredHelpFormatter,
-    interactive_chat_session,
-    prettify_markdown,
-    prettify_streaming_markdown,
-    has_markdown_renderer
-)
+from ngpt.cli.formatters import ColoredHelpFormatter
+from ngpt.cli.interactive import interactive_chat_session
+from ngpt.cli.renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer
 
 def main():
     # Set up argument parser with colorized help
@@ -352,7 +349,7 @@ nGPT supports multiple markdown renderers:
 Using the Rich library for terminal output:
 
 ```python
-from ngpt.cli import prettify_markdown
+from ngpt.cli.renderers import prettify_markdown
 
 # Rich renderer with custom styling
 formatted = prettify_markdown(markdown_text, renderer='rich')
@@ -364,7 +361,7 @@ print(formatted)
 If you have the Glow CLI tool installed:
 
 ```python
-from ngpt.cli import prettify_markdown, has_glow_installed
+from ngpt.cli.renderers import prettify_markdown, has_glow_installed
 
 if has_glow_installed():
     formatted = prettify_markdown(markdown_text, renderer='glow')
@@ -385,7 +382,7 @@ print(formatted)
 nGPT provides utilities to detect terminal capabilities:
 
 ```python
-from ngpt.cli import supports_ansi_colors
+from ngpt.cli.formatters import supports_ansi_colors
 
 if supports_ansi_colors():
     # Use colored output
@@ -422,17 +419,12 @@ This example creates a specialized web search tool using nGPT components:
 import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli import (
-    ColoredHelpFormatter,
-    prettify_streaming_markdown,
-    has_markdown_renderer
-)
+from ngpt.cli.renderers import prettify_streaming_markdown, has_markdown_renderer
 
 def main():
     # Set up colorized argument parser
     parser = argparse.ArgumentParser(
-        description="AI-powered web search tool",
-        formatter_class=ColoredHelpFormatter
+        description="AI-powered web search tool"
     )
     
     parser.add_argument("query", nargs="?", help="Search query")
@@ -514,7 +506,7 @@ logging.basicConfig(
 )
 
 # Use nGPT components with logging available
-from ngpt.cli import prettify_markdown
+from ngpt.cli.renderers import prettify_markdown
 try:
     result = prettify_markdown(text)
 except Exception as e:

ngpt-2.9.2/ngpt/cli/__init__.py

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

ngpt-2.9.2/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-2.9.2/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