ngpt 2.12.0__py3-none-any.whl → 2.14.0__py3-none-any.whl

ngpt/cli/modes/rewrite.py

@@ -0,0 +1,209 @@
+import sys
+import platform
+from ..formatters import COLORS
+from ..renderers import prettify_markdown, prettify_streaming_markdown
+from ..ui import get_multiline_input
+
+# System prompt for rewriting text
+REWRITE_SYSTEM_PROMPT = """You are an expert text editor and rewriter. Your task is to rewrite the user's text to improve readability and flow while carefully preserving the original meaning, tone, and style.
+
+PRIMARY GOAL:
+Improve the quality and clarity of writing without changing the author's voice or intent.
+
+PRESERVATION RULES (HIGHEST PRIORITY):
+1. Preserve the exact meaning and information content
+2. Maintain the original tone (formal/casual/technical/friendly/serious/rude)
+3. Keep the author's perspective and point of view
+4. Respect the style of expression when intentional
+5. Retain technical terminology, jargon, and domain-specific language
+6. Keep all facts, data points, quotes, and references exactly as provided
+
+IMPROVEMENT FOCUS:
+1. Fix grammar, spelling, and punctuation errors
+2. Improve sentence structure and flow
+3. Enhance clarity and readability
+4. Make language more concise and precise
+5. Replace awkward phrasings with more natural alternatives
+6. Break up sentences longer than 25 words
+7. Convert passive voice to active when appropriate
+8. Remove redundancies, filler words, and unnecessary repetition
+
+FORMAT PRESERVATION:
+1. Maintain all paragraph breaks and section structures
+2. Preserve formatting of lists, bullet points, and numbering
+3. Keep code blocks (```) exactly as they appear with no changes to code
+4. Respect all markdown formatting (bold, italic, headers, etc.)
+5. Preserve URLs, email addresses, file paths, and variables exactly
+6. Maintain the structure of tables and other special formats
+
+CONTENT-SPECIFIC GUIDANCE:
+- For technical content: Prioritize precision and clarity over stylistic changes
+- For casual text: Maintain conversational flow and personality
+- For formal writing: Preserve professionalism while improving structure
+- For emotional content: Carefully maintain the emotional resonance and intensity
+
+STRICTLY AVOID:
+1. Adding new information not present in the original
+2. Removing key points or substantive content
+3. Significantly changing the formality level
+4. Inserting your own opinions or commentary
+5. Explaining what you changed (just provide the improved text)
+6. Altering the meaning of any sentence, even slightly
+7. Changing domain-specific terminology or jargon to general terms
+
+OUTPUT INSTRUCTION:
+Provide ONLY the rewritten text with no explanations, comments, or meta-text.
+
+EXAMPLES:
+
+ORIGINAL: "The implementation of the feature, which was delayed due to unforeseen technical complications, is now scheduled for next week's release."
+BETTER: "We delayed the feature implementation due to unforeseen technical complications. It's now scheduled for next week's release."
+
+ORIGINAL: "We was hoping you could help with this issue what we are having with the server."
+BETTER: "We were hoping you could help with this issue we're having with the server."
+
+ORIGINAL: "The user interface, which is built using React, Redux, and various other frontend technologies, needs to be redesigned to accommodate the new features that we want to add to the application."
+BETTER: "The React/Redux user interface needs redesigning to accommodate our planned new features."
+"""
+
+def get_terminal_input():
+    """Get input from terminal in a cross-platform way, even when stdin is redirected."""
+    if platform.system() == 'Windows':
+        # Windows-specific solution
+        try:
+            import msvcrt
+            print("Press Y/N...", end="")
+            sys.stdout.flush()
+            # Wait for a keypress
+            char = msvcrt.getch().decode('utf-8').lower()
+            print(char)  # Echo the character
+            return char
+        except ImportError:
+            # Fallback if msvcrt is not available
+            return None
+    else:
+        # Unix-like systems (Linux, macOS)
+        try:
+            with open('/dev/tty', 'r') as tty:
+                return tty.readline().strip().lower()
+        except (IOError, OSError):
+            return None
+
+def rewrite_mode(client, args, logger=None):
+    """Handle the text rewriting mode.
+    
+    Args:
+        client: The NGPTClient instance
+        args: The parsed command-line arguments
+        logger: Optional logger instance
+    """
+    # Determine the input source (stdin pipe, command-line argument, or multiline input)
+    if not sys.stdin.isatty():
+        # Read from stdin if data is piped
+        input_text = sys.stdin.read().strip()
+        
+        # If stdin is empty but prompt is provided, use the prompt
+        if not input_text and args.prompt:
+            input_text = args.prompt
+    elif args.prompt:
+        # Use the command-line argument if provided
+        input_text = args.prompt
+    else:
+        # No pipe or prompt - use multiline input
+        print("Enter or paste text to rewrite (Ctrl+D or Ctrl+Z to submit):")
+        input_text = get_multiline_input()
+        if input_text is None:
+            # Input was cancelled or empty
+            print("Exiting.")
+            return
+    
+    # Check if input is empty
+    if not input_text:
+        print(f"{COLORS['yellow']}Error: Empty input. Please provide text to rewrite.{COLORS['reset']}")
+        return
+    
+    # Set up messages array with system prompt and user content
+    messages = [
+        {"role": "system", "content": REWRITE_SYSTEM_PROMPT},
+        {"role": "user", "content": input_text}
+    ]
+    
+    print("\nSubmission successful. Waiting for response...")
+    
+    # Log the messages if logging is enabled
+    if logger:
+        logger.log("system", REWRITE_SYSTEM_PROMPT)
+        logger.log("user", input_text)
+    
+    # Set default streaming behavior based on --no-stream and --prettify arguments
+    should_stream = not args.no_stream and not args.prettify
+    
+    # If stream-prettify is enabled
+    stream_callback = None
+    live_display = None
+    
+    if args.stream_prettify:
+        should_stream = True  # Enable streaming
+        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
+            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']}")
+    
+    # Start live display if using stream-prettify
+    if args.stream_prettify and live_display:
+        live_display.start()
+    
+    response = client.chat(
+        prompt=None,  # Not used when messages are provided
+        stream=should_stream, 
+        web_search=args.web_search,
+        temperature=args.temperature, 
+        top_p=args.top_p,
+        max_tokens=args.max_tokens, 
+        markdown_format=args.prettify or args.stream_prettify,
+        stream_callback=stream_callback,
+        messages=messages  # Use messages array instead of prompt
+    )
+    
+    # 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:
+        if args.prettify:
+            prettify_markdown(response, args.renderer)
+        else:
+            print(response)
+            
+    # Offer to copy to clipboard if not in a redirected output
+    if not args.no_stream and sys.stdout.isatty():
+        try:
+            # Make sure to flush output before asking for input
+            print("\nCopy to clipboard? (y/n) ", end="")
+            sys.stdout.flush()
+            
+            # Cross-platform terminal input
+            answer = get_terminal_input()
+            
+            if answer == 'y':
+                try:
+                    import pyperclip
+                    pyperclip.copy(response)
+                    print("Copied to clipboard.")
+                except ImportError:
+                    print(f"{COLORS['yellow']}pyperclip not installed. Try: pip install \"ngpt[clipboard]\" {COLORS['reset']}")
+            
+        except (KeyboardInterrupt, EOFError):
+            pass 

