ngpt 2.10.0__tar.gz → 2.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.10.0
+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).
@@ -349,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.10.0 → 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).
@@ -314,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.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → 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.10.0 → ngpt-2.11.0}/ngpt/cli/args.py

@@ -56,8 +56,8 @@ def setup_argument_parser():
                       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',
-                      help='Set filepath to log conversation to (For interactive modes)')
+    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',

{ngpt-2.10.0 → 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() 

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli/main.py

@@ -12,6 +12,7 @@ from ..cli_config import (
     CLI_CONFIG_OPTIONS,
     load_cli_config
 )
+from ..log import create_logger
 from .. import __version__
 
 from .formatters import COLORS, ColoredHelpFormatter
@@ -195,6 +196,46 @@ def main():
     # Load CLI configuration early
     cli_config = load_cli_config()
     
+    # Initialize logger if --log is specified
+    logger = None
+    if args.log is not None:
+        # Check if the log value is a string that looks like a prompt (incorrectly parsed)
+        likely_prompt = False
+        likely_path = False
+        
+        if isinstance(args.log, str) and args.prompt is None:
+            # Check if string looks like a path
+            if args.log.startswith('/') or args.log.startswith('./') or args.log.startswith('../') or args.log.startswith('~'):
+                likely_path = True
+            # Check if string has a file extension
+            elif '.' in os.path.basename(args.log):
+                likely_path = True
+            # Check if parent directory exists
+            elif os.path.exists(os.path.dirname(args.log)) and os.path.dirname(args.log) != '':
+                likely_path = True
+            # Check if string ends with a question mark (very likely a prompt)
+            elif args.log.strip().endswith('?'):
+                likely_prompt = True
+            # As a last resort, if it has spaces and doesn't look like a path, assume it's a prompt
+            elif ' ' in args.log and not likely_path:
+                likely_prompt = True
+                
+        if likely_prompt and not likely_path:
+            # This is likely a prompt, not a log path
+            args.prompt = args.log
+            # Change log to True to create a temp file
+            args.log = True
+        
+        # If --log is True, it means it was used without a path value
+        log_path = None if args.log is True else args.log
+        logger = create_logger(log_path)
+        if logger:
+            logger.open()
+            print(f"{COLORS['green']}Logging session to: {logger.get_log_path()}{COLORS['reset']}")
+            # If it's a temporary log file, inform the user
+            if logger.is_temporary():
+                print(f"{COLORS['green']}Created temporary log file.{COLORS['reset']}")
+    
     # Priority order for config selection:
     # 1. Command-line arguments (args.provider, args.config_index)
     # 2. CLI configuration (cli_config["provider"], cli_config["config-index"])
@@ -426,7 +467,12 @@ def main():
         show_available_renderers()
     
     # Initialize client using the potentially overridden active_config
-    client = NGPTClient(**active_config)
+    client = NGPTClient(
+        api_key=active_config.get("api_key", args.api_key),
+        base_url=active_config.get("base_url", args.base_url),
+        provider=active_config.get("provider"),
+        model=active_config.get("model", args.model)
+    )
     
     try:
         # Handle listing models
@@ -459,32 +505,32 @@ def main():
                 temperature=args.temperature,
                 top_p=args.top_p,
                 max_tokens=args.max_tokens,
-                log_file=args.log,
                 preprompt=args.preprompt,
                 prettify=args.prettify,
                 renderer=args.renderer,
-                stream_prettify=args.stream_prettify
+                stream_prettify=args.stream_prettify,
+                logger=logger
             )
         elif args.shell:
             # Apply CLI config for shell mode
             args = apply_cli_config(args, "shell")
             
             # Shell command generation mode
-            shell_mode(client, args)
+            shell_mode(client, args, logger=logger)
                     
         elif args.code:
             # Apply CLI config for code mode
             args = apply_cli_config(args, "code")
             
             # Code generation mode
-            code_mode(client, args)
+            code_mode(client, args, logger=logger)
         
         elif args.text:
             # Apply CLI config for text mode
             args = apply_cli_config(args, "text")
             
             # Text mode (multiline input)
-            text_mode(client, args)
+            text_mode(client, args, logger=logger)
         
         else:
             # Default to chat mode
@@ -492,12 +538,15 @@ def main():
             args = apply_cli_config(args, "all")
             
             # Standard chat mode
