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

ngpt/cli/args.py

@@ -98,8 +98,12 @@ def setup_argument_parser():
                       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)')
+    gitcommsg_group.add_argument('--analyses-chunk-size', type=int, default=200,
+                      help='Number of lines per chunk when recursively chunking analyses (default: 200)')
+    gitcommsg_group.add_argument('--max-msg-lines', type=int, default=20,
+                      help='Maximum number of lines in commit message before condensing (default: 20)')
+    gitcommsg_group.add_argument('--max-recursion-depth', type=int, default=3,
+                      help='Maximum recursion depth for commit message condensing (default: 3)')
     
     # Mode flags (mutually exclusive)
     mode_group = parser.add_argument_group('Modes (mutually exclusive)')

ngpt/cli/modes/gitcommsg.py

@@ -68,56 +68,57 @@ def split_into_chunks(content, chunk_size=200):
         
     return chunks
 
-def process_context(context):
-    """Process context string to extract directives and filters.
+def create_technical_analysis_system_prompt(context=None):
+    """Create system prompt for technical analysis based on context data.
     
     Args:
-        context: The context string provided with -m/--message-context
+        context: The raw context string from -m flag
         
     Returns:
-        dict: Extracted context data
+        str: System prompt for the technical analysis stage
     """
-    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.
+    base_prompt = """You are an expert at analyzing git diffs and extracting precise technical details. Your task is to analyze the git diff and create a detailed technical summary of the changes.
+
+OUTPUT 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
+
+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. ALWAYS identify exact function names, method names, class names, and line numbers where possible
+4. Use format 'filename:function_name()' or 'filename:line_number' when referencing code locations
+5. Be precise and factual - only describe code that actually changed
+6. Include ALL significant changes (do not skip any important modifications)
+7. Focus on technical specifics, avoid general statements
+8. When analyzing multiple files, clearly separate each file's changes
+9. Include proper technical details (method names, component identifiers, etc.)"""
+
+    # If context is provided, append it with strong wording about absolute priority
+    if context:
+        context_prompt = f"""
+
+===CRITICAL USER CONTEXT - ABSOLUTE HIGHEST PRIORITY===
+The following context from the user OVERRIDES ALL OTHER INSTRUCTIONS and must be followed exactly:
+
+{context}
+
+THIS USER CONTEXT HAS ABSOLUTE PRIORITY over any other instructions in this prompt. If it contradicts other instructions, the user context MUST be followed. No exceptions."""
+        base_prompt += context_prompt
+    
+    return base_prompt
+
+def create_system_prompt(context=None):
+    """Create system prompt for commit message generation based on context data.
     
     Args:
-        context_data: The processed context data
+        context: The raw context string from -m flag
         
     Returns:
         str: System prompt for the AI
@@ -131,6 +132,15 @@ type[(scope)]: <concise summary> (max 50 chars)
 - [type] <specific change 2> (filename:function/method/line)
 - [type] <additional changes...>
 
+RULES FOR FILENAMES:
+1. For the FIRST mention of a file, use the full relative path
+2. For SUBSEQUENT mentions of the same file, use ONLY the filename without path
+   - Example: First mention: "utils/helpers/format.js" → Subsequent mentions: "format.js"
+3. Only include the full path again if there are multiple files with the same name
+4. For repeated mentions of the same file, consider grouping related changes in one bullet
+5. Avoid breaking filenames across lines
+6. Only include function names when they add clarity
+
 COMMIT TYPES:
 - feat: New user-facing features
 - fix: Bug fixes or error corrections
@@ -151,6 +161,46 @@ COMMIT TYPES:
 - ui: User interface changes
 - api: API-related changes
 
