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

ngpt/__init__.py

@@ -3,8 +3,19 @@ __version__ = get_version("ngpt")
 
 from .client import NGPTClient
 from .config import load_config, get_config_path, get_config_dir
+from .cli_config import (
+    load_cli_config,
+    set_cli_config_option,
+    get_cli_config_option,
+    unset_cli_config_option,
+    apply_cli_config
+)
 
-__all__ = ["NGPTClient", "__version__", "load_config", "get_config_path", "get_config_dir"]
+__all__ = [
+    "NGPTClient", "__version__", "load_config", "get_config_path", "get_config_dir",
+    "load_cli_config", "set_cli_config_option", "get_cli_config_option", 
+    "unset_cli_config_option", "apply_cli_config"
+]
 
 # Import cli last to avoid circular imports
 from .cli import main

ngpt/cli.py

@@ -3,6 +3,14 @@ import sys
 import os
 from .client import NGPTClient
 from .config import load_config, get_config_path, load_configs, add_config_entry, remove_config_entry
+from .cli_config import (
+    set_cli_config_option, 
+    get_cli_config_option, 
+    unset_cli_config_option, 
+    apply_cli_config,
+    list_cli_config_options,
+    CLI_CONFIG_OPTIONS
+)
 from . import __version__
 
 # Try to import markdown rendering libraries