-            chat_mode(client, args)
-    
+            chat_mode(client, args, logger=logger)
     except KeyboardInterrupt:
         print("\nOperation cancelled by user. Exiting gracefully.")
         # Make sure we exit with a non-zero status code to indicate the operation was cancelled
         sys.exit(130)  # 130 is the standard exit code for SIGINT (Ctrl+C)
     except Exception as e:
         print(f"Error: {e}")
-        sys.exit(1)  # Exit with error code 
+        sys.exit(1)  # Exit with error code
+    finally:
+        # Close the logger if it exists
+        if logger:
+            logger.close() 

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli/modes/chat.py

@@ -1,13 +1,15 @@
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ...log import create_logger
 import sys
 
-def chat_mode(client, args):
+def chat_mode(client, args, logger=None):
     """Handle the standard chat mode with a single prompt.
     
     Args:
         client: The NGPTClient instance
         args: The parsed command-line arguments
+        logger: Optional logger instance
     """
     # Get the prompt
     if args.prompt is None:
@@ -19,10 +21,18 @@ def chat_mode(client, args):
             sys.exit(130)
     else:
         prompt = args.prompt
+    
+    # Log the user message if logging is enabled
+    if logger:
+        logger.log("user", prompt)
         
     # Create messages array with preprompt if available
     messages = None
     if args.preprompt:
+        # Log the system message if logging is enabled
+        if logger:
+            logger.log("system", args.preprompt)
+            
         messages = [
             {"role": "system", "content": args.preprompt},
             {"role": "user", "content": prompt}
@@ -63,6 +73,10 @@ def chat_mode(client, args):
     # Stop live display if using stream-prettify
     if args.stream_prettify and live_display:
         live_display.stop()
+    
+    # Log the AI response if logging is enabled
+    if logger and response:
+        logger.log("assistant", response)
         
     # Handle non-stream response or regular prettify
     if (args.no_stream or args.prettify) and response:

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli/modes/code.py

@@ -1,13 +1,15 @@
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown, has_markdown_renderer, show_available_renderers
+from ...log import create_logger
 import sys
 
-def code_mode(client, args):
+def code_mode(client, args, logger=None):
     """Handle the code generation mode.
     
     Args:
         client: The NGPTClient instance
         args: The parsed command-line arguments
+        logger: Optional logger instance
     """
     if args.prompt is None:
         try:
@@ -18,6 +20,10 @@ def code_mode(client, args):
             sys.exit(130)
     else:
         prompt = args.prompt
+    
+    # Log the user prompt if logging is enabled
+    if logger:
+        logger.log("user", prompt)
 
     # Setup for streaming and prettify logic
     stream_callback = None
@@ -86,6 +92,10 @@ def code_mode(client, args):
     # Stop live display if using stream-prettify
     if use_stream_prettify and live_display:
         live_display.stop()
+    
+    # Log the generated code if logging is enabled
+    if logger and generated_code:
+        logger.log("assistant", generated_code)
         
     # Print non-streamed output if needed
     if generated_code and not should_stream:

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli/modes/shell.py

@@ -1,13 +1,15 @@
 from ..formatters import COLORS
+from ...log import create_logger
 import subprocess
 import sys
 
-def shell_mode(client, args):
+def shell_mode(client, args, logger=None):
     """Handle the shell command generation mode.
     
     Args:
         client: The NGPTClient instance
         args: The parsed command-line arguments
+        logger: Optional logger instance
     """
     if args.prompt is None:
         try:
@@ -18,12 +20,20 @@ def shell_mode(client, args):
             sys.exit(130)
     else:
         prompt = args.prompt
+    
+    # Log the user prompt if logging is enabled
+    if logger:
+        logger.log("user", prompt)
         
     command = client.generate_shell_command(prompt, web_search=args.web_search, 
                                          temperature=args.temperature, top_p=args.top_p,
                                          max_tokens=args.max_tokens)
     if not command:
         return  # Error already printed by client
+    
+    # Log the generated command if logging is enabled
+    if logger:
+        logger.log("assistant", command)
         
     print(f"\nGenerated command: {command}")
     
@@ -35,12 +45,32 @@ def shell_mode(client, args):
         return
         
     if response == 'y' or response == 'yes':
+        # Log the execution if logging is enabled
+        if logger:
+            logger.log("system", f"Executing command: {command}")
+            
         try:
             try:
                 print("\nExecuting command... (Press Ctrl+C to cancel)")
                 result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
-                print(f"\nOutput:\n{result.stdout}")
+                output = result.stdout
+                
+                # Log the command output if logging is enabled
+                if logger:
+                    logger.log("system", f"Command output: {output}")
+                    
+                print(f"\nOutput:\n{output}")
             except KeyboardInterrupt:
                 print("\nCommand execution cancelled by user.")
+                
+                # Log the cancellation if logging is enabled
+                if logger:
+                    logger.log("system", "Command execution cancelled by user")
         except subprocess.CalledProcessError as e:
-            print(f"\nError:\n{e.stderr}") 
+            error = e.stderr
+            
+            # Log the error if logging is enabled
+            if logger:
+                logger.log("system", f"Command error: {error}")
+                
+            print(f"\nError:\n{error}") 

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli/modes/text.py

@@ -1,13 +1,15 @@
 from ..formatters import COLORS
 from ..renderers import prettify_markdown, prettify_streaming_markdown
 from ..ui import get_multiline_input
+from ...log import create_logger
 
-def text_mode(client, args):
+def text_mode(client, args, logger=None):
     """Handle the multi-line text input mode.
     
     Args:
         client: The NGPTClient instance
         args: The parsed command-line arguments
+        logger: Optional logger instance
     """
     if args.prompt is not None:
         prompt = args.prompt
@@ -20,9 +22,17 @@ def text_mode(client, args):
     
     print("\nSubmission successful. Waiting for response...")
     
+    # Log the user message if logging is enabled
+    if logger:
+        logger.log("user", prompt)
+    
     # Create messages array with preprompt if available
     messages = None
     if args.preprompt:
+        # Log the system message if logging is enabled
+        if logger:
+            logger.log("system", args.preprompt)
+            
         messages = [
             {"role": "system", "content": args.preprompt},
             {"role": "user", "content": prompt}
@@ -64,6 +74,10 @@ def text_mode(client, args):
     if args.stream_prettify and live_display:
         live_display.stop()
         
+    # Log the AI response if logging is enabled
+    if logger and response:
+        logger.log("assistant", response)
+        
     # Handle non-stream response or regular prettify
     if (args.no_stream or args.prettify) and response:
         if args.prettify:

{ngpt-2.10.0 → ngpt-2.11.0}/ngpt/cli_config.py

@@ -11,7 +11,7 @@ CLI_CONFIG_OPTIONS = {
     "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"]},
+    "log": {"type": "str", "default": None, "context": ["all"]},
     "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"]},