+EXAMPLES:
+
+1. Bug fix with UI scope:
+fix(ui): correct primary button focus style
+
+- [fix] Add :focus outline to Button component (Button.jsx:Button())
+- [chore] Bump Tailwind config to include ring-offset (tailwind.config.js:1-8)
+- [refactor] Extract common styles into buttonStyles util (styles/buttons.js:1-15)
+
+2. Feature with API scope:
+feat(api): add authentication endpoint for OAuth
+
+- [feat] Implement OAuth authentication route (auth/routes.js:createOAuthRoute())
+- [feat] Add token validation middleware (middleware/auth.js:validateToken())
+- [test] Add integration tests for OAuth flow (tests/auth.test.js:45-87)
+
+3. Multiple types in one commit:
+refactor(core): simplify data processing pipeline
+
+- [refactor] Replace nested loops with map/reduce (utils/process.js:transformData())
+- [perf] Optimize memory usage in large dataset handling (utils/memory.js:optimize())
+- [fix] Correct edge case in null value handling (utils/validators.js:checkNull())
+- [test] Update tests for new pipeline structure (tests/pipeline.test.js)
+
+4. Multiple changes to the same file:
+refactor(core): simplify context handling for commit prompts
+
+- [refactor] Remove process_context function (cli/modes/gitcommsg.py:69-124)
+- [refactor] Update all functions to accept raw context string (gitcommsg.py:create_system_prompt())
+- [refactor] Replace context_data usages with context (gitcommsg.py)
+- [docs] Update library usage doc (docs/usage/library_usage.md:516,531-537)
+- [chore] Bump project version to 2.15.1 (pyproject.toml:3, uv.lock:137)
+
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
 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
@@ -164,48 +214,17 @@ RULES:
 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
+    # If context is provided, append it with strong wording about absolute priority
+    if context:
+        context_prompt = f"""
+
+===CRITICAL USER CONTEXT - ABSOLUTE HIGHEST PRIORITY===
+The following context from the user OVERRIDES ALL OTHER INSTRUCTIONS and must be followed exactly:
+
+{context}
+
+THIS USER CONTEXT HAS ABSOLUTE PRIORITY over any other instructions in this prompt. If it contradicts other instructions, the user context MUST be followed. No exceptions."""
+        base_prompt += context_prompt
     
     return base_prompt
 
@@ -218,21 +237,14 @@ def create_chunk_prompt(chunk):
     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
+    return f"""Analyze this PARTIAL git diff and create a detailed technical summary.
 
-[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
+The system prompt already contains your output format instructions with [FILES], [CHANGES], and [IMPACT] sections.
 
-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.
+REMINDER: 
+- Identify exact function names, method names, class names, and line numbers
+- Use format 'filename:function_name()' or 'filename:line_number' for references
+- Be precise and factual - only describe code that actually changed
 
 Diff chunk:
 
@@ -251,61 +263,15 @@ def create_rechunk_prompt(combined_analysis, depth):
     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
+Create a terse technical summary following the format in the system prompt.
 
 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.
+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.
     
@@ -325,11 +291,13 @@ type[(scope)]: <concise summary> (max 50 chars)
 - [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
+1. For the FIRST mention of a file, use the full relative path
+2. For SUBSEQUENT mentions of the same file, use ONLY the filename without path
+   - Example: First mention: "utils/helpers/format.js" → Subsequent mentions: "format.js"
+3. Only include the full path again if there are multiple files with the same name
+4. For repeated mentions of the same file, consider grouping related changes in one bullet
+5. Avoid breaking filenames across lines
+6. Only include function names when they add clarity
 
 COMMIT TYPES:
 - feat: New user-facing features
@@ -351,6 +319,46 @@ COMMIT TYPES:
 - ui: User interface changes
 - api: API-related changes
 
+EXAMPLES:
+
+1. Bug fix with UI scope:
+fix(ui): correct primary button focus style
+
+- [fix] Add :focus outline to Button component (Button.jsx:Button())
+- [chore] Bump Tailwind config to include ring-offset (tailwind.config.js:1-8)
+- [refactor] Extract common styles into buttonStyles util (styles/buttons.js:1-15)
+
+2. Feature with API scope:
+feat(api): add authentication endpoint for OAuth
+
+- [feat] Implement OAuth authentication route (auth/routes.js:createOAuthRoute())
+- [feat] Add token validation middleware (middleware/auth.js:validateToken())
+- [test] Add integration tests for OAuth flow (tests/auth.test.js:45-87)
+
+3. Multiple types in one commit:
+refactor(core): simplify data processing pipeline
+
+- [refactor] Replace nested loops with map/reduce (utils/process.js:transformData())
+- [perf] Optimize memory usage in large dataset handling (utils/memory.js:optimize())
+- [fix] Correct edge case in null value handling (utils/validators.js:checkNull())
+- [test] Update tests for new pipeline structure (tests/pipeline.test.js)
+
+4. Multiple changes to the same file:
+refactor(core): simplify context handling for commit prompts
+
+- [refactor] Remove process_context function (cli/modes/gitcommsg.py:69-124)
+- [refactor] Update all functions to accept raw context string (gitcommsg.py:create_system_prompt())
+- [refactor] Replace context_data usages with context (gitcommsg.py)
+- [docs] Update library usage doc (docs/usage/library_usage.md:516,531-537)
+- [chore] Bump project version to 2.15.1 (pyproject.toml:3, uv.lock:137)
+
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
 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
@@ -441,23 +449,30 @@ def handle_api_call(client, prompt, system_prompt=None, logger=None, max_retries
             # Exponential backoff
             wait_seconds *= 2
 
-def process_with_chunking(client, diff_content, context_data, chunk_size=200, recursive=False, max_depth=3, logger=None):
+def process_with_chunking(client, diff_content, context, chunk_size=200, recursive=False, logger=None, max_msg_lines=20, max_recursion_depth=3, analyses_chunk_size=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
+        context: The raw context string
         chunk_size: Maximum number of lines per chunk
         recursive: Whether to use recursive chunking
-        max_depth: Maximum recursion depth
         logger: Optional logger instance
+        max_msg_lines: Maximum number of lines in commit message before condensing
+        max_recursion_depth: Maximum recursion depth for message condensing
+        analyses_chunk_size: Maximum number of lines per chunk for recursive analysis chunking
         
     Returns:
         str: Generated commit message
     """
