ngpt 2.13.0__py3-none-any.whl → 2.14.1__py3-none-any.whl

ngpt/cli/args.py

@@ -88,6 +88,19 @@ def setup_argument_parser():
     global_group.add_argument('--renderer', choices=['auto', 'rich', 'glow'], default='auto',
                       help='Select which markdown renderer to use with --prettify (auto, rich, or glow)')
     
+    # GitCommit message options
+    gitcommsg_group = parser.add_argument_group('Git Commit Message Options')
+    gitcommsg_group.add_argument('-m', '--message-context', 
+                      help='Context to guide AI generation (e.g., file types, commit type)')
+    gitcommsg_group.add_argument('-r', '--recursive-chunk', action='store_true',
+                      help='Process large diffs in chunks with recursive analysis if needed')
+    gitcommsg_group.add_argument('--diff', metavar='FILE', nargs='?', const=True,
+                      help='Use diff from specified file instead of staged changes. If used without a path, uses the path from CLI config.')
+    gitcommsg_group.add_argument('--chunk-size', type=int, default=200,
+                      help='Number of lines per chunk when chunking is enabled (default: 200)')
+    gitcommsg_group.add_argument('--max-depth', type=int, default=3,
+                      help='Maximum recursion depth for recursive chunking (default: 3)')
+    
     # Mode flags (mutually exclusive)
     mode_group = parser.add_argument_group('Modes (mutually exclusive)')
     mode_exclusive_group = mode_group.add_mutually_exclusive_group()
@@ -103,6 +116,8 @@ def setup_argument_parser():
                                       help='Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content')
     mode_exclusive_group.add_argument('--rewrite', action='store_true',
                                       help='Rewrite text from stdin to be more natural while preserving tone and meaning')
+    mode_exclusive_group.add_argument('--gitcommsg', action='store_true',
+                                      help='Generate AI-powered git commit messages from staged changes or diff file')
     
     return parser
 

ngpt/cli/main.py

@@ -24,6 +24,7 @@ from .modes.code import code_mode
 from .modes.shell import shell_mode
 from .modes.text import text_mode
 from .modes.rewrite import rewrite_mode
+from .modes.gitcommsg import gitcommsg_mode
 from .args import parse_args, validate_args, handle_cli_config_args, setup_argument_parser, validate_markdown_renderer
 
 def show_cli_config_help():
@@ -45,7 +46,8 @@ def show_cli_config_help():
         "code": [],
         "interactive": [],
         "text": [],
-        "shell": []
+        "shell": [],
+        "gitcommsg": []  # Add gitcommsg context
     }
     
     for option, meta in CLI_CONFIG_OPTIONS.items():
@@ -70,7 +72,8 @@ def show_cli_config_help():
         ("code", "Code generation mode"),
         ("interactive", "Interactive mode"),
         ("text", "Text mode"),
-        ("shell", "Shell mode")
+        ("shell", "Shell mode"),
+        ("gitcommsg", "Git commit message mode")  # Add gitcommsg mode
     ]:
         if context_groups[mode]:
             print(f"\n    {COLORS['yellow']}Options for {options}:{COLORS['reset']}")
@@ -87,6 +90,8 @@ def show_cli_config_help():
     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 set recursive-chunk true{COLORS['reset']} - Enable recursive chunking for git commit messages")
+    print(f"    {COLORS['yellow']}ngpt --cli-config set diff /path/to/file.diff{COLORS['reset']} - Set default diff file for git commit messages")
     print(f"    {COLORS['yellow']}ngpt --cli-config get temperature{COLORS['reset']}          - Check the current temperature setting")
     print(f"    {COLORS['yellow']}ngpt --cli-config get{COLORS['reset']}                      - Show all current CLI settings")
     print(f"    {COLORS['yellow']}ngpt --cli-config unset language{COLORS['reset']}           - Remove language setting")
@@ -227,15 +232,17 @@ def main():
             # 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']}")
+        # Skip logger initialization for gitcommsg mode as it creates its own logger
+        if not args.gitcommsg:
+            # 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)
@@ -461,7 +468,7 @@ def main():
         return
     
     # For interactive mode, we'll allow continuing without a specific prompt
-    if not args.prompt and not (args.shell or args.code or args.text or args.interactive or args.show_config or args.list_models or args.rewrite):
+    if not args.prompt and not (args.shell or args.code or args.text or args.interactive or args.show_config or args.list_models or args.rewrite or args.gitcommsg):
         # Simply use the parser's help
         parser = setup_argument_parser()
         parser.print_help()
@@ -557,6 +564,13 @@ def main():
             # Rewrite mode (process stdin)
             rewrite_mode(client, args, logger=logger)
         
+        elif args.gitcommsg:
+            # Apply CLI config for gitcommsg mode
+            args = apply_cli_config(args, "gitcommsg")
+            
+            # Git commit message generation mode
+            gitcommsg_mode(client, args, logger=logger)
+        
         else:
             # Default to chat mode
             # Apply CLI config for default chat mode