ngpt-2.11.0/ngpt/log.py

@@ -0,0 +1,180 @@
+import os
+import sys
+import datetime
+import tempfile
+from pathlib import Path
+from typing import Optional, TextIO, Dict, Any
+
+# Simple color definitions for fallback message
+COLORS = {
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "reset": "\033[0m"
+}
+
+class Logger:
+    """Handles logging functionality for ngpt"""
+    
+    def __init__(self, log_path: Optional[str] = None):
+        """
+        Initialize the logger.
+        
+        Args:
+            log_path: Optional path to the log file. If None, a temporary file will be created.
+        """
+        self.log_path = log_path
+        self.log_file: Optional[TextIO] = None
+        self.is_temp = False
+        self.command_args = sys.argv
+        
+        if self.log_path is None:
+            # Create a temporary log file with date-time in the name
+            timestamp = datetime.datetime.now().strftime('%Y%m%d-%H%M%S')
+            
+            # Use OS-specific temp directory
+            if sys.platform == "win32":
+                # Windows
+                temp_dir = os.environ.get("TEMP", "")
+                self.log_path = os.path.join(temp_dir, f"ngpt-{timestamp}.log")
+            else:
+                # Linux/MacOS
+                self.log_path = f"/tmp/ngpt-{timestamp}.log"
+            
+            self.is_temp = True
+    
+    def __enter__(self):
+        """Context manager entry"""
+        self.open()
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.close()
+    
+    def open(self) -> bool:
+        """
+        Open the log file for writing.
+        
+        Returns:
+            bool: True if successful, False otherwise.
+        """
+        try:
+            # Expand ~ to home directory if present
+            if self.log_path.startswith('~'):
+                self.log_path = os.path.expanduser(self.log_path)
+                
+            # Make sure the directory exists
+            log_dir = os.path.dirname(self.log_path)
+            if log_dir and not os.path.exists(log_dir):
+                try:
+                    os.makedirs(log_dir, exist_ok=True)
+                except (PermissionError, OSError) as e:
+                    print(f"Warning: Could not create log directory: {str(e)}", file=sys.stderr)
+                    # Fall back to temp directory
+                    timestamp = datetime.datetime.now().strftime('%Y%m%d-%H%M%S')
+                    if sys.platform == "win32":
+                        temp_dir = os.environ.get("TEMP", "")
+                        self.log_path = os.path.join(temp_dir, f"ngpt-{timestamp}.log")
+                    else:
+                        self.log_path = f"/tmp/ngpt-{timestamp}.log"
+                    self.is_temp = True
+                
+            self.log_file = open(self.log_path, 'a', encoding='utf-8')
+            
+            # Write header information
+            timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            self.log_file.write(f"\n--- nGPT Session Log ---\n")
+            self.log_file.write(f"Started at: {timestamp}\n")
+            self.log_file.write(f"Command: {' '.join(self.command_args)}\n")
+            self.log_file.write(f"Log file: {self.log_path}\n\n")
+            self.log_file.flush()
+            
+            return True
+        except Exception as e:
+            print(f"Warning: Could not open log file: {str(e)}", file=sys.stderr)
+            
+            # Fall back to temp file
+            timestamp = datetime.datetime.now().strftime('%Y%m%d-%H%M%S')
+            if sys.platform == "win32":
+                temp_dir = os.environ.get("TEMP", "")
+                self.log_path = os.path.join(temp_dir, f"ngpt-{timestamp}.log")
+            else:
+                self.log_path = f"/tmp/ngpt-{timestamp}.log"
+            self.is_temp = True
+            
+            # Try again with temp file
+            try:
+                self.log_file = open(self.log_path, 'a', encoding='utf-8')
+                timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                self.log_file.write(f"\n--- nGPT Session Log ---\n")
+                self.log_file.write(f"Started at: {timestamp}\n")
+                self.log_file.write(f"Command: {' '.join(self.command_args)}\n")
+                self.log_file.write(f"Log file: {self.log_path}\n\n")
+                self.log_file.flush()
+                print(f"{COLORS['green']}Falling back to temporary log file: {self.log_path}{COLORS['reset']}", file=sys.stderr)
+                return True
+            except Exception as e2:
+                print(f"Warning: Could not open temporary log file: {str(e2)}", file=sys.stderr)
+                self.log_file = None
+                return False
+    
+    def close(self):
+        """Close the log file if it's open."""
+        if self.log_file:
+            try:
+                timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                self.log_file.write(f"\n--- Session ended at {timestamp} ---\n")
+                self.log_file.close()
+            except Exception:
+                pass
+            self.log_file = None
+    
+    def log(self, role: str, content: str):
+        """
+        Log a message.
+        
+        Args:
+            role: Role of the message (e.g., 'system', 'user', 'assistant')
+            content: Content of the message
+        """
+        if not self.log_file:
+            return
+            
+        try:
+            timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            self.log_file.write(f"{timestamp}: {role}: {content}\n")
+            self.log_file.flush()
+        except Exception:
+            # Silently fail if logging fails
+            pass
+
+    def get_log_path(self) -> str:
+        """
+        Get the path to the log file.
+        
+        Returns:
+            str: Path to the log file
+        """
+        return self.log_path
+
+    def is_temporary(self) -> bool:
+        """
+        Check if the log file is temporary.
+        
+        Returns:
+            bool: True if the log file is temporary
+        """
+        return self.is_temp
+
+
+def create_logger(log_path: Optional[str] = None) -> Logger:
+    """
+    Create a logger instance.
+    
+    Args:
+        log_path: Optional path to the log file
+        
+    Returns:
+        Logger: Logger instance
+    """
+    return Logger(log_path) 

{ngpt-2.10.0 → ngpt-2.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ngpt"
-version = "2.10.0"
+version = "2.11.0"
 description = "A lightweight Python CLI and library for interacting with OpenAI-compatible APIs, supporting both official and self-hosted LLM endpoints."
 authors = [
     {name = "nazDridoy", email = "nazdridoy399@gmail.com"},

{ngpt-2.10.0 → ngpt-2.11.0}/uv.lock

@@ -134,7 +134,7 @@ wheels = [
 
 [[package]]
 name = "ngpt"
-version = "2.10.0"
+version = "2.11.0"
 source = { editable = "." }
 dependencies = [
     { name = "prompt-toolkit" },