-    # Create system prompt
-    system_prompt = create_system_prompt(context_data)
+    # If analyses_chunk_size not provided, default to chunk_size
+    if analyses_chunk_size is None:
+        analyses_chunk_size = chunk_size
+        
+    # Create different system prompts for different stages
+    technical_system_prompt = create_technical_analysis_system_prompt(context)
+    commit_system_prompt = create_system_prompt(context)
     
     # Log initial diff content
     if logger:
@@ -488,10 +503,10 @@ def process_with_chunking(client, diff_content, context_data, chunk_size=200, re
         if logger:
             logger.log_template("DEBUG", "CHUNK", chunk_prompt)
         
-        # Process chunk
+        # Process chunk - use technical system prompt for analysis
         print(f"{COLORS['yellow']}Analyzing changes...{COLORS['reset']}")
         try:
-            result = handle_api_call(client, chunk_prompt, system_prompt, logger)
+            result = handle_api_call(client, chunk_prompt, technical_system_prompt, logger)
             partial_analyses.append(result)
             print(f"{COLORS['green']}✓ Chunk {i+1} processed{COLORS['reset']}")
         except Exception as e:
@@ -517,11 +532,20 @@ def process_with_chunking(client, diff_content, context_data, chunk_size=200, re
     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)
+    if recursive and combined_line_count > analyses_chunk_size:
+        # Use recursive analysis chunking
+        return recursive_chunk_analysis(
+            client, 
+            combined_analyses, 
+            context, 
+            analyses_chunk_size,
+            logger,
+            max_msg_lines,
+            max_recursion_depth
+        )
     else:
-        # Use direct combination
+        # Combined analysis is under the chunk size limit, generate the commit message
+        print(f"{COLORS['green']}Generating commit message from combined analysis...{COLORS['reset']}")
         combine_prompt = create_combine_prompt(partial_analyses)
         
         # Log combine template
@@ -529,66 +553,62 @@ def process_with_chunking(client, diff_content, context_data, chunk_size=200, re
             logger.log_template("DEBUG", "COMBINE", combine_prompt)
         
         try:
-            result = handle_api_call(client, combine_prompt, system_prompt, logger)
-            return result
+            # Use commit message system prompt for final generation
+            commit_message = handle_api_call(client, combine_prompt, commit_system_prompt, logger)
+            
+            # If the commit message is too long, we need to condense it
+            if len(commit_message.splitlines()) > max_msg_lines:
+                return condense_commit_message(
+                    client,
+                    commit_message,
+                    commit_system_prompt,
+                    max_msg_lines,
+                    max_recursion_depth,
+                    1,  # Start at depth 1
+                    logger
+                )
+            return commit_message
         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.
+def recursive_chunk_analysis(client, combined_analysis, context, chunk_size, logger=None, max_msg_lines=20, max_recursion_depth=3, current_depth=1):
+    """Recursively chunk and process large analysis results until they're small enough.
     
     Args:
         client: The NGPTClient instance
         combined_analysis: The combined analysis to process
-        context_data: The processed context data
-        max_depth: Maximum recursion depth
+        context: The raw context string
+        chunk_size: Maximum number of lines per chunk
         logger: Optional logger instance
-        current_depth: Current recursion depth
+        max_msg_lines: Maximum number of lines in commit message before condensing
+        max_recursion_depth: Maximum recursion depth for message condensing
+        current_depth: Current recursive analysis depth
         
     Returns:
         str: Generated commit message
     """
-    system_prompt = create_system_prompt(context_data)
+    # Create different system prompts for different stages
+    technical_system_prompt = create_technical_analysis_system_prompt(context)
+    commit_system_prompt = create_system_prompt(context)
     
-    print(f"\n{COLORS['cyan']}Recursive chunking level {current_depth}/{max_depth}...{COLORS['reset']}")
+    print(f"\n{COLORS['cyan']}Recursive analysis chunking level {current_depth}...{COLORS['reset']}")
     
     if logger:
-        logger.info(f"Starting recursive chunking at depth {current_depth}/{max_depth}")
+        logger.info(f"Starting recursive analysis chunking at depth {current_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 analysis is under chunk size, generate the commit message
+    if len(combined_analysis.splitlines()) <= chunk_size:
+        print(f"{COLORS['green']}Analysis is small enough, generating commit message...{COLORS['reset']}")
         
-        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:
+        # Create final prompt
+        final_prompt = f"""Create a CONVENTIONAL COMMIT MESSAGE based on these analyzed git changes:
 
-{result}
+{combined_analysis}
 
 FORMAT:
 type[(scope)]: <concise summary> (max 50 chars)
@@ -597,6 +617,13 @@ type[(scope)]: <concise summary> (max 50 chars)
 - [type] <specific change 2> (filename:function/method/line)
 - [type] <additional changes...>
 
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
 RULES:
 1. First line must be under 50 characters
 2. Include a blank line after the first line
@@ -604,17 +631,281 @@ RULES:
 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", f"FINAL_PROMPT_DEPTH_{current_depth}", final_prompt)
+        
+        # Generate the commit message - use commit message system prompt
+        commit_message = handle_api_call(client, final_prompt, commit_system_prompt, logger)
+        
+        if logger:
+            logger.log_content("DEBUG", f"COMMIT_MESSAGE_DEPTH_{current_depth}", commit_message)
+        
+        # If the commit message is too long, we need to condense it
+        if len(commit_message.splitlines()) > max_msg_lines:
+            return condense_commit_message(
+                client,
+                commit_message,
+                commit_system_prompt,
+                max_msg_lines,
+                max_recursion_depth,
+                1,  # Start at depth 1
+                logger
+            )
+        return commit_message
+    
+    # Analysis is still too large, need to chunk it
+    print(f"{COLORS['yellow']}Analysis still too large ({len(combined_analysis.splitlines())} lines), chunking...{COLORS['reset']}")
+    
+    # Split the analysis into chunks
+    analysis_chunks = split_into_chunks(combined_analysis, chunk_size)
+    analysis_chunk_count = len(analysis_chunks)
+    
+    if logger:
+        logger.info(f"Split analysis into {analysis_chunk_count} chunks at depth {current_depth}")
+    
+    # Process each analysis chunk and get a condensed version
+    condensed_chunks = []
+    for i, analysis_chunk in enumerate(analysis_chunks):
+        print(f"\n{COLORS['cyan']}[Analysis chunk {i+1}/{analysis_chunk_count} at depth {current_depth}]{COLORS['reset']}")
+        
+        # Create a target size based on how many chunks we have
+        target_size = min(int(chunk_size / analysis_chunk_count), 100)  # Make sure it's not too small
+        
+        # Create a prompt to condense this analysis chunk
+        condense_prompt = f"""You are analyzing a PORTION of already analyzed git changes. This is analysis data, not raw git diff.
+
+Take this SECTION of technical analysis and condense it to be UNDER {target_size} lines while preserving the most important technical details.
+
+Keep the format consistent with the system prompt.
+Preserve full file paths, function names, and technical changes.
+Group related changes when appropriate.
+
+SECTION OF ANALYSIS TO CONDENSE:
+
+{analysis_chunk}"""
+        
+        if logger:
+            logger.log_template("DEBUG", f"CONDENSE_ANALYSIS_DEPTH_{current_depth}_CHUNK_{i+1}", condense_prompt)
+        
+        print(f"{COLORS['yellow']}Condensing analysis chunk {i+1}/{analysis_chunk_count}...{COLORS['reset']}")
+        
+        # Condense this analysis chunk - use technical system prompt for condensing analysis
+        try:
+            condensed_chunk = handle_api_call(client, condense_prompt, technical_system_prompt, logger)
+            condensed_chunks.append(condensed_chunk)
+            
+            if logger:
+                logger.log_content("DEBUG", f"CONDENSED_ANALYSIS_DEPTH_{current_depth}_CHUNK_{i+1}", condensed_chunk)
+                
+            print(f"{COLORS['green']}✓ Analysis chunk {i+1}/{analysis_chunk_count} condensed{COLORS['reset']}")
+        except Exception as e:
+            print(f"{COLORS['red']}Error condensing analysis chunk {i+1}: {str(e)}{COLORS['reset']}")
+            if logger:
+                logger.error(f"Error condensing analysis chunk {i+1} at depth {current_depth}: {str(e)}")
+            return None
+        
+        # Rate limit protection between chunks
+        if i < analysis_chunk_count - 1:
+            print(f"{COLORS['yellow']}Waiting to avoid rate limits...{COLORS['reset']}")
+            time.sleep(5)
+    
+    # Combine condensed chunks
+    combined_condensed = "\n\n".join(condensed_chunks)
+    condensed_line_count = len(combined_condensed.splitlines())
+    
+    print(f"\n{COLORS['cyan']}Condensed analysis to {condensed_line_count} lines at depth {current_depth}{COLORS['reset']}")
+    
+    if logger:
+        logger.info(f"Combined condensed analysis: {condensed_line_count} lines at depth {current_depth}")
+        logger.log_content("DEBUG", f"COMBINED_CONDENSED_DEPTH_{current_depth}", combined_condensed)
+    
+    # Recursively process the combined condensed analysis
+    return recursive_chunk_analysis(
+        client,
+        combined_condensed,
+        context,
+        chunk_size,
+        logger,
+        max_msg_lines,
+        max_recursion_depth,
+        current_depth + 1
+    )
+
+def condense_commit_message(client, commit_message, system_prompt, max_msg_lines, max_recursion_depth, current_depth=1, logger=None):
+    """Recursively condense a commit message to be under the maximum length.
+    
+    Args:
+        client: The NGPTClient instance
+        commit_message: The commit message to condense
+        system_prompt: The system prompt
+        max_msg_lines: Maximum number of lines in commit message
+        max_recursion_depth: Maximum recursion depth for condensing
+        current_depth: Current recursion depth
+        logger: Optional logger instance
+        
+    Returns:
+        str: Condensed commit message
+    """
+    # Always use commit message system prompt for condensing commit messages
+    if not isinstance(system_prompt, str) or not system_prompt.startswith("You are an expert Git commit message writer"):
+        system_prompt = create_system_prompt(None)  # Use default commit message system prompt
+    
+    commit_lines = len(commit_message.splitlines())
+    print(f"\n{COLORS['cyan']}Commit message has {commit_lines} lines (depth {current_depth}/{max_recursion_depth}){COLORS['reset']}")
+    
+    if logger:
+        logger.info(f"Commit message has {commit_lines} lines at depth {current_depth}/{max_recursion_depth}")
+        logger.log_content("DEBUG", f"COMMIT_MESSAGE_DEPTH_{current_depth}", commit_message)
+    
+    # If already under the limit, return as is
+    if commit_lines <= max_msg_lines:
+        return commit_message
+    
+    # Check if we've reached the maximum recursion depth
+    is_final_depth = current_depth >= max_recursion_depth
+    
+    # Create the condense prompt - only mention the specific max_msg_lines at final depth
+    if is_final_depth:
+        condense_prompt = f"""Rewrite this git commit message to be MUST BE AT MOST {max_msg_lines} LINES TOTAL.
+PRESERVE the first line exactly as is, and keep the most important changes in the bullet points.
+Group related changes when possible.
+
+CURRENT MESSAGE (TOO LONG):
+{commit_message}
+
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
+REQUIREMENTS:
+1. First line must be preserved exactly as is
+2. MUST BE AT MOST {max_msg_lines} LINES TOTAL including blank lines - THIS IS A HARD REQUIREMENT
+3. Include the most significant changes
+4. Group related changes when possible
+5. Keep proper formatting with bullet points
+6. Maintain detailed file/function references in each bullet point
+7. KEEP TYPE TAGS IN SQUARE BRACKETS: [type]"""
+    else:
+        # At earlier depths, don't specify the exact line count limit
+        condense_prompt = f"""Rewrite this git commit message to be more concise.
+PRESERVE the first line exactly as is, and keep the most important changes in the bullet points.
+Group related changes when possible.
+
+CURRENT MESSAGE (TOO LONG):
+{commit_message}
+
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
+REQUIREMENTS:
+1. First line must be preserved exactly as is
+2. Make the message significantly shorter while preserving key information
+3. Include the most significant changes
+4. Group related changes when possible
+5. Keep proper formatting with bullet points
+6. Maintain detailed file/function references in each bullet point
+7. KEEP TYPE TAGS IN SQUARE BRACKETS: [type]"""
+    
+    if logger:
+        logger.log_template("DEBUG", f"CONDENSE_PROMPT_DEPTH_{current_depth}", condense_prompt)
+    
+    print(f"{COLORS['yellow']}Condensing commit message (depth {current_depth}/{max_recursion_depth})...{COLORS['reset']}")
+    
+    try:
+        condensed_result = handle_api_call(client, condense_prompt, system_prompt, logger)
+        
+        if logger:
+            logger.log_content("DEBUG", f"CONDENSED_RESULT_DEPTH_{current_depth}", condensed_result)
+        
+        # Check if we need to condense further
+        condensed_lines = len(condensed_result.splitlines())
+        
+        if condensed_lines > max_msg_lines and current_depth < max_recursion_depth:
+            print(f"{COLORS['yellow']}Commit message still has {condensed_lines} lines. Further condensing...{COLORS['reset']}")
             
-            # Log final template
             if logger:
-                logger.log_template("DEBUG", "FINAL", final_prompt)
+                logger.info(f"Commit message still has {condensed_lines} lines after condensing at depth {current_depth}")
             
-            return handle_api_call(client, final_prompt, system_prompt, logger)
+            # Try again at the next depth
+            return condense_commit_message(
+                client,
+                condensed_result,
+                system_prompt,
+                max_msg_lines,
+                max_recursion_depth,
+                current_depth + 1,
+                logger
+            )
+        else:
+            return condensed_result
     except Exception as e:
-        print(f"{COLORS['red']}Error in recursive processing: {str(e)}{COLORS['reset']}")
+        print(f"{COLORS['red']}Error condensing commit message: {str(e)}{COLORS['reset']}")
         if logger:
-            logger.error(f"Error in recursive processing at depth {current_depth}: {str(e)}")
-        return None
+            logger.error(f"Error condensing commit message at depth {current_depth}: {str(e)}")
+        # Return the original message if condensing fails
+        return commit_message
+
+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.
+
+TASK: Synthesize these partial analyses into a complete conventional commit message 
+following the format specified in the system prompt.
+
+The analyses to combine:
+
+{all_analyses}
+
+RULES FOR FILENAMES:
+1. For the FIRST mention of a file, use the full relative path
+2. For SUBSEQUENT mentions of the same file, use ONLY the filename without path
+   - Example: First mention: "utils/helpers/format.js" → Subsequent mentions: "format.js"
+3. Only include the full path again if there are multiple files with the same name
+4. For repeated mentions of the same file, consider grouping related changes in one bullet
+
+BULLET POINT FORMAT:
+- Each bullet MUST start with a type in square brackets: [type]
+- DO NOT use the format "- type: description" (without square brackets)
+- Instead, ALWAYS use "- [type] description" (with square brackets)
+- Example: "- [feat] Add new login component" (correct)
+- Not: "- feat: Add new login component" (incorrect)
+
+EXAMPLE OF PROPERLY FORMATTED COMMIT MESSAGE:
+refactor(core): simplify context handling for commit prompts
+
+- [refactor] Remove process_context function (cli/modes/gitcommsg.py:69-124)
+- [refactor] Update all functions to accept raw context string (gitcommsg.py:create_system_prompt())
+- [refactor] Replace context_data usages with context (gitcommsg.py)
+- [docs] Update library usage doc (docs/usage/library_usage.md:516,531-537)
+- [chore] Bump project version to 2.15.1 (pyproject.toml:3, uv.lock:137)
+
+REMINDER:
+- First line must be under 50 characters
+- Include a blank line after the first line
+- Each bullet must include specific file references with format [type]
+- Include specific technical details in each bullet point
+
+DO NOT ask for the original diff or add explanations outside the commit message format."""
 
 def gitcommsg_mode(client, args, logger=None):
     """Handle the Git commit message generation mode.
@@ -678,19 +969,21 @@ def gitcommsg_mode(client, args, logger=None):
             active_logger.log_diff("DEBUG", diff_content)
         
         # Process context if provided
-        context_data = None
+        context = None
         if args.message_context:
-            context_data = process_context(args.message_context)
+            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))
+                active_logger.debug(f"Using raw context: {context}")
+                active_logger.log_content("DEBUG", "CONTEXT", context)
         
-        # Create system prompt
-        system_prompt = create_system_prompt(context_data)
+        # Create system prompts for different stages
+        technical_system_prompt = create_technical_analysis_system_prompt(context)
+        commit_system_prompt = create_system_prompt(context)
         
-        # Log system prompt
+        # Log system prompts
         if active_logger:
-            active_logger.log_template("DEBUG", "SYSTEM", system_prompt)
+            active_logger.log_template("DEBUG", "TECHNICAL_SYSTEM", technical_system_prompt)
+            active_logger.log_template("DEBUG", "COMMIT_SYSTEM", commit_system_prompt)
         
         print(f"\n{COLORS['green']}Generating commit message...{COLORS['reset']}")
         
@@ -701,19 +994,36 @@ def gitcommsg_mode(client, args, logger=None):
             if active_logger:
                 active_logger.info(f"Using chunk size: {chunk_size}")
         
+        # Get max_msg_lines from args or use default
+        max_msg_lines = getattr(args, 'max_msg_lines', 20)  # Default to 20 if not specified
+        if active_logger:
+            active_logger.info(f"Maximum commit message lines: {max_msg_lines}")
+        
+        # Get max_recursion_depth from args or use default
+        max_recursion_depth = getattr(args, 'max_recursion_depth', 3)  # Default to 3 if not specified
+        if active_logger:
+            active_logger.info(f"Maximum recursion depth for message condensing: {max_recursion_depth}")
+        
+        # Get analyses_chunk_size from args or use default
+        analyses_chunk_size = getattr(args, 'analyses_chunk_size', args.chunk_size)  # Default to chunk_size if not specified
+        if active_logger:
+            active_logger.info(f"Analyses chunk size: {analyses_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}")
+                active_logger.info(f"Using recursive chunking with max_recursion_depth: {max_recursion_depth}")
             
             result = process_with_chunking(
                 client, 
                 diff_content, 
-                context_data, 
+                context, 
                 chunk_size=args.chunk_size,
                 recursive=True,
-                max_depth=args.max_depth,
-                logger=active_logger
+                logger=active_logger,
+                max_msg_lines=max_msg_lines,
+                max_recursion_depth=max_recursion_depth,
+                analyses_chunk_size=analyses_chunk_size
             )
         else:
             # Direct processing without chunking
@@ -726,7 +1036,25 @@ def gitcommsg_mode(client, args, logger=None):
             if active_logger:
                 active_logger.log_template("DEBUG", "DIRECT_PROCESSING", prompt)
             
-            result = handle_api_call(client, prompt, system_prompt, active_logger)
+            # Use commit message system prompt for direct processing
+            result = handle_api_call(client, prompt, commit_system_prompt, active_logger)
+            
+            # Check if the result exceeds max_msg_lines and recursive_chunk is enabled
+            if result and len(result.splitlines()) > max_msg_lines:
+                print(f"{COLORS['yellow']}Commit message exceeds {max_msg_lines} lines, condensing...{COLORS['reset']}")
+                if active_logger:
+                    active_logger.info(f"Commit message exceeds {max_msg_lines} lines, starting condensing process")
+                
+                # Use our condense_commit_message function with commit message system prompt
+                result = condense_commit_message(
+                    client,
+                    result,
+                    commit_system_prompt,
+                    max_msg_lines,
+                    max_recursion_depth,
+                    1,  # Start at depth 1
+                    active_logger
+                )
         
         if not result:
             print(f"{COLORS['red']}Failed to generate commit message.{COLORS['reset']}")

ngpt/utils/cli_config.py

@@ -24,7 +24,9 @@ CLI_CONFIG_OPTIONS = {
     "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"]},
+    "analyses-chunk-size": {"type": "int", "default": 200, "context": ["gitcommsg"]},
+    "max-msg-lines": {"type": "int", "default": 20, "context": ["gitcommsg"]},
+    "max-recursion-depth": {"type": "int", "default": 3, "context": ["gitcommsg"]},
 }
 
 def get_cli_config_dir() -> Path:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ngpt
-Version: 2.14.1
+Version: 2.15.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
@@ -154,6 +154,13 @@ ngpt --log "Tell me about quantum computing"
 
 # Process text from stdin using the {} placeholder
 cat README.md | ngpt --stdin "Summarize this document: {}"
+
+# Use different model providers by specifying the provider name
+ngpt --provider Groq "Explain quantum computing"
+
+# Compare outputs from different providers
+ngpt --provider OpenAI "Explain quantum physics" > openai_response.txt
+ngpt --provider Ollama "Explain quantum physics" > ollama_response.txt
 ```
 
 For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdridoy.github.io/ngpt/usage/cli_usage.html).
@@ -162,7 +169,7 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 
 - ✅ **Versatile**: Use as a CLI tool, Python library, or CLI framework for building custom tools
 - 🪶 **Lightweight**: Minimal dependencies with everything you need included
-- 🔄 **API Flexibility**: Works with OpenAI, Ollama, Groq, and any compatible endpoint
+- 🔄 **API Flexibility**: Works with OpenAI, Ollama, Groq, Claude, and any compatible endpoint
 - 💬 **Interactive Chat**: Continuous conversation with memory in modern UI
 - 📊 **Streaming Responses**: Real-time output for better user experience
 - 🔍 **Web Search**: Integrated with compatible API endpoints
@@ -179,6 +186,8 @@ For more examples and detailed usage, visit the [CLI Usage Guide](https://nazdri
 - 📃 **Conversation Logging**: Save your conversations to text files for later reference
 - 🧰 **CLI Components**: Reusable components for building custom AI-powered command-line tools
 - 🔌 **Modular Architecture**: Well-structured codebase with clean separation of concerns
+- 🔄 **Provider Switching**: Easily switch between different LLM providers with a single parameter
+- 🚀 **Performance Optimized**: Fast response times and minimal resource usage
 
 See the [Feature Overview](https://nazdridoy.github.io/ngpt/overview.html) for more details.
 
@@ -327,6 +336,16 @@ print(result.stdout)
 # Returns only code without markdown or explanations
 code = client.generate_code("function that converts Celsius to Fahrenheit")
 print(code)
+
+# Compare responses from different providers
+openai_config = load_config(config_index=0)  # OpenAI
+groq_config = load_config(config_index=1)    # Groq
+
+openai_client = NGPTClient(**openai_config)
+groq_client = NGPTClient(**groq_config)
+
+openai_response = openai_client.chat("Explain quantum computing")
+groq_response = groq_client.chat("Explain quantum computing")
 ```
 
 For advanced usage patterns and integrations, check out the [Advanced Examples](https://nazdridoy.github.io/ngpt/examples/advanced.html).
@@ -392,6 +411,7 @@ You can configure nGPT using the following options:
 | `-t, --text` | Open interactive multiline editor for complex prompts with syntax highlighting |
 | `--stdin` | Read from stdin and use content with prompt. Use {} in prompt as placeholder for stdin content |
 | `--rewrite` | Rewrite text to improve quality while preserving original tone and meaning |
+| `--gitcommsg` | Generate AI-powered git commit messages from staged changes or diff files |
 
 #### Global Options
 

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

@@ -2,7 +2,7 @@ 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=fTX3ozqMT5fCcxlyrPQEEHeWxSpgDvdWSM4AtdIAIE8,11152
+ngpt/cli/args.py,sha256=VJM6ySMnVrXgKaGb7Qb3AQPYxcQCv3FfCI4x8YkAsLQ,11534
 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
@@ -12,16 +12,16 @@ ngpt/cli/ui.py,sha256=iMinm_QdsmwrEUpb7CBRexyyBqf4sviFI9M3E8D-hhA,5303
 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/gitcommsg.py,sha256=Kx9pWGWB2bMNFhpBPAa4q7VwHmJQwnZ2qoFrWK7t3gs,45080
 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=b7cXTxbRA-tQWgaehP_uRm_L8-677elPUXk290uzsTs,11110
+ngpt/utils/cli_config.py,sha256=tQxR3a2iXyc5TfRBPQHSUXPInO2dv_zTPGn04eWfmoo,11285
 ngpt/utils/config.py,sha256=WYOk_b1eiYjo6hpV3pfXr2RjqhOnmKqwZwKid1T41I4,10363
 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,,
+ngpt-2.15.1.dist-info/METADATA,sha256=vKoeQ_IrjV2UtPpEGsThb-i8wg6OE46qXw-UDZdj9YQ,23523
+ngpt-2.15.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ngpt-2.15.1.dist-info/entry_points.txt,sha256=SqAAvLhMrsEpkIr4YFRdUeyuXQ9o0IBCeYgE6AVojoI,44
+ngpt-2.15.1.dist-info/licenses/LICENSE,sha256=mQkpWoADxbHqE0HRefYLJdm7OpdrXBr3vNv5bZ8w72M,1065
+ngpt-2.15.1.dist-info/RECORD,,