ngpt 2.9.2__tar.gz → 2.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.9.2
+Version: 2.11.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
@@ -114,6 +114,9 @@ ngpt --preprompt "You are a Linux expert" "How do I find large files?"
 
 # Log your conversation to a file
 ngpt --interactive --log conversation.log
+
+# Create a temporary log file automatically
+ngpt --log "Tell me about quantum computing"
 ```
 
 For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage.html).
@@ -135,6 +138,7 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 - 🎭 **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
+- 🔌 **Modular Architecture**: Well-structured codebase with clean separation of concerns
 
 See the [Feature Overview](https://nazdridoy.github.io/ngpt/overview.html) for more details.
 
@@ -292,16 +296,14 @@ 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.main import interactive_chat_session
+from ngpt.cli.interactive import interactive_chat_session
 from ngpt.cli.renderers import prettify_markdown
-from ngpt.cli.formatters import ColoredHelpFormatter
-import argparse
+from ngpt.cli.args import setup_argument_parser
+import sys
 
 # Create a custom CLI tool with colorized help
-parser = argparse.ArgumentParser(
-    description="Specialized Code Assistant",
-    formatter_class=ColoredHelpFormatter
-)
+parser = setup_argument_parser()
+parser.description = "Specialized Code Assistant"
 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")
@@ -318,6 +320,9 @@ 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```"))
+else:
+    parser.print_help()
+    sys.exit(1)
 ```
 
 This allows you to build specialized AI tools like:
@@ -347,7 +352,7 @@ You can configure the client using the following options:
 | `--top_p` | Set top_p (controls diversity, default: 1.0) |
 | `--max_tokens` | Set maximum response length in tokens |
 | `--preprompt` | Set custom system prompt to control AI behavior |
-| `--log` | Set filepath to log conversation to (for interactive modes) |
+| `--log` | Enable logging: use `--log` to create a temporary log file, or `--log PATH` for a specific location |
 | `--prettify` | Render markdown responses and code with syntax highlighting |
 | `--stream-prettify` | Enable real-time markdown rendering with syntax highlighting while streaming |
 | `--renderer` | Select which markdown renderer to use with --prettify (auto, rich, or glow) |

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

@@ -79,6 +79,9 @@ ngpt --preprompt "You are a Linux expert" "How do I find large files?"
 
 # Log your conversation to a file
 ngpt --interactive --log conversation.log
+
+# Create a temporary log file automatically
+ngpt --log "Tell me about quantum computing"
 ```
 
 For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage.html).