ngpt/utils/cli_config.py

@@ -19,6 +19,12 @@ CLI_CONFIG_OPTIONS = {
     "renderer": {"type": "str", "default": "auto", "context": ["all"]},
     "config-index": {"type": "int", "default": 0, "context": ["all"], "exclusive": ["provider"]},
     "web-search": {"type": "bool", "default": False, "context": ["all"]},
+    # GitCommit message options
+    "message-context": {"type": "str", "default": None, "context": ["gitcommsg"]},
+    "recursive-chunk": {"type": "bool", "default": False, "context": ["gitcommsg"]},
+    "diff": {"type": "str", "default": None, "context": ["gitcommsg"]},
+    "chunk-size": {"type": "int", "default": 200, "context": ["gitcommsg"]},
+    "max-depth": {"type": "int", "default": 3, "context": ["gitcommsg"]},
 }
 
 def get_cli_config_dir() -> Path:

ngpt/utils/log.py

@@ -1,14 +1,24 @@
 import os
 import sys
 import datetime
+import logging
+import tempfile
 from pathlib import Path
-from typing import Optional, TextIO, Dict, Any
+from typing import Optional, TextIO, Dict, Any, Union
 
-# Simple color definitions for fallback message
+# Define colors locally to avoid circular imports
 COLORS = {
-    "green": "\033[32m",
+    "reset": "\033[0m",
+    "bold": "\033[1m",
+    "cyan": "\033[36m",
+    "green": "\033[32m", 
     "yellow": "\033[33m",
-    "reset": "\033[0m"
+    "red": "\033[31m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "gray": "\033[90m",
+    "bg_blue": "\033[44m",
+    "bg_cyan": "\033[46m"
 }
 
 class Logger:
@@ -165,6 +175,281 @@ class Logger:
         """
         return self.is_temp
 
+    # Add standard logging methods to be compatible with gitcommsg mode
+    def info(self, message: str):
+        """Log an info message."""
+        self.log("INFO", message)
+    
+    def debug(self, message: str):
+        """Log a debug message."""
+        self.log("DEBUG", message)
+    
+    def warning(self, message: str):
+        """Log a warning message."""
+        self.log("WARNING", message)
+    
+    def error(self, message: str, exc_info=False):
+        """Log an error message."""
+        if exc_info:
+            import traceback
+            message += "\n" + traceback.format_exc()
+        self.log("ERROR", message)
+
+
+class GitCommsgLogger:
+    """Specialized logger for gitcommsg mode with standard logging methods."""
+    
+    def __init__(self, log_path: Optional[str] = None):
+        """
+        Initialize the gitcommsg logger.
+        
+        Args:
+            log_path: Optional path to the log file. If None, a temporary file will be created.
+        """
+        self.log_path = log_path
+        self.logger = None
+        self.is_temp = False
+        self.command_args = sys.argv
+        
+        # Create a temporary log file if no path provided
+        if self.log_path is True or self.log_path is None:
+            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_gitcommsg_{timestamp}.log")
+            else:
+                self.log_path = f"/tmp/ngpt_gitcommsg_{timestamp}.log"
+            self.is_temp = True
+
+    def setup(self):
+        """Set up the logger."""
+        # Set up Python's standard logging module
+        self.logger = logging.getLogger("gitcommsg")
+        self.logger.setLevel(logging.DEBUG)
+        
+        # Clear any existing handlers
+        if self.logger.handlers:
+            for handler in self.logger.handlers:
+                self.logger.removeHandler(handler)
+        
+        # Create file handler
+        try:
+            # Ensure the directory exists
+            log_dir = os.path.dirname(self.log_path)
+            if log_dir and not os.path.exists(log_dir):
+                os.makedirs(log_dir, exist_ok=True)
+                
+            file_handler = logging.FileHandler(self.log_path)
+            file_handler.setLevel(logging.DEBUG)
+            
+            # Create formatter
+            formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+            file_handler.setFormatter(formatter)
+            
+            # Add handler to logger
+            self.logger.addHandler(file_handler)
+            
+            print(f"{COLORS['green']}Logging enabled. Log file: {self.log_path}{COLORS['reset']}")
+            self.logger.info("GitCommitMsg mode started")
+            self.logger.info(f"Command: {' '.join(self.command_args)}")
+            
+            return True
+        except Exception as e:
+            print(f"{COLORS['yellow']}Error setting up logger: {str(e)}{COLORS['reset']}")
+            return False
+
+    def info(self, message: str):
+        """Log an info message."""
+        if self.logger:
+            self.logger.info(message)
+    
+    def debug(self, message: str):
+        """Log a debug message."""
+        if self.logger:
+            self.logger.debug(message)
+    
+    def warning(self, message: str):
+        """Log a warning message."""
+        if self.logger:
+            self.logger.warning(message)
+    
+    def error(self, message: str, exc_info=False):
+        """Log an error message."""
+        if self.logger:
+            self.logger.error(message, exc_info=exc_info)
+
+    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 log_file_contents(self, level: str, description: str, filepath: str):
+        """
+        Log the contents of a file.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            description: Description of the file contents
+            filepath: Path to the file
+        """
+        if not self.logger or not os.path.isfile(filepath):
+            return
+            
+        try:
+            # Start marker with description
+            self.logger.log(
+                getattr(logging, level.upper()),
+                f"===== BEGIN {description}: {filepath} ====="
+            )
+            
+            # Read and log file contents
+            with open(filepath, 'r', encoding='utf-8', errors='replace') as f:
+                content = f.read()
+                for line in content.split('\n'):
+                    self.logger.log(
+                        getattr(logging, level.upper()),
+                        line
+                    )
+            
+            # End marker
+            self.logger.log(
+                getattr(logging, level.upper()),
+                f"===== END {description}: {filepath} ====="
+            )
+        except Exception as e:
+            self.logger.error(f"Error logging file contents: {str(e)}")
+            
+    def log_content(self, level: str, description: str, content: str):
+        """
+        Log the provided content.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            description: Description of the content
+            content: The content to log
+        """
+        if not self.logger:
+            return
+            
+        try:
+            # Create a temporary file for the content
+            fd, temp_path = tempfile.mkstemp(prefix="ngpt_log_", suffix=".txt")
+            with os.fdopen(fd, 'w', encoding='utf-8') as f:
+                f.write(content)
+                
+            # Log the content from the file
+            self.log_file_contents(level, description, temp_path)
+            
+            # Clean up the temporary file
+            try:
+                os.unlink(temp_path)
+            except Exception:
+                pass
+        except Exception as e:
+            if self.logger:
+                self.logger.error(f"Error logging content: {str(e)}")
+                
+    def log_prompt(self, level: str, system_prompt: Optional[str], user_prompt: str):
+        """
+        Log AI prompt information with detailed content.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            system_prompt: Optional system prompt
+            user_prompt: User prompt
+        """
+        if not self.logger:
+            return
+            
+        # Log summary
+        self.logger.log(
+            getattr(logging, level.upper()),
+            "AI Request:"
+        )
+        
+        # Log system prompt if provided
+        if system_prompt:
+            self.log_content(level, "SYSTEM_PROMPT", system_prompt)
+        
+        # Log user prompt
+        self.log_content(level, "USER_PROMPT", user_prompt)
+        
+    def log_response(self, level: str, response: str):
+        """
+        Log AI response with full content.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            response: The AI response
+        """
+        if not self.logger:
+            return
+            
+        # Log response
+        self.log_content(level, "AI_RESPONSE", response)
+        
+    def log_diff(self, level: str, diff_content: str):
+        """
+        Log git diff content.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            diff_content: The git diff content
+        """
+        if not self.logger:
+            return
+            
+        # Log diff content
+        self.log_content(level, "GIT_DIFF", diff_content)
+        
+    def log_chunks(self, level: str, chunk_number: int, total_chunks: int, chunk_content: str):
+        """
+        Log chunk content for processing.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            chunk_number: Current chunk number
+            total_chunks: Total number of chunks
+            chunk_content: Content of the chunk
+        """
+        if not self.logger:
+            return
+            
+        # Log chunk content
+        self.log_content(
+            level, 
+            f"CHUNK_{chunk_number}_OF_{total_chunks}", 
+            chunk_content
+        )
+        
+    def log_template(self, level: str, template_type: str, template: str):
+        """
+        Log prompt template.
+        
+        Args:
+            level: Log level (DEBUG, INFO, etc.)
+            template_type: Type of template (INITIAL, CHUNK, COMBINE, etc.)
+            template: Template content
+        """
+        if not self.logger:
+            return
+            
+        # Log template
+        self.log_content(level, f"{template_type}_TEMPLATE", template)
+
 
 def create_logger(log_path: Optional[str] = None) -> Logger:
     """
@@ -176,4 +461,19 @@ def create_logger(log_path: Optional[str] = None) -> Logger:
     Returns:
         Logger: Logger instance
     """
-    return Logger(log_path) 
+    return Logger(log_path)
+
+
+def create_gitcommsg_logger(log_path: Optional[str] = None) -> GitCommsgLogger:
+    """
+    Create a gitcommsg logger instance.
+    
+    Args:
+        log_path: Optional path to the log file
+        
+    Returns:
+        GitCommsgLogger: GitCommsgLogger instance
+    """
+    logger = GitCommsgLogger(log_path)
+    logger.setup()
+    return logger