ngpt/cli/modes/__init__.py

@@ -3,5 +3,6 @@ from .code import code_mode
 from .shell import shell_mode
 from .text import text_mode
 from .rewrite import rewrite_mode
+from .gitcommsg import gitcommsg_mode
 
-__all__ = ['chat_mode', 'code_mode', 'shell_mode', 'text_mode', 'rewrite_mode']
+__all__ = ['chat_mode', 'code_mode', 'shell_mode', 'text_mode', 'rewrite_mode', 'gitcommsg_mode']

ngpt/cli/modes/gitcommsg.py

@@ -0,0 +1,758 @@
+import os
+import re
+import sys
+import tempfile
+import time
+import subprocess
+from datetime import datetime
+import logging
+from ..formatters import COLORS
+from ...utils.log import create_gitcommsg_logger
+from ...utils.cli_config import get_cli_config_option
+
+def get_diff_content(diff_file=None):
+    """Get git diff content from file or git staged changes.
+    
+    Args:
+        diff_file: Path to a diff file to use instead of git staged changes
+        
+    Returns:
+        str: Content of the diff, or None if no diff is available
+    """
+    if diff_file:
+        try:
+            with open(diff_file, 'r') as f:
+                content = f.read()
+                return content
+        except Exception as e:
+            print(f"{COLORS['yellow']}Error reading diff file: {str(e)}{COLORS['reset']}")
+            return None
+            
+    # No diff file specified, get staged changes from git
+    try:
+        result = subprocess.run(
+            ["git", "diff", "--staged"], 
+            capture_output=True, 
+            text=True
+        )
+        
+        if result.returncode != 0:
+            raise Exception(f"Git command failed: {result.stderr}")
+            
+        # Check if there are staged changes
+        if not result.stdout.strip():
+            print(f"{COLORS['yellow']}No staged changes found. Stage changes with 'git add' first.{COLORS['reset']}")
+            return None
+            
+        return result.stdout
+    except Exception as e:
+        print(f"{COLORS['yellow']}Error getting git diff: {str(e)}{COLORS['reset']}")
+        return None
+
+def split_into_chunks(content, chunk_size=200):
+    """Split content into chunks of specified size.
+    
+    Args:
+        content: The content to split into chunks
+        chunk_size: Maximum number of lines per chunk
+        
+    Returns:
+        list: List of content chunks
+    """
+    lines = content.splitlines()
+    chunks = []
+    
+    for i in range(0, len(lines), chunk_size):
+        chunk = lines[i:i+chunk_size]
+        chunks.append("\n".join(chunk))
+        
+    return chunks
+
+def process_context(context):
+    """Process context string to extract directives and filters.
+    
+    Args:
+        context: The context string provided with -m/--message-context
+        
+    Returns:
+        dict: Extracted context data
+    """
+    context_data = {
+        "file_type_filter": None,
+        "commit_type": None,
+        "focus": None,
+        "exclusions": [],
+        "raw_context": context
+    }
+    
+    if not context:
+        return context_data
+    
+    # Extract commit type directive (e.g., "type:feat")
+    if "type:" in context:
+        match = re.search(r"type:(\w+)", context)
+        if match:
+            context_data["commit_type"] = match.group(1)
+    
+    # Extract file type filters
+    file_type_keywords = ["html", "css", "javascript", "python", "js", "py", "ui", "api", "config"]
+    for keyword in file_type_keywords:
+        if keyword in context.lower():
+            context_data["file_type_filter"] = keyword
+            break
+    
+    # Process focus/exclusion directives
+    if "focus on" in context.lower() or "only mention" in context.lower():
+        focus_match = re.search(r"focus(?:\s+on)?\s+(\w+)", context.lower())
+        if focus_match:
+            context_data["focus"] = focus_match.group(1)
+    
+    if any(x in context.lower() for x in ["ignore", "don't include", "exclude"]):
+        exclusion_matches = re.findall(r"(?:ignore|don't include|exclude)\s+(\w+)", context.lower())
+        context_data["exclusions"] = exclusion_matches
+    
+    return context_data
+
+def create_system_prompt(context_data=None):
+    """Create system prompt based on context data.
+    
+    Args:
+        context_data: The processed context data
+        
+    Returns:
+        str: System prompt for the AI
+    """
+    base_prompt = """You are an expert Git commit message writer. Your task is to analyze the git diff and create a precise, factual commit message following the conventional commit format.
+
+FORMAT:
+type[(scope)]: <concise summary> (max 50 chars)
+
+- [type] <specific change 1> (filename:function/method/line)
+- [type] <specific change 2> (filename:function/method/line)
+- [type] <additional changes...>
+
+COMMIT TYPES:
+- feat: New user-facing features
+- fix: Bug fixes or error corrections
+- refactor: Code restructuring (no behavior change)
+- style: Formatting/whitespace changes only
+- docs: Documentation only
+- test: Test-related changes
+- perf: Performance improvements
+- build: Build system changes
+- ci: CI/CD pipeline changes
+- chore: Routine maintenance tasks
+- revert: Reverting previous changes
+- add: New files without user-facing features
+- remove: Removing files/code
+- update: Changes to existing functionality
+- security: Security-related changes
+- config: Configuration changes
+- ui: User interface changes
+- api: API-related changes
+
+RULES:
+1. BE 100% FACTUAL - Mention ONLY code explicitly shown in the diff
+2. NEVER invent or assume changes not directly visible in the code
+3. EVERY bullet point MUST reference specific files/functions/lines
+4. Include ALL significant changes (do not skip any important modifications)
+5. If unsure about a change's purpose, describe WHAT changed, not WHY
+6. Keep summary line under 50 characters (mandatory)
+7. Use appropriate type tags for each change (main summary and each bullet)
+8. ONLY describe code that was actually changed
+9. Focus on technical specifics, avoid general statements
+10. Include proper technical details (method names, component identifiers, etc.)
+11. When all changes are to the same file, mention it once in the summary"""
+
+    if not context_data:
+        return base_prompt
+    
+    # Add file type filtering instructions
+    if context_data.get("file_type_filter"):
+        file_type = context_data["file_type_filter"]
+        file_type_prompt = f"""
+
+CRITICAL FILE TYPE FILTERING:
+You MUST INCLUDE ONLY changes to {file_type} files or files related to {file_type}.
+You MUST EXCLUDE ALL other files completely from your output.
+This is a strict filter - no exceptions allowed."""
+        base_prompt += file_type_prompt
+    
+    # Add commit type directive
+    if context_data.get("commit_type"):
+        commit_type = context_data["commit_type"]
+        commit_type_prompt = f"""
+
+CRITICAL COMMIT TYPE DIRECTIVE:
+You MUST use exactly "{commit_type}:" as the commit type prefix.
+This takes highest priority over any other commit type you might determine.
+Do not override this commit type based on your own analysis."""
+        base_prompt += commit_type_prompt
+    
+    # Add focus/exclusion directives
+    if context_data.get("focus"):
+        focus = context_data["focus"]
+        focus_prompt = f"""
+
+FOCUS DIRECTIVE:
+Focus exclusively on changes related to {focus}.
+Exclude everything else from your analysis."""
+        base_prompt += focus_prompt
+    
+    if context_data.get("exclusions"):
+        exclusions = ", ".join(context_data["exclusions"])
+        exclusion_prompt = f"""
+
+EXCLUSION DIRECTIVE:
+Completely ignore and exclude any mentions of: {exclusions}."""
+        base_prompt += exclusion_prompt
+    
+    return base_prompt
+
+def create_chunk_prompt(chunk):
+    """Create prompt for processing a single diff chunk.
+    
+    Args:
+        chunk: The diff chunk to process
+        
+    Returns:
+        str: Prompt for the AI
+    """
+    return f"""Analyze this PARTIAL git diff and create a detailed technical summary with this EXACT format:
+
+[FILES]: Comma-separated list of affected files with full paths
+
+[CHANGES]: 
+- Technical detail 1 (include specific function/method names and line numbers)
+- Technical detail 2 (be precise about exactly what code was added/modified/removed)
+- Additional technical details (include ALL significant changes in this chunk)
+
+[IMPACT]: Brief technical description of what the changes accomplish
+
+CRITICALLY IMPORTANT: Be extremely specific with technical details.
+ALWAYS identify exact function names, method names, class names, and line numbers where possible.
+Use format 'filename:function_name()' or 'filename:line_number' when referencing code locations.
+Be precise and factual - only describe code that actually changed.
+
+Diff chunk:
+
+{chunk}"""
+
+def create_rechunk_prompt(combined_analysis, depth):
+    """Create prompt for re-chunking process.
+    
+    Args:
+        combined_analysis: The combined analysis to re-chunk
+        depth: Current recursion depth
+        
+    Returns:
+        str: Prompt for the AI
+    """
+    return f"""IMPORTANT: You are analyzing SUMMARIES of git changes, not raw git diff.
+
+You are in a re-chunking process (depth: {depth}) where the input is already summarized changes.
+Create a TERSE summary of these summaries focusing ONLY ON TECHNICAL CHANGES:
+
+[CHANGES]:
+- Technical change 1 (specific file and function)
+- Technical change 2 (specific file and function)
+- Additional relevant changes
+
+DO NOT ask for raw git diff. These summaries are all you need to work with.
+Keep your response FACTUAL and SPECIFIC to what's in the summaries.
+
+Section to summarize:
+
+{combined_analysis}"""
+
+def create_combine_prompt(partial_analyses):
+    """Create prompt for combining partial analyses.
+    
+    Args:
+        partial_analyses: List of partial analyses to combine
+        
+    Returns:
+        str: Prompt for the AI
+    """
+    all_analyses = "\n\n".join(partial_analyses)
+    
+    return f"""===CRITICAL INSTRUCTION===
+You are working with ANALYZED SUMMARIES of git changes, NOT raw git diff.
+The raw git diff has ALREADY been processed into these summaries.
+DO NOT ask for or expect to see the original git diff.
+
+TASK: Synthesize these partial analyses into a complete conventional commit message:
+
+{all_analyses}
+
+Create a CONVENTIONAL COMMIT MESSAGE with:
+1. First line: "type[(scope)]: brief summary" (50 chars max)
+   - Include scope ONLY if you are 100% confident about the affected area
+   - Omit scope if changes affect multiple areas or scope is unclear
+2. ⚠️ ONE BLANK LINE IS MANDATORY - NEVER SKIP THIS STEP ⚠️
+   - This blank line MUST be present in EVERY commit message
+   - The blank line separates the summary from the detailed changes
+   - Without this blank line, the commit message format is invalid
+3. Bullet points with specific changes, each with appropriate [type] tag
+4. Reference files in EACH bullet point with function names or line numbers
+
+FILENAME & FUNCTION HANDLING RULES:
+- Include SPECIFIC function names, method names, or line numbers when available
+- Format as filename:function() or filename:line_number
+- Use short relative paths for files
+- Group related changes to the same file when appropriate
+- Avoid breaking long filenames across lines
+
+STRICTLY follow this format with NO EXPLANATION or additional commentary.
+DO NOT mention insufficient information or ask for the original diff."""
+
+def create_final_prompt(diff_content):
+    """Create prompt for direct processing without chunking.
+    
+    Args:
+        diff_content: The full diff content
+        
+    Returns:
+        str: Prompt for the AI
+    """
+    return f"""Analyze ONLY the exact changes in this git diff and create a precise, factual commit message.
+
+FORMAT:
+type[(scope)]: <concise summary> (max 50 chars)
+
+- [type] <specific change 1> (filename:function/method/line)
+- [type] <specific change 2> (filename:function/method/line)
+- [type] <additional changes...>
+
+RULES FOR FILENAMES:
+1. Use short relative paths when possible
+2. For multiple changes to the same file, consider grouping them
+3. Abbreviate long paths when they're repeated (e.g., 'commit.zsh' instead of full path)
+4. Avoid breaking filenames across lines
+5. Only include function names when they add clarity
+
+COMMIT TYPES:
+- feat: New user-facing features
+- fix: Bug fixes or error corrections
+- refactor: Code restructuring (no behavior change)
+- style: Formatting/whitespace changes only
+- docs: Documentation only
+- test: Test-related changes
+- perf: Performance improvements
+- build: Build system changes
+- ci: CI/CD pipeline changes
+- chore: Routine maintenance tasks
+- revert: Reverting previous changes
+- add: New files without user-facing features
+- remove: Removing files/code
+- update: Changes to existing functionality
+- security: Security-related changes
+- config: Configuration changes
+- ui: User interface changes
+- api: API-related changes
+
+RULES:
+1. BE 100% FACTUAL - Mention ONLY code explicitly shown in the diff
+2. NEVER invent or assume changes not directly visible in the code
+3. EVERY bullet point MUST reference specific files/functions/lines
+4. Include ALL significant changes (do not skip any important modifications)
+5. If unsure about a change's purpose, describe WHAT changed, not WHY
+6. Keep summary line under 50 characters (mandatory)
+7. Use appropriate type tags for each change (main summary and each bullet)
+8. ONLY describe code that was actually changed
+9. Focus on technical specifics, avoid general statements
+10. Include proper technical details (method names, component identifiers, etc.)
+11. When all changes are to the same file, mention it once in the summary
+
+Git diff to process:
+
+{diff_content}"""
+
+def handle_api_call(client, prompt, system_prompt=None, logger=None, max_retries=3):
+    """Handle API call with retries and error handling.
+    
+    Args:
+        client: The NGPTClient instance
+        prompt: The prompt to send to the API
+        system_prompt: Optional system prompt
+        logger: Optional logger instance
+        max_retries: Maximum number of retries on error
+        
+    Returns:
+        str: Response from the API
+    """
+    if logger:
+        # Enhanced logging of full prompt and system prompt
+        logger.log_prompt("DEBUG", system_prompt, prompt)
+    
+    retry_count = 0
+    wait_seconds = 5
+    
+    while True:
+        try:
+            # Create messages array with system prompt if available
+            messages = None
+            if system_prompt:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ]
+            else:
+                messages = [
+                    {"role": "user", "content": prompt}
+                ]
+            
+            response = client.chat(
+                prompt=prompt,
+                stream=False,
+                markdown_format=False,
+                messages=messages
+            )
+            
+            if logger:
+                # Log full response
+                logger.log_response("DEBUG", response)
+                
+            return response
+            
+        except Exception as e:
+            retry_count += 1
+            error_msg = f"Error (attempt {retry_count}/{max_retries}): {str(e)}"
+            
+            if logger:
+                logger.error(error_msg)
+                
+            if retry_count >= max_retries:
+                raise Exception(f"Failed after {max_retries} retries: {str(e)}")
+                
+            print(f"{COLORS['yellow']}{error_msg}{COLORS['reset']}")
+            print(f"{COLORS['yellow']}Retrying in {wait_seconds} seconds...{COLORS['reset']}")
+            
+            # Create a spinner effect for waiting
+            spinner = "⣾⣽⣻⢿⡿⣟⣯⣷"
+            for _ in range(wait_seconds * 5):
+                for char in spinner:
+                    sys.stdout.write(f"\r{COLORS['yellow']}Waiting... {char}{COLORS['reset']}")
+                    sys.stdout.flush()
+                    time.sleep(0.2)
+            
+            print("\r" + " " * 20 + "\r", end="")
+            
+            # Exponential backoff
+            wait_seconds *= 2
+
+def process_with_chunking(client, diff_content, context_data, chunk_size=200, recursive=False, max_depth=3, logger=None):
+    """Process diff with chunking to handle large diffs.
+    
+    Args:
+        client: The NGPTClient instance
+        diff_content: The diff content to process
+        context_data: The processed context data
+        chunk_size: Maximum number of lines per chunk
+        recursive: Whether to use recursive chunking
+        max_depth: Maximum recursion depth
+        logger: Optional logger instance
+        
+    Returns:
+        str: Generated commit message
+    """
+    # Create system prompt
+    system_prompt = create_system_prompt(context_data)
+    
+    # Log initial diff content
+    if logger:
+        logger.log_diff("DEBUG", diff_content)
+    
+    # Split diff into chunks
+    chunks = split_into_chunks(diff_content, chunk_size)
+    chunk_count = len(chunks)
+    
+    if logger:
+        logger.info(f"Processing {chunk_count} chunks of {chunk_size} lines each")
+    
+    print(f"{COLORS['green']}Processing diff in {chunk_count} chunks...{COLORS['reset']}")
+    
+    # Process each chunk
+    partial_analyses = []
+    for i, chunk in enumerate(chunks):
+        print(f"\n{COLORS['cyan']}[Chunk {i+1}/{chunk_count}]{COLORS['reset']}")
+        
+        # Log chunk content
+        if logger:
+            logger.log_chunks("DEBUG", i+1, chunk_count, chunk)
+        
+        # Create chunk prompt
+        chunk_prompt = create_chunk_prompt(chunk)
+        
+        # Log chunk template
+        if logger:
+            logger.log_template("DEBUG", "CHUNK", chunk_prompt)
+        
+        # Process chunk
+        print(f"{COLORS['yellow']}Analyzing changes...{COLORS['reset']}")
+        try:
+            result = handle_api_call(client, chunk_prompt, system_prompt, logger)
+            partial_analyses.append(result)
+            print(f"{COLORS['green']}✓ Chunk {i+1} processed{COLORS['reset']}")
+        except Exception as e:
+            print(f"{COLORS['red']}Error processing chunk {i+1}: {str(e)}{COLORS['reset']}")
+            if logger:
+                logger.error(f"Error processing chunk {i+1}: {str(e)}")
+            return None
+        
+        # Rate limit protection between chunks
+        if i < chunk_count - 1:
+            print(f"{COLORS['yellow']}Waiting to avoid rate limits...{COLORS['reset']}")
+            time.sleep(5)
+    
+    # Combine partial analyses
+    print(f"\n{COLORS['cyan']}Combining analyses from {len(partial_analyses)} chunks...{COLORS['reset']}")
+    
+    # Log partial analyses
+    if logger:
+        combined_analyses = "\n\n".join(partial_analyses)
+        logger.log_content("DEBUG", "PARTIAL_ANALYSES", combined_analyses)
+    
+    # Check if we need to use recursive chunking
+    combined_analyses = "\n\n".join(partial_analyses)
+    combined_line_count = len(combined_analyses.splitlines())
+    
+    if recursive and combined_line_count > 50 and max_depth > 0:
+        # Use recursive chunking
+        return recursive_process(client, combined_analyses, context_data, max_depth, logger)
+    else:
+        # Use direct combination
+        combine_prompt = create_combine_prompt(partial_analyses)
+        
+        # Log combine template
+        if logger:
+            logger.log_template("DEBUG", "COMBINE", combine_prompt)
+        
+        try:
+            result = handle_api_call(client, combine_prompt, system_prompt, logger)
+            return result
+        except Exception as e:
+            print(f"{COLORS['red']}Error combining analyses: {str(e)}{COLORS['reset']}")
+            if logger:
+                logger.error(f"Error combining analyses: {str(e)}")
+            return None
+
+def recursive_process(client, combined_analysis, context_data, max_depth, logger=None, current_depth=1):
+    """Process large analysis results recursively.
+    
+    Args:
+        client: The NGPTClient instance
+        combined_analysis: The combined analysis to process
+        context_data: The processed context data
+        max_depth: Maximum recursion depth
+        logger: Optional logger instance
+        current_depth: Current recursion depth
+        
+    Returns:
+        str: Generated commit message
+    """
+    system_prompt = create_system_prompt(context_data)
+    
+    print(f"\n{COLORS['cyan']}Recursive chunking level {current_depth}/{max_depth}...{COLORS['reset']}")
+    
+    if logger:
+        logger.info(f"Starting recursive chunking at depth {current_depth}/{max_depth}")
+        logger.debug(f"Combined analysis size: {len(combined_analysis.splitlines())} lines")
+        logger.log_content("DEBUG", f"COMBINED_ANALYSIS_DEPTH_{current_depth}", combined_analysis)
+    
+    # Create rechunk prompt
+    rechunk_prompt = create_rechunk_prompt(combined_analysis, current_depth)
+    
+    # Log rechunk template
+    if logger:
+        logger.log_template("DEBUG", f"RECHUNK_DEPTH_{current_depth}", rechunk_prompt)
+    
+    # Process rechunk
+    try:
+        result = handle_api_call(client, rechunk_prompt, system_prompt, logger)
+        
+        # Check if further recursive chunking is needed
+        result_line_count = len(result.splitlines())
+        
+        if result_line_count > 50 and current_depth < max_depth:
+            # Need another level of chunking
+            print(f"{COLORS['yellow']}Result still too large ({result_line_count} lines), continuing recursion...{COLORS['reset']}")
+            if logger:
+                logger.info(f"Result still too large ({result_line_count} lines), depth {current_depth}/{max_depth}")
+            
+            return recursive_process(client, result, context_data, max_depth, logger, current_depth + 1)
+        else:
+            # Final processing
+            print(f"{COLORS['green']}Recursion complete, generating final commit message...{COLORS['reset']}")
+            
+            # Create final combine prompt
+            final_prompt = f"""Create a CONVENTIONAL COMMIT MESSAGE based on these analyzed git changes:
+
+{result}
+
+FORMAT:
+type[(scope)]: <concise summary> (max 50 chars)
+
+- [type] <specific change 1> (filename:function/method/line)
+- [type] <specific change 2> (filename:function/method/line)
+- [type] <additional changes...>
+
+RULES:
+1. First line must be under 50 characters
+2. Include a blank line after the first line
+3. Each bullet must include specific file references
+4. BE SPECIFIC - mention technical details and function names
+
+DO NOT include any explanation or commentary outside the commit message format."""
+            
+            # Log final template
+            if logger:
+                logger.log_template("DEBUG", "FINAL", final_prompt)
+            
+            return handle_api_call(client, final_prompt, system_prompt, logger)
+    except Exception as e:
+        print(f"{COLORS['red']}Error in recursive processing: {str(e)}{COLORS['reset']}")
+        if logger:
+            logger.error(f"Error in recursive processing at depth {current_depth}: {str(e)}")
+        return None
+
+def gitcommsg_mode(client, args, logger=None):
+    """Handle the Git commit message generation mode.
+    
+    Args:
+        client: The NGPTClient instance
+        args: The parsed command line arguments
+        logger: Optional logger instance
+    """
+    # Set up logging if requested
+    custom_logger = None
+    log_path = None
+    
+    if args.log:
+        custom_logger = create_gitcommsg_logger(args.log)
+    
+    # Use both loggers if they exist
+    active_logger = logger if logger else custom_logger
+    
+    if active_logger:
+        active_logger.info("Starting gitcommsg mode")
+        active_logger.debug(f"Args: {args}")
+    
+    try:
+        # Check if --diff was explicitly passed on the command line
+        diff_option_provided = '--diff' in sys.argv
+        diff_path_provided = diff_option_provided and args.diff is not None and args.diff is not True
+        
+        # If --diff wasn't explicitly provided on the command line, don't use the config value
+        if not diff_option_provided:
+            # Even if diff is in CLI config, don't use it unless --diff flag is provided
+            diff_file = None
+            if active_logger:
+                active_logger.info("Not using diff file from CLI config because --diff flag was not provided")
+        else:
+            # --diff flag was provided on command line
+            if args.diff is True:
+                # --diff flag was used without a path, use the value from CLI config
+                success, config_diff = get_cli_config_option("diff")
+                diff_file = config_diff if success and config_diff else None
+                if active_logger:
+                    if diff_file:
+                        active_logger.info(f"Using diff file from CLI config: {diff_file}")
+                    else:
+                        active_logger.info("No diff file found in CLI config")
+            else:
+                # --diff flag was used with an explicit path
+                diff_file = args.diff
+                if active_logger:
+                    active_logger.info(f"Using explicitly provided diff file: {diff_file}")
+        
+        # Get diff content
+        diff_content = get_diff_content(diff_file)
+        
+        if not diff_content:
+            print(f"{COLORS['red']}No diff content available. Exiting.{COLORS['reset']}")
+            return
+        
+        # Log the diff content
+        if active_logger:
+            active_logger.log_diff("DEBUG", diff_content)
+        
+        # Process context if provided
+        context_data = None
+        if args.message_context:
+            context_data = process_context(args.message_context)
+            if active_logger:
+                active_logger.debug(f"Processed context: {context_data}")
+                active_logger.log_content("DEBUG", "CONTEXT_DATA", str(context_data))
+        
+        # Create system prompt
+        system_prompt = create_system_prompt(context_data)
+        
+        # Log system prompt
+        if active_logger:
+            active_logger.log_template("DEBUG", "SYSTEM", system_prompt)
+        
+        print(f"\n{COLORS['green']}Generating commit message...{COLORS['reset']}")
+        
+        # Process based on chunking options
+        result = None
+        if args.chunk_size:
+            chunk_size = args.chunk_size
+            if active_logger:
+                active_logger.info(f"Using chunk size: {chunk_size}")
+        
+        if args.recursive_chunk:
+            # Use chunking with recursive processing
+            if active_logger:
+                active_logger.info(f"Using recursive chunking with max_depth: {args.max_depth}")
+            
+            result = process_with_chunking(
+                client, 
+                diff_content, 
+                context_data, 
+                chunk_size=args.chunk_size,
+                recursive=True,
+                max_depth=args.max_depth,
+                logger=active_logger
+            )
+        else:
+            # Direct processing without chunking
+            if active_logger:
+                active_logger.info("Processing without chunking")
+            
+            prompt = create_final_prompt(diff_content)
+            
+            # Log final template
+            if active_logger:
+                active_logger.log_template("DEBUG", "DIRECT_PROCESSING", prompt)
+            
+            result = handle_api_call(client, prompt, system_prompt, active_logger)
+        
+        if not result:
+            print(f"{COLORS['red']}Failed to generate commit message.{COLORS['reset']}")
+            return
+        
+        # Display the result
+        print(f"\n{COLORS['green']}✨ Generated Commit Message:{COLORS['reset']}\n")
+        print(result)
+        
+        # Log the result
+        if active_logger:
+            active_logger.info("Generated commit message successfully")
+            active_logger.log_content("INFO", "FINAL_COMMIT_MESSAGE", result)
+        
+        # Try to copy to clipboard
+        try:
+            import pyperclip
+            pyperclip.copy(result)
+            print(f"\n{COLORS['green']}(Copied to clipboard){COLORS['reset']}")
+            if active_logger:
+                active_logger.info("Commit message copied to clipboard")
+        except ImportError:
+            if active_logger:
+                active_logger.debug("pyperclip not available, couldn't copy to clipboard")
+    
+    except Exception as e:
+        print(f"{COLORS['red']}Error: {str(e)}{COLORS['reset']}")
+        if active_logger:
+            active_logger.error(f"Error in gitcommsg mode: {str(e)}", exc_info=True) 

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 