@@ -100,6 +103,7 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 - 🎭 **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
+- 🔌 **Modular Architecture**: Well-structured codebase with clean separation of concerns
 
 See the [Feature Overview](https://nazdridoy.github.io/ngpt/overview.html) for more details.
 
@@ -257,16 +261,14 @@ 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.main import interactive_chat_session
+from ngpt.cli.interactive import interactive_chat_session
 from ngpt.cli.renderers import prettify_markdown
-from ngpt.cli.formatters import ColoredHelpFormatter
-import argparse
+from ngpt.cli.args import setup_argument_parser
+import sys
 
 # Create a custom CLI tool with colorized help
-parser = argparse.ArgumentParser(
-    description="Specialized Code Assistant",
-    formatter_class=ColoredHelpFormatter
-)
+parser = setup_argument_parser()
+parser.description = "Specialized Code Assistant"
 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")
@@ -283,6 +285,9 @@ 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```"))
+else:
+    parser.print_help()
+    sys.exit(1)
 ```
 
 This allows you to build specialized AI tools like:
@@ -312,7 +317,7 @@ You can configure the client using the following options:
 | `--top_p` | Set top_p (controls diversity, default: 1.0) |
 | `--max_tokens` | Set maximum response length in tokens |
 | `--preprompt` | Set custom system prompt to control AI behavior |
-| `--log` | Set filepath to log conversation to (for interactive modes) |
+| `--log` | Enable logging: use `--log` to create a temporary log file, or `--log PATH` for a specific location |
 | `--prettify` | Render markdown responses and code with syntax highlighting |
 | `--stream-prettify` | Enable real-time markdown rendering with syntax highlighting while streaming |
 | `--renderer` | Select which markdown renderer to use with --prettify (auto, rich, or glow) |

{ngpt-2.9.2 → ngpt-2.11.0}/docs/api/cli.md

@@ -18,7 +18,7 @@ def interactive_chat_session(
     temperature=0.7,
     top_p=1.0,
     max_tokens=None,
-    log_file=None,
+    logger=None,
     preprompt=None,
     prettify=False,
     renderer='auto',
@@ -35,7 +35,7 @@ Creates an interactive chat session with the specified AI client.
 - `temperature` (float): Temperature for generation (0.0-1.0)
 - `top_p` (float): Top-p sampling value (0.0-1.0)
 - `max_tokens` (int, optional): Maximum number of tokens to generate
-- `log_file` (str, optional): Path to file for logging the conversation
+- `logger` (object, optional): A logger instance with `log(role, message)` and `get_log_path()` methods for logging the conversation.
 - `preprompt` (str, optional): System prompt to use for the chat
 - `prettify` (bool): Whether to prettify markdown in responses
 - `renderer` (str): Markdown renderer to use ('auto', 'rich', 'glow')

{ngpt-2.9.2 → ngpt-2.11.0}/docs/configuration.md

@@ -131,7 +131,7 @@ You can also set configuration options directly via command-line arguments:
 - `--stream-prettify`: Enable real-time formatted output while streaming (uses Rich).
 - `--web-search`: Enable web search capability (if supported by the API).
 - `--preprompt <text>`: Set a custom system prompt.
-- `--log <file>`: Log the conversation to a file (in interactive modes).
+- `--log [file]`: Enable logging: use `--log` to create a temporary log file, or `--log PATH` for a specific location.
 - `--temperature <value>`: Set the generation temperature (0.0-2.0).
 - `--top_p <value>`: Set the nucleus sampling top_p value (0.0-1.0).
 - `--max_tokens <number>`: Set the maximum number of tokens for the response.
@@ -157,8 +157,11 @@ ngpt --temperature 0.8 --top_p 0.95 --max_tokens 300 "Write a creative story"
 # Set a custom system prompt (preprompt)
 ngpt --preprompt "You are a Linux command line expert. Focus on efficient solutions." "How do I find the largest files in a directory?"
 
-# Save conversation to a log file (for interactive modes)
+# Log conversation to a specific file
 ngpt --interactive --log conversation.log
+
+# Create a temporary log file automatically
+ngpt --log "Tell me about quantum computing"
 ```
 
 ## Environment Variables

{ngpt-2.9.2 → ngpt-2.11.0}/docs/examples/advanced.md

@@ -81,9 +81,12 @@ ngpt --interactive --preprompt "You are a Python programming tutor. Explain conc
 Save your conversation history to a file for reference:
 
 ```bash
-# Basic interactive session with logging
+# Basic interactive session with logging to a specific file
 ngpt --interactive --log python_tutoring.log
 
+# Create an automatic temporary log file
+ngpt --interactive --log
+
 # Combine logging with custom system prompt
 ngpt --interactive \
      --preprompt "You are a data science expert helping analyze experimental results." \
@@ -93,6 +96,9 @@ ngpt --interactive \
 ngpt --interactive \
      --preprompt "You are helping plan the architecture for a microservices application." \
      --log architecture_planning.log
+
+# Log non-interactive sessions
+ngpt --log "Explain quantum computing"
 ```
 
 The log file contains the complete conversation transcript, including:

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

@@ -18,19 +18,17 @@ Here's a simple CLI tool that uses nGPT to generate and explain code:
 
 ```python
 #!/usr/bin/env python3
-import argparse
 import sys
 from ngpt import NGPTClient, load_config
-from ngpt.cli.formatters import ColoredHelpFormatter
+from ngpt.cli.args import setup_argument_parser, validate_args
 from ngpt.cli.renderers import prettify_markdown, has_markdown_renderer
 
 def main():
     # Create parser with colorized help
-    parser = argparse.ArgumentParser(
-        description="Simple code generation tool",
-        formatter_class=ColoredHelpFormatter
-    )
+    parser = setup_argument_parser()
     
+    # Customize the parser for our specific needs
+    parser.description = "Simple code generation tool"
     parser.add_argument("prompt", help="Code description")
     parser.add_argument("--language", "-l", default="python", help="Programming language")
     parser.add_argument("--explain", "-e", action="store_true", help="Include explanation")

{ngpt-2.9.2 → ngpt-2.11.0}/docs/overview.md

@@ -28,6 +28,11 @@ nGPT is a lightweight Python library and command-line interface (CLI) tool desig
 
 - **Clean Code Generation**: Output code without markdown formatting or explanations.
 
+- 📝 **Rich Multiline Editor**: Interactive multiline text input with syntax highlighting and intuitive controls
+- 🎭 **System Prompts**: Customize model behavior with custom system prompts
+- 📃 **Conversation Logging**: Automatically or manually log conversations with timestamps and role information
+- 🧰 **CLI Components**: Reusable components for building custom AI-powered command-line tools
+
 ## Architecture
 
 nGPT is built around a few core components:

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

@@ -10,6 +10,7 @@ nGPT's CLI module has been modularized into several components that you can inco
 - **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`)
+- **Argument Parsing**: Sophisticated argument parsing and validation (`ngpt.cli.args`)
 - **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`)
 
@@ -28,6 +29,40 @@ This will install nGPT with all required dependencies, including:
 
 ## Available Components
 
+### Argument Parsing
+
+The `args` module provides utilities for building colorful, sophisticated command-line interfaces:
+
+```python
+from ngpt.cli.args import setup_argument_parser, validate_args, validate_markdown_renderer
+
+# Create and configure the parser
+parser = setup_argument_parser()
+args = parser.parse_args()
+
+# Validate arguments for correctness and compatibility
+try:
+    args = validate_args(args)
+except ValueError as e:
+    print(f"Error: {e}")
+    sys.exit(1)
+    
+# Check if markdown renderer is available
+has_renderer, args = validate_markdown_renderer(args)
+if not has_renderer:
+    print("Warning: No markdown renderer available. Using plain text.")
+```
+
+The argument parsing module provides these key functions:
+
+- `setup_argument_parser()`: Creates a fully configured argument parser with rich formatting
+- `parse_args()`: Parses command-line arguments
+- `validate_args(args)`: Validates parsed arguments for correctness and compatibility
+- `validate_markdown_renderer(args)`: Checks if markdown rendering is available
+- `handle_cli_config_args(args)`: Processes CLI configuration commands
+
+This modular approach makes it easy to create sophisticated CLI tools with consistent behavior.
+
 ### Interactive Chat Session
 
 The `interactive_chat_session` function provides a complete interactive chat experience:

{ngpt-2.9.2 → ngpt-2.11.0}/docs/usage/cli_usage.md

@@ -90,7 +90,7 @@ Below is a comprehensive list of all available command-line options, organized b
 
 | Option | Description |
 |--------|-------------|
-| `--log <file>` | Set filepath to log conversation to (for interactive modes) |
+| `--log [file]` | Enable logging: use `--log` to create a temporary log file, or `--log PATH` for a specific location |
 | `-v, --version` | Show version information and exit |
 | `-h, --help` | Show help message and exit |
 
@@ -120,13 +120,36 @@ This opens a continuous chat session where the AI remembers previous exchanges.
 - Use arrow keys to navigate message history
 - Press Ctrl+C to exit the session
 
-You can log your conversation to a file for later reference:
+#### Conversation Logging
+
+You can log your conversation in several ways:
 
 ```bash
+# Log to a specific file
 ngpt -i --log conversation.log
+
+# Automatically create a temporary log file
+ngpt -i --log
 ```
 
-This saves the entire conversation, including both user inputs and AI responses, to the specified file. 
+When using `--log` without a path, nGPT creates a temporary log file with a timestamp in the name:
+- On Linux/macOS: `/tmp/ngpt-YYYYMMDD-HHMMSS.log`
+- On Windows: `%TEMP%\ngpt-YYYYMMDD-HHMMSS.log`
+
+The log file contains timestamps, roles, and the full content of all messages exchanged, making it easy to reference conversations later.
+
+Logging works in all modes (not just interactive):
+
+```bash
+# Log in standard chat mode
+ngpt --log "Tell me about quantum computing"
+
+# Log in code generation mode 
+ngpt --code --log "function to calculate prime numbers"
+
+# Log in shell command mode
+ngpt --shell --log "find large files in current directory"
+```
 
 #### Combining with Other Options
 

ngpt-2.11.0/ngpt/cli/args.py

@@ -0,0 +1,161 @@
+import argparse
+import sys
+from .. import __version__
+from .formatters import COLORS, ColoredHelpFormatter
+from .renderers import has_markdown_renderer, warn_if_no_markdown_renderer
+
+def setup_argument_parser():
+    """Set up and return a fully configured argument parser for nGPT CLI."""
+    # 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"
+    
+    # Minimalist, clean epilog design
+    epilog = f"\n{COLORS['yellow']}nGPT {COLORS['bold']}v{__version__}{COLORS['reset']}  •  {COLORS['green']}Docs: {COLORS['bold']}https://nazdridoy.github.io/ngpt/usage/cli_usage.html{COLORS['reset']}"
+    
+    parser = argparse.ArgumentParser(description=description, formatter_class=ColoredHelpFormatter, epilog=epilog)
+    
+    # Add custom error method with color
+    original_error = parser.error
+    def error_with_color(message):
+        parser.print_usage(sys.stderr)
+        parser.exit(2, f"{COLORS['bold']}{COLORS['yellow']}error: {COLORS['reset']}{message}\n")
+    parser.error = error_with_color
+    
+    # Custom version action with color
+    class ColoredVersionAction(argparse.Action):
+        def __call__(self, parser, namespace, values, option_string=None):
+            print(f"{COLORS['green']}{COLORS['bold']}nGPT{COLORS['reset']} version {COLORS['yellow']}{__version__}{COLORS['reset']}")
+            parser.exit()
+    
+    # Version flag
+    parser.add_argument('-v', '--version', action=ColoredVersionAction, nargs=0, help='Show version information and exit')
+    
+    # Config options
+    config_group = parser.add_argument_group('Configuration Options')
+    config_group.add_argument('--config', nargs='?', const=True, help='Path to a custom config file or, if no value provided, enter interactive configuration mode to create a new config')
+    config_group.add_argument('--config-index', type=int, default=0, help='Index of the configuration to use or edit (default: 0)')
+    config_group.add_argument('--provider', help='Provider name to identify the configuration to use')
+    config_group.add_argument('--remove', action='store_true', help='Remove the configuration at the specified index (requires --config and --config-index)')
+    config_group.add_argument('--show-config', action='store_true', help='Show the current configuration(s) and exit')
+    config_group.add_argument('--all', action='store_true', help='Show details for all configurations (requires --show-config)')
+    config_group.add_argument('--list-models', action='store_true', help='List all available models for the current configuration and exit')
+    config_group.add_argument('--list-renderers', action='store_true', help='Show available markdown renderers for use with --prettify')
+    
+    # Global options
+    global_group = parser.add_argument_group('Global Options')
+    global_group.add_argument('--api-key', help='API key for the service')
+    global_group.add_argument('--base-url', help='Base URL for the API')
+    global_group.add_argument('--model', help='Model to use')
+    global_group.add_argument('--web-search', action='store_true', 
+                      help='Enable web search capability (Note: Your API endpoint must support this feature)')
+    global_group.add_argument('-n', '--no-stream', action='store_true',
+                      help='Return the whole response without streaming')
+    global_group.add_argument('--temperature', type=float, default=0.7,
+                      help='Set temperature (controls randomness, default: 0.7)')
+    global_group.add_argument('--top_p', type=float, default=1.0,
+                      help='Set top_p (controls diversity, default: 1.0)')
+    global_group.add_argument('--max_tokens', type=int, 
+                      help='Set max response length in tokens')
+    global_group.add_argument('--log', metavar='FILE', nargs='?', const=True,
+                      help='Set filepath to log conversation to, or create a temporary log file if no path provided')
+    global_group.add_argument('--preprompt', 
+                      help='Set custom system prompt to control AI behavior')
+    global_group.add_argument('--prettify', action='store_const', const='auto',
+                      help='Render markdown responses and code with syntax highlighting and formatting')
+    global_group.add_argument('--stream-prettify', action='store_true',
+                      help='Enable streaming with markdown rendering (automatically uses Rich renderer)')
+    global_group.add_argument('--renderer', choices=['auto', 'rich', 'glow'], default='auto',
+                      help='Select which markdown renderer to use with --prettify (auto, rich, or glow)')
+    
+    # Mode flags (mutually exclusive)
+    mode_group = parser.add_argument_group('Modes (mutually exclusive)')
+    mode_exclusive_group = mode_group.add_mutually_exclusive_group()
+    mode_exclusive_group.add_argument('-i', '--interactive', action='store_true', help='Start an interactive chat session')
+    mode_exclusive_group.add_argument('-s', '--shell', action='store_true', help='Generate and execute shell commands')
+    mode_exclusive_group.add_argument('-c', '--code', action='store_true', help='Generate code')
+    mode_exclusive_group.add_argument('-t', '--text', action='store_true', help='Enter multi-line text input (submit with Ctrl+D)')
+    # Note: --show-config is handled separately and implicitly acts as a mode
+    
+    # Language option for code mode
+    parser.add_argument('--language', default="python", help='Programming language to generate code in (for code mode)')
+    
+    # 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)')
+    
+    return parser
+
+def parse_args():
+    """Parse command line arguments using the configured parser."""
+    parser = setup_argument_parser()
+    return parser.parse_args()
+
+def validate_args(args):
+    """Validate parsed arguments for correctness and compatibility."""
+    # Validate --all usage
+    if args.all and not args.show_config:
+        raise ValueError("--all can only be used with --show-config")
+    
+    # Check if --prettify is used with --stream-prettify (conflict)
+    if args.prettify and args.stream_prettify:
+        raise ValueError("--prettify and --stream-prettify cannot be used together. Choose one option.")
+    
+    # Check if --stream-prettify is used but Rich is not available
+    if args.stream_prettify and not has_markdown_renderer('rich'):
+        raise ValueError("--stream-prettify requires Rich to be installed. Install with: pip install \"ngpt[full]\" or pip install rich")
+    
+    return args
+
+def validate_markdown_renderer(args):
+    """Validate that required markdown renderers are available.
+    
+    Args:
+        args: The parsed command line arguments.
+    
+    Returns:
+        tuple: (has_renderer, args)
+            - has_renderer: Boolean indicating if a renderer is available
+            - args: Potentially modified args with prettify disabled if no renderer is available
+    """
+    has_renderer = True
+    if args.prettify:
+        has_renderer = warn_if_no_markdown_renderer(args.renderer)
+        if not has_renderer:
+            # Set a flag to disable prettify since we already warned the user
+            print(f"{COLORS['yellow']}Continuing without markdown rendering.{COLORS['reset']}")
+            args.prettify = False
+    
+    return has_renderer, args
+
+def handle_cli_config_args(args):
+    """Process CLI configuration arguments and determine command parameters.
+    
+    Args:
+        args: The parsed command line arguments.
+        
+    Returns:
+        tuple: (should_handle, action, option, value)
+            - should_handle: True if --cli-config was specified and should be handled
+            - action: The action to perform (set, get, unset, list, help)
+            - option: The option name (or None)
+            - value: The option value (or None)
+    """
+    if args.cli_config is None:
+        return (False, None, None, 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"):
+        return (True, "help", None, None)
+    
+    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", "help"):
+        return (True, action, option, value)
+    else:
+        # Unknown action, show help
+        return (True, "help", None, None) 

{ngpt-2.9.2 → ngpt-2.11.0}/ngpt/cli/interactive.py

@@ -1,9 +1,11 @@
 import sys
+import os
 import shutil
 import datetime
 import traceback
 from .formatters import COLORS
 from .renderers import prettify_markdown, prettify_streaming_markdown
+from ..log import create_logger
 
 # Optional imports for enhanced UI
 try:
@@ -16,7 +18,7 @@ try:
 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):
+def interactive_chat_session(client, web_search=False, no_stream=False, temperature=0.7, top_p=1.0, max_tokens=None, preprompt=None, prettify=False, renderer='auto', stream_prettify=False, logger=None):
     """Start an interactive chat session with the AI.
     
     Args:
@@ -26,11 +28,11 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
         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
+        logger: Logger instance for logging the conversation
     """
     # Get terminal width for better formatting
     try:
@@ -58,18 +60,9 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
     
     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
+    # Show logging info if logger is available
+    if logger:
+        print(f"{COLORS['green']}Logging conversation to: {logger.get_log_path()}{COLORS['reset']}")
     
     # Custom separator - use the same length for consistency
     def print_separator():
@@ -90,9 +83,8 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
     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()
+    if logger and preprompt:
+        logger.log("system", system_prompt)
     
     # Initialize prompt_toolkit history
     prompt_history = InMemoryHistory() if HAS_PROMPT_TOOLKIT else None
@@ -187,9 +179,8 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
             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()
+            if logger:
+                logger.log("user", user_input)
             
             # Print assistant indicator with formatting
             if not no_stream and not stream_prettify:
@@ -254,22 +245,16 @@ def interactive_chat_session(client, web_search=False, no_stream=False, temperat
                     else:
                         print(response)
                 
-                # Log assistant response if logging is enabled
-                if log_handle:
-                    log_handle.write(f"Assistant: {response}\n\n")
-                    log_handle.flush()
+                # Log AI response if logging is enabled
+                if logger:
+                    logger.log("assistant", response)
             
             # Print separator between exchanges
             print_separator()
             
     except KeyboardInterrupt:
-        print(f"\n\n{COLORS['green']}Chat session ended by user. Goodbye!{COLORS['reset']}")
+        print(f"\n\n{COLORS['yellow']}Chat session interrupted by user.{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() 
+        print(f"\n{COLORS['yellow']}Error in chat session: {str(e)}{COLORS['reset']}")
+        if os.environ.get("NGPT_DEBUG"):
+            traceback.print_exc()