@@ -844,6 +852,143 @@ def prettify_streaming_markdown(renderer='rich', is_interactive=False, header_te
         print(f"{COLORS['yellow']}Error setting up Rich streaming display: {str(e)}{COLORS['reset']}")
         return None, None
 
+def show_cli_config_help():
+    """Display help information about CLI configuration."""
+    print(f"\n{COLORS['green']}{COLORS['bold']}CLI Configuration Help:{COLORS['reset']}")
+    print(f"  {COLORS['cyan']}Command syntax:{COLORS['reset']}")
+    print(f"    {COLORS['yellow']}ngpt --cli-config set OPTION VALUE{COLORS['reset']}    - Set a default value for OPTION")
+    print(f"    {COLORS['yellow']}ngpt --cli-config get OPTION{COLORS['reset']}          - Get the current value of OPTION")
+    print(f"    {COLORS['yellow']}ngpt --cli-config get{COLORS['reset']}                 - Show all CLI configuration settings")
+    print(f"    {COLORS['yellow']}ngpt --cli-config unset OPTION{COLORS['reset']}        - Remove OPTION from configuration")
+    print(f"    {COLORS['yellow']}ngpt --cli-config list{COLORS['reset']}                - List all available options")
+    
+    print(f"\n  {COLORS['cyan']}Available options:{COLORS['reset']}")
+    
+    # Group options by context
+    context_groups = {
+        "all": [],
+        "code": [],
+        "interactive": [],
+        "text": [],
+        "shell": []
+    }
+    
+    for option, meta in CLI_CONFIG_OPTIONS.items():
+        for context in meta["context"]:
+            if context in context_groups:
+                if context == "all":
+                    context_groups[context].append(option)
+                    break
+                else:
+                    context_groups[context].append(option)
+    
+    # Print general options (available in all contexts)
+    print(f"    {COLORS['yellow']}General options (all modes):{COLORS['reset']}")
+    for option in sorted(context_groups["all"]):
+        meta = CLI_CONFIG_OPTIONS[option]
+        default = f"(default: {meta['default']})" if meta['default'] is not None else ""
+        exclusive = f" [exclusive with: {', '.join(meta['exclusive'])}]" if "exclusive" in meta else ""
+        print(f"      {COLORS['green']}{option}{COLORS['reset']} - {meta['type']} {default}{exclusive}")
+    
+    # Print mode-specific options
+    for mode, options in [
+        ("code", "Code generation mode"),
+        ("interactive", "Interactive mode"),
+        ("text", "Text mode"),
+        ("shell", "Shell mode")
+    ]:
+        if context_groups[mode]:
+            print(f"\n    {COLORS['yellow']}Options for {options}:{COLORS['reset']}")
+            for option in sorted(context_groups[mode]):
+                # Skip if already listed in general options
+                if option in context_groups["all"]:
+                    continue
+                meta = CLI_CONFIG_OPTIONS[option]
+                default = f"(default: {meta['default']})" if meta['default'] is not None else ""
+                exclusive = f" [exclusive with: {', '.join(meta['exclusive'])}]" if "exclusive" in meta else ""
+                print(f"      {COLORS['green']}{option}{COLORS['reset']} - {meta['type']} {default}{exclusive}")
+    
+    print(f"\n  {COLORS['cyan']}Example usage:{COLORS['reset']}")
+    print(f"    {COLORS['yellow']}ngpt --cli-config set language java{COLORS['reset']}        - Set default language to java for code generation")
+    print(f"    {COLORS['yellow']}ngpt --cli-config set temperature 0.9{COLORS['reset']}      - Set default temperature to 0.9")
+    print(f"    {COLORS['yellow']}ngpt --cli-config set no-stream true{COLORS['reset']}       - Disable streaming by default")
+    print(f"    {COLORS['yellow']}ngpt --cli-config unset language{COLORS['reset']}           - Remove language setting")
+    
+    print(f"\n  {COLORS['cyan']}Notes:{COLORS['reset']}")
+    print(f"    - CLI configuration is stored in {COLORS['yellow']}~/.config/ngpt/ngpt-cli.conf{COLORS['reset']} (or equivalent for your OS)")
+    print(f"    - Settings are applied based on context (e.g., language only applies to code generation mode)")
+    print(f"    - Command-line arguments always override CLI configuration")
+    print(f"    - Some options are mutually exclusive and will not be applied together")
+
+def handle_cli_config(action, option=None, value=None):
+    """Handle CLI configuration commands."""
+    if action == "list":
+        # List all available options
+        print(f"{COLORS['green']}{COLORS['bold']}Available CLI configuration options:{COLORS['reset']}")
+        for option in list_cli_config_options():
+            meta = CLI_CONFIG_OPTIONS[option]
+            default = f"(default: {meta['default']})" if meta['default'] is not None else ""
+            contexts = ', '.join(meta['context'])
+            if "all" in meta['context']:
+                contexts = "all modes"
+            print(f"  {COLORS['cyan']}{option}{COLORS['reset']} - {meta['type']} {default} - Available in: {contexts}")
+        return
+    
+    if action == "get":
+        if option is None:
+            # Get all options
+            success, config = get_cli_config_option()
+            if success and config:
+                print(f"{COLORS['green']}{COLORS['bold']}Current CLI configuration:{COLORS['reset']}")
+                for opt, val in config.items():
+                    if opt in CLI_CONFIG_OPTIONS:
+                        print(f"  {COLORS['cyan']}{opt}{COLORS['reset']} = {val}")
+                    else:
+                        print(f"  {COLORS['yellow']}{opt}{COLORS['reset']} = {val} (unknown option)")
+            else:
+                print(f"{COLORS['yellow']}No CLI configuration set. Use 'ngpt --cli-config set OPTION VALUE' to set options.{COLORS['reset']}")
+        else:
+            # Get specific option
+            success, result = get_cli_config_option(option)
+            if success:
+                if result is None:
+                    print(f"{COLORS['cyan']}{option}{COLORS['reset']} is not set (default: {CLI_CONFIG_OPTIONS.get(option, {}).get('default', 'N/A')})")
+                else:
+                    print(f"{COLORS['cyan']}{option}{COLORS['reset']} = {result}")
+            else:
+                print(f"{COLORS['yellow']}{result}{COLORS['reset']}")
+        return
+    
+    if action == "set":
+        if option is None or value is None:
+            print(f"{COLORS['yellow']}Error: Both OPTION and VALUE are required for 'set' command.{COLORS['reset']}")
+            print(f"Usage: ngpt --cli-config set OPTION VALUE")
+            return
+            
+        success, message = set_cli_config_option(option, value)
+        if success:
+            print(f"{COLORS['green']}{message}{COLORS['reset']}")
+        else:
+            print(f"{COLORS['yellow']}{message}{COLORS['reset']}")
+        return
+    
+    if action == "unset":
+        if option is None:
+            print(f"{COLORS['yellow']}Error: OPTION is required for 'unset' command.{COLORS['reset']}")
+            print(f"Usage: ngpt --cli-config unset OPTION")
+            return
+            
+        success, message = unset_cli_config_option(option)
+        if success:
+            print(f"{COLORS['green']}{message}{COLORS['reset']}")
+        else:
+            print(f"{COLORS['yellow']}{message}{COLORS['reset']}")
+        return
+    
+    # If we get here, the action is not recognized
+    print(f"{COLORS['yellow']}Error: Unknown action '{action}'. Use 'set', 'get', 'unset', or 'list'.{COLORS['reset']}")
+    show_cli_config_help()
+
 def main():
     # Colorize description - use a shorter description to avoid line wrapping issues
     description = f"{COLORS['cyan']}{COLORS['bold']}nGPT{COLORS['reset']} - Interact with AI language models via OpenAI-compatible APIs"
@@ -921,8 +1066,30 @@ def main():
     # Prompt argument
     parser.add_argument('prompt', nargs='?', default=None, help='The prompt to send')
     
+    # Add CLI configuration command
+    config_group.add_argument('--cli-config', nargs='*', metavar='COMMAND',
+                      help='Manage CLI configuration (set, get, unset, list)')
+    
     args = parser.parse_args()
     
+    # Handle CLI configuration command
+    if args.cli_config is not None:
+        # Show help if no arguments or "help" argument
+        if len(args.cli_config) == 0 or (len(args.cli_config) > 0 and args.cli_config[0].lower() == "help"):
+            show_cli_config_help()
+            return
+            
+        action = args.cli_config[0].lower()
+        option = args.cli_config[1] if len(args.cli_config) > 1 else None
+        value = args.cli_config[2] if len(args.cli_config) > 2 else None
+        
+        if action in ("set", "get", "unset", "list"):
+            handle_cli_config(action, option, value)
+            return
+        else:
+            show_cli_config_help()
+            return
+    
     # Validate --all usage
     if args.all and not args.show_config:
         parser.error("--all can only be used with --show-config")
@@ -932,8 +1099,28 @@ def main():
         show_available_renderers()
         return
     
-    # Check for mutual exclusivity between --config-index and --provider
-    if args.config_index != 0 and args.provider:
+    # Load CLI configuration early
+    from .cli_config import load_cli_config
+    cli_config = load_cli_config()
+    
+    # Priority order for config selection:
+    # 1. Command-line arguments (args.provider, args.config_index)
+    # 2. CLI configuration (cli_config["provider"], cli_config["config-index"])
+    # 3. Default values (None, 0)
+    
+    # Get provider/config-index from CLI config if not specified in args
+    effective_provider = args.provider
+    effective_config_index = args.config_index
+    
+    # Only apply CLI config for provider/config-index if not explicitly set on command line
+    if not effective_provider and 'provider' in cli_config and '--provider' not in sys.argv:
+        effective_provider = cli_config['provider']
+    
+    if effective_config_index == 0 and 'config-index' in cli_config and '--config-index' not in sys.argv:
+        effective_config_index = cli_config['config-index']
+    
+    # Check for mutual exclusivity between provider and config-index
+    if effective_config_index != 0 and effective_provider:
         parser.error("--config-index and --provider cannot be used together")
 
     # Handle interactive configuration mode
@@ -943,22 +1130,22 @@ def main():
         # Handle configuration removal if --remove flag is present
         if args.remove:
             # Validate that config_index is explicitly provided
-            if '--config-index' not in sys.argv and not args.provider:
+            if '--config-index' not in sys.argv and not effective_provider:
                 parser.error("--remove requires explicitly specifying --config-index or --provider")
             
             # Show config details before asking for confirmation
             configs = load_configs(str(config_path))
             
             # Determine the config index to remove
-            config_index = args.config_index
-            if args.provider:
+            config_index = effective_config_index
+            if effective_provider:
                 # Find config index by provider name
-                matching_configs = [i for i, cfg in enumerate(configs) if cfg.get('provider', '').lower() == args.provider.lower()]
+                matching_configs = [i for i, cfg in enumerate(configs) if cfg.get('provider', '').lower() == effective_provider.lower()]
                 if not matching_configs:
-                    print(f"Error: No configuration found for provider '{args.provider}'")
+                    print(f"Error: No configuration found for provider '{effective_provider}'")
                     return
                 elif len(matching_configs) > 1:
-                    print(f"Multiple configurations found for provider '{args.provider}':")
+                    print(f"Multiple configurations found for provider '{effective_provider}':")
                     for i, idx in enumerate(matching_configs):
                         print(f"  [{i}] Index {idx}: {configs[idx].get('model', 'Unknown model')}")
                     
@@ -1008,15 +1195,15 @@ def main():
         config_index = None
         
         # Determine if we're editing an existing config or creating a new one
-        if args.provider:
+        if effective_provider:
             # Find config by provider name
             configs = load_configs(str(config_path))
-            matching_configs = [i for i, cfg in enumerate(configs) if cfg.get('provider', '').lower() == args.provider.lower()]
+            matching_configs = [i for i, cfg in enumerate(configs) if cfg.get('provider', '').lower() == effective_provider.lower()]
             
             if not matching_configs:
-                print(f"No configuration found for provider '{args.provider}'. Creating a new configuration.")
+                print(f"No configuration found for provider '{effective_provider}'. Creating a new configuration.")
             elif len(matching_configs) > 1:
-                print(f"Multiple configurations found for provider '{args.provider}':")
+                print(f"Multiple configurations found for provider '{effective_provider}':")
                 for i, idx in enumerate(matching_configs):
                     print(f"  [{i}] Index {idx}: {configs[idx].get('model', 'Unknown model')}")
                 
@@ -1032,14 +1219,14 @@ def main():
                 config_index = matching_configs[0]
                 
             print(f"Editing existing configuration at index {config_index}")
-        elif args.config_index != 0 or '--config-index' in sys.argv:
+        elif effective_config_index != 0 or '--config-index' in sys.argv:
             # Check if the index is valid
             configs = load_configs(str(config_path))
-            if args.config_index >= 0 and args.config_index < len(configs):
-                config_index = args.config_index
+            if effective_config_index >= 0 and effective_config_index < len(configs):
+                config_index = effective_config_index
                 print(f"Editing existing configuration at index {config_index}")
             else:
-                print(f"Configuration index {args.config_index} is out of range. Creating a new configuration.")
+                print(f"Configuration index {effective_config_index} is out of range. Creating a new configuration.")
         else:
             # Creating a new config
             configs = load_configs(str(config_path))
@@ -1048,12 +1235,10 @@ def main():
         add_config_entry(config_path, config_index)
         return
     
-    # Load configuration using the specified index or provider (needed for active config display)
-    active_config = load_config(args.config, args.config_index, args.provider)
+    # Load configuration using the effective provider/config-index
+    active_config = load_config(args.config, effective_config_index, effective_provider)
     
     # Command-line arguments override config settings for active config display
-    # This part is kept to ensure the active config display reflects potential overrides,
-    # even though the overrides don't affect the stored configurations displayed with --all.
     if args.api_key:
         active_config["api_key"] = args.api_key
     if args.base_url:
@@ -1070,9 +1255,9 @@ def main():
         print(f"Total configurations: {len(configs)}")
         
         # Determine active configuration and display identifier
-        active_identifier = f"index {args.config_index}"
-        if args.provider:
-            active_identifier = f"provider '{args.provider}'"
+        active_identifier = f"index {effective_config_index}"
+        if effective_provider:
+            active_identifier = f"provider '{effective_provider}'"
         print(f"Active configuration: {active_identifier}")
 
         if args.all:
@@ -1081,8 +1266,8 @@ def main():
             for i, cfg in enumerate(configs):
                 provider = cfg.get('provider', 'N/A')
                 active_str = '(Active)' if (
-                    (args.provider and provider.lower() == args.provider.lower()) or 
-                    (not args.provider and i == args.config_index)
+                    (effective_provider and provider.lower() == effective_provider.lower()) or 
+                    (not effective_provider and i == effective_config_index)
                 ) else ''
                 print(f"\n--- Configuration Index {i} / Provider: {COLORS['green']}{provider}{COLORS['reset']} {active_str} ---")
                 print(f"  API Key: {'[Set]' if cfg.get('api_key') else '[Not Set]'}")
@@ -1112,8 +1297,8 @@ def main():
                         provider_display = f"{provider} {COLORS['yellow']}(duplicate){COLORS['reset']}"
                     
                     active_marker = "*" if (
-                        (args.provider and provider.lower() == args.provider.lower()) or 
-                        (not args.provider and i == args.config_index)
+                        (effective_provider and provider.lower() == effective_provider.lower()) or 
+                        (not effective_provider and i == effective_config_index)
                     ) else " "
                     print(f"[{i}]{active_marker} {COLORS['green']}{provider_display}{COLORS['reset']} - {cfg.get('model', 'N/A')} ({'[API Key Set]' if cfg.get('api_key') else '[API Key Not Set]'})")
                 
@@ -1173,6 +1358,9 @@ def main():
         
         # Handle modes
         if args.interactive:
+            # Apply CLI config for interactive mode
+            args = apply_cli_config(args, "interactive")
+            
             # Interactive chat mode
             interactive_chat_session(
                 client,
@@ -1188,6 +1376,9 @@ def main():
                 stream_prettify=args.stream_prettify
             )
         elif args.shell:
+            # Apply CLI config for shell mode
+            args = apply_cli_config(args, "shell")
+            
             if args.prompt is None:
                 try:
                     print("Enter shell command description: ", end='')
@@ -1226,6 +1417,9 @@ def main():
                     print(f"\nError:\n{e.stderr}")
                     
         elif args.code:
+            # Apply CLI config for code mode
+            args = apply_cli_config(args, "code")
+            
             if args.prompt is None:
                 try:
                     print("Enter code description: ", end='')
@@ -1236,30 +1430,55 @@ def main():
             else:
                 prompt = args.prompt
 
-            # Setup for stream-prettify with code generation
+            # Setup for streaming and prettify logic
             stream_callback = None
             live_display = None
-            should_stream = False
-            
+            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:
-                should_stream = True  # Enable streaming
-                # This is the code generation 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
+                # 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
-                    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']}")
+                    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 args.stream_prettify and live_display:
+            if use_stream_prettify and live_display:
                 live_display.start()
                 
             generated_code = client.generate_code(
@@ -1269,23 +1488,29 @@ def main():
                 temperature=args.temperature, 
                 top_p=args.top_p,
                 max_tokens=args.max_tokens,
-                markdown_format=args.prettify or args.stream_prettify,
+                # 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 args.stream_prettify and live_display:
+            if use_stream_prettify and live_display:
                 live_display.stop()
                 
-            if generated_code and not args.stream_prettify:
-                if args.prettify:
+            # 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}")
-            
+        
         elif args.text:
+            # Apply CLI config for text mode
+            args = apply_cli_config(args, "text")
+            
             if args.prompt is not None:
                 prompt = args.prompt
             else:
@@ -1447,6 +1672,9 @@ def main():
         
         else:
             # Default to chat mode
+            # Apply CLI config for default chat mode
+            args = apply_cli_config(args, "all")
+            
             if args.prompt is None:
                 try:
                     print("Enter your prompt: ", end='')

ngpt/cli_config.py

@@ -0,0 +1,247 @@
+import os
+import sys
+import json
+from pathlib import Path
+from typing import Dict, Optional, Any, List, Union, Tuple
+
+# CLI config options with their types and default values
+CLI_CONFIG_OPTIONS = {
+    "language": {"type": "str", "default": "python", "context": ["code"]},
+    "provider": {"type": "str", "default": None, "context": ["all"]},
+    "temperature": {"type": "float", "default": 0.7, "context": ["all"]},
+    "top_p": {"type": "float", "default": 1.0, "context": ["all"]},
+    "max_tokens": {"type": "int", "default": None, "context": ["all"]},
+    "log": {"type": "str", "default": None, "context": ["interactive", "text"]},
+    "preprompt": {"type": "str", "default": None, "context": ["all"]},
+    "no-stream": {"type": "bool", "default": False, "context": ["all"], "exclusive": ["prettify", "stream-prettify"]},
+    "prettify": {"type": "bool", "default": False, "context": ["all"], "exclusive": ["no-stream", "stream-prettify"]},
+    "stream-prettify": {"type": "bool", "default": False, "context": ["all"], "exclusive": ["no-stream", "prettify"]},
+    "renderer": {"type": "str", "default": "auto", "context": ["all"]},
+    "config-index": {"type": "int", "default": 0, "context": ["all"]},
+    "web-search": {"type": "bool", "default": False, "context": ["all"]},
+}
+
+def get_cli_config_dir() -> Path:
+    """Get the appropriate CLI config directory based on OS."""
+    if sys.platform == "win32":
+        # Windows
+        config_dir = Path(os.environ.get("APPDATA", "")) / "ngpt"
+    elif sys.platform == "darwin":
+        # macOS
+        config_dir = Path.home() / "Library" / "Application Support" / "ngpt"
+    else:
+        # Linux and other Unix-like systems
+        xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
+        if xdg_config_home:
+            config_dir = Path(xdg_config_home) / "ngpt"
+        else:
+            config_dir = Path.home() / ".config" / "ngpt"
+    
+    # Ensure the directory exists
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+def get_cli_config_path() -> Path:
+    """Get the path to the CLI config file."""
+    return get_cli_config_dir() / "ngpt-cli.conf"
+
+def load_cli_config() -> Dict[str, Any]:
+    """Load CLI configuration from the config file."""
+    config_path = get_cli_config_path()
+    
+    # Default empty config
+    config = {}
+    
+    # Load from config file if it exists
+    if config_path.exists():
+        try:
+            with open(config_path, "r") as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Warning: Could not read CLI config file: {e}", file=sys.stderr)
+    
+    return config
+
+def save_cli_config(config: Dict[str, Any]) -> bool:
+    """Save CLI configuration to the config file."""
+    config_path = get_cli_config_path()
+    
+    try:
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=2)
+        return True
+    except Exception as e:
+        print(f"Error saving CLI configuration: {e}", file=sys.stderr)
+        return False
+
+def set_cli_config_option(option: str, value: Any) -> Tuple[bool, str]:
+    """Set a CLI configuration option.
+    
+    Args:
+        option: The name of the option to set
+        value: The value to set
+        
+    Returns:
+        Tuple of (success, message)
+    """
+    # Check if option is valid
+    if option not in CLI_CONFIG_OPTIONS:
+        return False, f"Error: Unknown option '{option}'"
+    
+    # Load current config
+    config = load_cli_config()
+    
+    # Parse and validate the value based on option type
+    option_type = CLI_CONFIG_OPTIONS[option]["type"]
+    
+    try:
+        if option_type == "str":
+            parsed_value = str(value)
+        elif option_type == "int":
+            parsed_value = int(value)
+        elif option_type == "float":
+            parsed_value = float(value)
+        elif option_type == "bool":
+            if isinstance(value, bool):
+                parsed_value = value
+            elif value.lower() in ("true", "yes", "1", "t", "y"):
+                parsed_value = True
+            elif value.lower() in ("false", "no", "0", "f", "n"):
+                parsed_value = False
+            else:
+                return False, f"Error: Invalid boolean value '{value}' for option '{option}'"
+        else:
+            return False, f"Error: Unsupported option type '{option_type}'"
+        
+        # Handle mutual exclusivity for boolean options
+        if option_type == "bool" and "exclusive" in CLI_CONFIG_OPTIONS[option]:
+            if parsed_value:  # If setting this option to True
+                # Set all other exclusive options to False
+                for excl_option in CLI_CONFIG_OPTIONS[option]["exclusive"]:
+                    config[excl_option] = False
+            # No special handling needed if setting to False, just update the value
+        
+        # Set the value in the config
+        config[option] = parsed_value
+        
+        # Save the config
+        if save_cli_config(config):
+            return True, f"Successfully set {option}={parsed_value}"
+        else:
+            return False, "Error saving configuration"
+            
+    except (ValueError, TypeError) as e:
+        return False, f"Error: {str(e)}"
+
+def get_cli_config_option(option: str = None) -> Tuple[bool, Union[str, Dict[str, Any]]]:
+    """Get a CLI configuration option or all options.
+    
+    Args:
+        option: The name of the option to get, or None for all options
+        
+    Returns:
+        Tuple of (success, value/message)
+    """
+    # Load current config
+    config = load_cli_config()
+    
+    # Return all options if no specific option requested
+    if option is None:
+        return True, config
+    
+    # Check if option is valid
+    if option not in CLI_CONFIG_OPTIONS:
+        return False, f"Error: Unknown option '{option}'"
+    
+    # Return the option value if set, otherwise the default
+    if option in config:
+        return True, config[option]
+    else:
+        return True, CLI_CONFIG_OPTIONS[option]["default"]
+
+def unset_cli_config_option(option: str) -> Tuple[bool, str]:
+    """Unset a CLI configuration option.
+    
+    Args:
+        option: The name of the option to unset
+        
+    Returns:
+        Tuple of (success, message)
+    """
+    # Check if option is valid
+    if option not in CLI_CONFIG_OPTIONS:
+        return False, f"Error: Unknown option '{option}'"
+    
+    # Load current config
+    config = load_cli_config()
+    
+    # Remove the option if it exists
+    if option in config:
+        del config[option]
+        
+        # Save the config
+        if save_cli_config(config):
+            return True, f"Successfully unset {option}"
+        else:
+            return False, "Error saving configuration"
+    else:
+        return True, f"Note: Option '{option}' was not set"
+
+def apply_cli_config(args: Any, mode: str) -> Any:
+    """Apply CLI configuration to args object, respecting context and not overriding explicit args.
+    
+    Args:
+        args: The argparse namespace object
+        mode: The current mode ('interactive', 'shell', 'code', 'text', or 'all' for default)
+        
+    Returns:
+        Updated args object
+    """
+    # Load CLI config
+    cli_config = load_cli_config()
+    
+    # Get command-line arguments provided by the user
+    explicit_args = set(arg for arg in sys.argv[1:] if arg.startswith('--'))
+
+    # For each option in CLI config, check if it should be applied
+    for option, value in cli_config.items():
+        # Skip if not a valid option
+        if option not in CLI_CONFIG_OPTIONS:
+            continue
+            
+        # Check context
+        option_context = CLI_CONFIG_OPTIONS[option]["context"]
+        if "all" not in option_context and mode not in option_context:
+            continue
+            
+        # Convert dashes to underscores for argparse compatibility
+        arg_name = option.replace("-", "_")
+        
+        # Skip if explicitly set via command line
+        # Check common variants like --option
+        cli_option = f"--{option}"
+        if cli_option in explicit_args:
+            continue
+        
+        # Check exclusivity constraints against *explicitly set* args
+        # Don't apply a CLI config option if an exclusive option was explicitly set
+        if "exclusive" in CLI_CONFIG_OPTIONS[option]:
+            skip = False
+            for excl_option in CLI_CONFIG_OPTIONS[option]["exclusive"]:
+                excl_cli_option = f"--{excl_option}"
+                if excl_cli_option in explicit_args:
+                    skip = True
+                    break # Skip applying this CLI config value
+            if skip:
+                continue
+                
+        # Apply the value from CLI config
+        # Ensure the attribute exists on args before setting
+        if hasattr(args, arg_name):
+            setattr(args, arg_name, value)
+    
+    return args
+
+def list_cli_config_options() -> List[str]:
+    """List all available CLI configuration options."""
+    return sorted(CLI_CONFIG_OPTIONS.keys()) 

{ngpt-2.7.2.dist-info → ngpt-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.7.2
+Version: 2.9.0
 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
@@ -28,10 +28,9 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.8
+Requires-Dist: prompt-toolkit>=3.0.0
 Requires-Dist: requests>=2.31.0
-Provides-Extra: full
-Requires-Dist: prompt-toolkit>=3.0.0; extra == 'full'
-Requires-Dist: rich>=10.0.0; extra == 'full'
+Requires-Dist: rich>=10.0.0
 Description-Content-Type: text/markdown
 
 # nGPT
@@ -43,6 +42,9 @@ Description-Content-Type: text/markdown
 
 A lightweight Python CLI and library for interacting with OpenAI-compatible APIs, supporting both official and self-hosted LLM endpoints.
 
+![2025-04-23_16-18-01](https://github.com/user-attachments/assets/b8e58926-5165-4352-b48b-9f4a982da86e)
+
+
 ## Table of Contents
 - [Quick Start](#quick-start)
 - [Features](#features)
@@ -52,8 +54,10 @@ A lightweight Python CLI and library for interacting with OpenAI-compatible APIs
   - [Documentation](https://nazdridoy.github.io/ngpt/)
   - [CLI Tool](#as-a-cli-tool)
   - [Python Library](#as-a-library)
+  - [CLI Framework](#as-a-cli-framework)
 - [Configuration](#configuration)
   - [Command Line Options](#command-line-options)
+  - [CLI Configuration](#cli-configuration)
   - [Interactive Configuration](#interactive-configuration)
   - [Configuration File](#configuration-file)
   - [Configuration Priority](#configuration-priority)
@@ -63,11 +67,14 @@ A lightweight Python CLI and library for interacting with OpenAI-compatible APIs
 ## Quick Start
 
 ```bash
-# Install
+# Install with pip
 pip install ngpt
 
-# Install with additional features
-pip install "ngpt[full]"
+# Or install with uv (faster)
+uv pip install ngpt
+
+# Or install globally as a CLI tool (recommended)
+uv tool install ngpt
 
 # Chat with default settings
 ngpt "Tell me about quantum computing"
@@ -113,8 +120,8 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 
 ## Features
 
-- ✅ **Dual Mode**: Use as a CLI tool or import as a Python library
-- 🪶 **Lightweight**: Minimal dependencies (just `requests`)
+- ✅ **Versatile**: Use as a CLI tool, Python library, or CLI framework for building custom tools
+- 🪶 **Lightweight**: Minimal dependencies with everything you need included
 - 🔄 **API Flexibility**: Works with OpenAI, Ollama, Groq, and any compatible endpoint
 - 💬 **Interactive Chat**: Continuous conversation with memory in modern UI
 - 📊 **Streaming Responses**: Real-time output for better user experience
@@ -127,6 +134,7 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 - 📝 **Rich Multiline Editor**: Interactive multiline text input with syntax highlighting and intuitive controls
 - 🎭 **System Prompts**: Customize model behavior with custom system prompts
 - 📃 **Conversation Logging**: Save your conversations to text files for later reference
+- 🧰 **CLI Components**: Reusable components for building custom AI-powered command-line tools
 
 See the [Feature Overview](https://nazdridoy.github.io/ngpt/overview.html) for more details.
 
@@ -140,25 +148,25 @@ Key documentation sections:
 - [Installation Guide](https://nazdridoy.github.io/ngpt/installation.html)
 - [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage.html)
 - [Library Usage Guide](https://nazdridoy.github.io/ngpt/usage/library_usage.html)
+- [CLI Framework Guide](https://nazdridoy.github.io/ngpt/usage/cli_framework.html)
 - [Configuration Guide](https://nazdridoy.github.io/ngpt/configuration.html)
 - [Examples & Tutorials](https://nazdridoy.github.io/ngpt/examples/basic.html)
 
 ## Installation
 
 ```bash
-# Basic installation (minimal dependencies)
+# Installation with pip
 pip install ngpt
 
-# Full installation with all features (recommended)
-pip install "ngpt[full]"
+# Or install with uv (faster installation)
+uv pip install ngpt
+
+# Or install globally as a CLI tool (recommended for command-line usage)
+uv tool install ngpt
 ```
 
 Requires Python 3.8 or newer.
 
-The full installation includes:
-- Enhanced markdown rendering with syntax highlighting
-- Improved interactive input experience with multiline editing
-
 For detailed installation instructions, see the [Installation Guide](https://nazdridoy.github.io/ngpt/installation.html).
 
 ## Usage
@@ -278,6 +286,47 @@ print(code)
 
 For advanced usage patterns and integrations, check out the [Advanced Examples](https://nazdridoy.github.io/ngpt/examples/advanced.html).
 
+### As a CLI Framework
+
+nGPT can also be used as a framework to build your own AI-powered command-line tools. You can leverage nGPT's pre-built CLI components to quickly develop sophisticated CLI applications.
+
+```python
+from ngpt import NGPTClient, load_config
+from ngpt.cli import interactive_chat_session, prettify_markdown, ColoredHelpFormatter
+import argparse
+
+# Create a custom CLI tool with colorized help
+parser = argparse.ArgumentParser(
+    description="Specialized Code Assistant",
+    formatter_class=ColoredHelpFormatter
+)
+parser.add_argument("prompt", nargs="?", help="Code description")
+parser.add_argument("--language", "-l", default="python", help="Programming language")
+parser.add_argument("--interactive", "-i", action="store_true", help="Start interactive mode")
+args = parser.parse_args()
+
+# Initialize client
+client = NGPTClient(**load_config())
+
+# Use interactive session for conversation
+if args.interactive:
+    system_prompt = f"You are an expert {args.language} developer. Provide clear, detailed answers."
+    interactive_chat_session(client=client, preprompt=system_prompt, prettify=True)
+elif args.prompt:
+    # Generate and prettify code
+    code = client.generate_code(args.prompt, language=args.language)
+    print(prettify_markdown(f"```{args.language}\n{code}\n```"))
+```
+
+This allows you to build specialized AI tools like:
+- Code generators for specific languages or frameworks
+- Domain-specific assistants (SQL, legal, finance, etc.)
+- Documentation generators
+- Translation tools
+- And much more
+
+For detailed information about building CLI tools with nGPT, see the [CLI Framework Guide](https://nazdridoy.github.io/ngpt/usage/cli_framework.html) and explore the [CLI Component Examples](https://nazdridoy.github.io/ngpt/examples/cli_components.html).
+
 ## Configuration
 
 ### Command Line Options
@@ -304,17 +353,85 @@ You can configure the client using the following options:
 | `--config` | Path to a custom configuration file or, when used without a value, enters interactive configuration mode |
 | `--config-index` | Index of the configuration to use (default: 0) |
 | `--provider` | Provider name to identify the configuration to use (alternative to --config-index) |
-| `--remove` | Remove the configuration at the specified index (requires --config and --config-index) |
+| `--remove` | Remove the configuration at the specified index (requires --config and --config-index or --provider) |
 | `--show-config` | Show configuration details and exit |
 | `--all` | Used with `--show-config` to display all configurations |
 | `-i, --interactive` | Start an interactive chat session with stylish UI, conversation history, and special commands |
 | `-s, --shell` | Generate and execute shell commands |
 | `-c, --code` | Generate clean code output |
 | `-t, --text` | Open interactive multiline editor for complex prompts |
+| `--language` | Programming language to generate code in (for code mode, default: python) |
+| `--cli-config` | Manage CLI configuration settings (set, get, unset, list, help) |
 | `-v, --version` | Show version information |
 
 For a complete reference of all available options, see the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage.html).
 
+### CLI Configuration
+
+NGPT offers a CLI configuration system that allows you to set default values for command-line options:
+
+```bash
+# Set default options
+ngpt --cli-config set language typescript
+ngpt --cli-config set temperature 0.9
+ngpt --cli-config set prettify true
+
+# View current settings
+ngpt --cli-config get
+
+# Get a specific setting
+ngpt --cli-config get language
+
+# Remove a setting
+ngpt --cli-config unset prettify
+
+# List all available options
+ngpt --cli-config list
+
+# Show help information
+ngpt --cli-config help
+```
+
+Key features of CLI configuration:
+- **Context-Aware**: Settings are applied based on the current command mode (e.g., `language` only applies in code generation mode `-c`).
+- **Priority**: When determining option values, NGPT uses the following priority order (highest to lowest):
+  1. Command-line arguments
+  2. Environment variables
+  3. CLI configuration (ngpt-cli.conf)
+  4. Main configuration file (ngpt.conf)
+  5. Default values
+- **Mutual Exclusivity**: For options like `no-stream`, `prettify`, and `stream-prettify`, setting one to `True` automatically sets the others to `False` in the configuration file, ensuring consistency.
+- **Smart Selection**: The `provider` setting is used to select which configuration profile to use, offering a persistent way to select your preferred API.
+
+Available options include:
+- General options (all modes): `provider`, `temperature`, `top_p`, `max_tokens`, `preprompt`, `renderer`, `config-index`, `web-search`
+- Mode-specific options: `language` (code mode only), `log` (interactive and text modes)
+- Mutually exclusive options: `no-stream`, `prettify`, `stream-prettify`
+
+#### Practical Examples
+
+```bash
+# Set Gemini as your default provider
+ngpt --cli-config set provider Gemini
+# Now you can run commands without specifying --provider
+ngpt "Explain quantum computing"
+
+# Configure code generation for TypeScript
+ngpt --cli-config set language typescript
+# Now in code mode, TypeScript will be used by default
+ngpt -c "Write a function to sort an array"
+
+# Set a higher temperature for more creative responses
+ngpt --cli-config set temperature 0.9
+```
+
+The CLI configuration is stored in:
+- Linux: `~/.config/ngpt/ngpt-cli.conf`
+- macOS: `~/Library/Application Support/ngpt/ngpt-cli.conf`
+- Windows: `%APPDATA%\ngpt\ngpt-cli.conf`
+
+For more details, see the [CLI Configuration Guide](https://nazdridoy.github.io/ngpt/usage/cli_config.html).
+
 ### Interactive Configuration
 
 The `--config` option without arguments enters interactive configuration mode, allowing you to add or edit configurations:
@@ -387,10 +504,11 @@ For details on the configuration file format and structure, see the [Configurati
 
 nGPT determines configuration values in the following order (highest priority first):
 
-1. Command line arguments (`--api-key`, `--base-url`, `--model`)
+1. Command line arguments (`--api-key`, `--base-url`, `--model`, etc.)
 2. Environment variables (`OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`)
-3. Configuration file (selected by `--config-index`, defaults to index 0)
-4. Default values
+3. CLI configuration file (`ngpt-cli.conf`, managed with `--cli-config`)
+4. Main configuration file `ngpt.conf` or `custom-config-file`
+5. Default values
 
 ## Contributing
 

ngpt-2.9.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+ngpt/__init__.py,sha256=awvycdj3tgcOr0BO81L4XU6DOtnToxFqkPHe1Pyu0Bw,652
+ngpt/cli.py,sha256=8E65ovaJE0OJ3-M6aw_FqCNSy_1-x1h4NwhnsZOlXq4,81580
+ngpt/cli_config.py,sha256=LatikOJTtohbmCfXM6AH44qplbpyAD-x1kMkmaJHRS0,9046
+ngpt/client.py,sha256=Rv-JO8RAmw1v3gdLkwaPe_PEw6p83cejO0YNT_DDjeg,15134
+ngpt/config.py,sha256=WYOk_b1eiYjo6hpV3pfXr2RjqhOnmKqwZwKid1T41I4,10363
+ngpt-2.9.0.dist-info/METADATA,sha256=mA32IXz-eKDqJBnXFjdOq9miHkQc2sDUBv78zw7sWec,20277
+ngpt-2.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-2.9.0.dist-info/entry_points.txt,sha256=1cnAMujyy34DlOahrJg19lePSnb08bLbkUs_kVerqdk,39
+ngpt-2.9.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-2.9.0.dist-info/RECORD,,

ngpt-2.7.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-ngpt/__init__.py,sha256=ehInP9w0MZlS1vZ1g6Cm4YE1ftmgF72CnEddQ3Le9n4,368
-ngpt/cli.py,sha256=kdEgC4mOml4I3uX_w1SsCZUqlaccdyIQGtox3IjPhbs,70115
-ngpt/client.py,sha256=Rv-JO8RAmw1v3gdLkwaPe_PEw6p83cejO0YNT_DDjeg,15134
-ngpt/config.py,sha256=WYOk_b1eiYjo6hpV3pfXr2RjqhOnmKqwZwKid1T41I4,10363
-ngpt-2.7.2.dist-info/METADATA,sha256=J1epGacDeo1w9bWUUqAQ8LvUI1I-rEtKIxm6TwRA-7U,15452
-ngpt-2.7.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-2.7.2.dist-info/entry_points.txt,sha256=1cnAMujyy34DlOahrJg19lePSnb08bLbkUs_kVerqdk,39
-ngpt-2.7.2.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-2.7.2.dist-info/RECORD,,