{ngpt-2.13.0.dist-info → ngpt-2.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.13.0
+Version: 2.14.1
 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
@@ -110,6 +110,24 @@ echo "your text" | ngpt --rewrite
 # Rewrite text from a command-line argument
 ngpt --rewrite "your text to rewrite"
 
+# Rewrite text from a file
+cat file.txt | ngpt --rewrite
+
+# Generate AI-powered git commit messages for staged changes
+ngpt --gitcommsg
+
+# Generate commit message with context
+ngpt --gitcommsg -m "type:feat"
+
+# Process large diffs in chunks with recursive analysis
+ngpt --gitcommsg -r
+
+# Process a diff file instead of staged changes
+ngpt --gitcommsg --diff /path/to/changes.diff
+
+# Generate a commit message with logging for debugging
+ngpt --gitcommsg --log commit_log.txt
+
 # Use interactive multiline editor to enter text to rewrite
 ngpt --rewrite
 
@@ -156,6 +174,7 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 - 🧠 **Text Rewriting**: Improve text quality while maintaining original tone and meaning
 - 🧩 **Clean Code Generation**: Output code without markdown or explanations
 - 📝 **Rich Multiline Editor**: Interactive multiline text input with syntax highlighting and intuitive controls
+- 📑 **Git Commit Messages**: AI-powered generation of conventional, detailed commit messages from git diffs
 - 🎭 **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

{ngpt-2.13.0.dist-info → ngpt-2.14.1.dist-info}/RECORD

@@ -2,25 +2,26 @@ ngpt/__init__.py,sha256=kpKhViLakwMdHZkuLht2vWcjt0uD_5gR33gvMhfXr6w,664
 ngpt/__main__.py,sha256=j3eFYPOtCCFBOGh7NK5IWEnADnTMMSEB9GLyIDoW724,66
 ngpt/client.py,sha256=rLgDPmJe8_yi13-XUiHJ45z54rJVrupxWmeb-fQZGF4,15129
 ngpt/cli/__init__.py,sha256=hebbDSMGiOd43YNnQP67uzr67Ue6rZPwm2czynr5iZY,43
-ngpt/cli/args.py,sha256=1yuVgmBXPu3HrCkVtWBfJG5he90ij84UjPbY11TppPk,9965
+ngpt/cli/args.py,sha256=fTX3ozqMT5fCcxlyrPQEEHeWxSpgDvdWSM4AtdIAIE8,11152
 ngpt/cli/config_manager.py,sha256=NQQcWnjUppAAd0s0p9YAf8EyKS1ex5-0EB4DvKdB4dk,3662
 ngpt/cli/formatters.py,sha256=HBYGlx_7eoAKyzfy0Vq5L0yn8yVKjngqYBukMmXCcz0,9401
 ngpt/cli/interactive.py,sha256=DZFbExcXd7RylkpBiZBhiI6N8FBaT0m_lBes0Pvhi48,10894
-ngpt/cli/main.py,sha256=E51XQFIT2NGC1nV1FTQ0GAy-Q6fm730vDXhArqJDwRU,28019
+ngpt/cli/main.py,sha256=6GO4r9e9su7FFukj9JeVmJt1bJsqPOJBj6xo3iyMZXU,28911
 ngpt/cli/renderers.py,sha256=gJ3WdVvCGkNxrLEkLCh6gk9HBFMK8y7an6CsEkqt2Z8,10535
 ngpt/cli/ui.py,sha256=iMinm_QdsmwrEUpb7CBRexyyBqf4sviFI9M3E8D-hhA,5303
-ngpt/cli/modes/__init__.py,sha256=i1ZKe7QsKkQ1g8Ip-NmyltZRQQI6nwXRq35bsmER8BU,229
+ngpt/cli/modes/__init__.py,sha256=R3aO662RIzWEOvr3moTrEI8Tpg0zDDyMGGh1-OxiRgM,285
 ngpt/cli/modes/chat.py,sha256=4a5EgM_5A1zCSrLrjgQMDnBwIHd1Rnu5_BjSKSm7p24,4255
 ngpt/cli/modes/code.py,sha256=RjOAj7BDO5vLUdIPkUfPtyIkI_W6qEHsZvYh-sIdVaM,4293
+ngpt/cli/modes/gitcommsg.py,sha256=eme_E1JFOndh1yWP90ryYcrsx6K5VLQqPoTIJDKwCsQ,28164
 ngpt/cli/modes/rewrite.py,sha256=Zb0PFvWRKXs4xJCF3GEdYc-LSmy6qRszz8-QJuldHc0,8595
 ngpt/cli/modes/shell.py,sha256=lF9f7w-0bl_FdZl-WJnZuV736BKrWQtrwoKr3ejPXFE,2682
 ngpt/cli/modes/text.py,sha256=ncYnfLFMdTPuHiOvAaHNiOWhox6GF6S-2fTwMIrAz-g,3140
 ngpt/utils/__init__.py,sha256=E46suk2-QgYBI0Qrs6WXOajOUOebF3ETAFY7ah8DTWs,942
-ngpt/utils/cli_config.py,sha256=A1TgO1rkRs6zgfNwIw5v8-N5jxqrHMZ4B6r3w48egi8,10687
+ngpt/utils/cli_config.py,sha256=b7cXTxbRA-tQWgaehP_uRm_L8-677elPUXk290uzsTs,11110
 ngpt/utils/config.py,sha256=WYOk_b1eiYjo6hpV3pfXr2RjqhOnmKqwZwKid1T41I4,10363
-ngpt/utils/log.py,sha256=3AJiry9vUbo9Rzzrgj6-NMM4lCbgoZhrGcXvdxMqtrs,6353
-ngpt-2.13.0.dist-info/METADATA,sha256=KseQZjNtDa7N5uJVZ0XFThyLh7fawca-6mEUHFzMcjY,21987
-ngpt-2.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ngpt-2.13.0.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
-ngpt-2.13.0.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
-ngpt-2.13.0.dist-info/RECORD,,
+ngpt/utils/log.py,sha256=f1jg2iFo35PAmsarH8FVL_62plq4VXH0Mu2QiP6RJGw,15934
+ngpt-2.14.1.dist-info/METADATA,sha256=MRsUrLvG2mRWtZ7ZxhbTzf1GQ43gY9E_LjVIPIr_NSU,22573
+ngpt-2.14.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-2.14.1.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-2.14.1.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-2.14.1.dist-info/RECORD,,