ngpt 2.13.0__tar.gz → 2.14.1__tar.gz

{ngpt-2.13.0 → ngpt-2.14.1}/.gitignore

@@ -11,3 +11,5 @@ wheels/
 
 # Environment variables
 .env
+# Reference files
+ref-*

{ngpt-2.13.0 → ngpt-2.14.1}/PKG-INFO

@@ -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 → ngpt-2.14.1}/README.md

@@ -74,6 +74,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
 
@@ -120,6 +138,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 → ngpt-2.14.1}/docs/api/cli.md

@@ -21,6 +21,7 @@ The CLI components for nGPT are organized into a modular structure under the `ng
     - `ngpt.cli.modes.code`: Code generation mode functionality
     - `ngpt.cli.modes.shell`: Shell command generation mode functionality
     - `ngpt.cli.modes.text`: Text generation mode functionality
+    - `ngpt.cli.modes.rewrite`: Text rewriting mode functionality
 
 ## Interactive Chat Module
 

{ngpt-2.13.0 → ngpt-2.14.1}/docs/usage/cli_config.md

@@ -66,9 +66,81 @@ These options are mutually exclusive:
 
 Some options only apply in specific modes:
 
+#### Code Mode Options
 - `language` - Programming language for code generation (only for code mode)
+
+#### Logging Options
 - `log` - Filepath to log conversation (for interactive and text modes)
 
+#### Git Commit Message Mode Options
+- `message-context` - Context to guide AI generation (e.g., file types, commit type directive)
+- `recursive-chunk` - Process large diffs in chunks with recursive analysis if needed (default: false)
+- `diff` - Path to diff file to use instead of staged git changes
+- `chunk-size` - Number of lines per chunk when chunking is enabled (default: 200)
+- `max-depth` - Maximum recursion depth for recursive chunking (default: 3)
+
+### Git Commit Message Options Details
+
+These options control the behavior of the `--gitcommsg` mode, which helps generate conventional commit messages from git diffs.
+
+#### message-context
+This option provides contextual information to guide the AI when generating commit messages. It accepts various directives:
+
+```bash
+# Set a default context for commit message generation
+ngpt --cli-config set message-context "type:feat focus on UI"
+```
+
+The context can include:
+- **Commit type directives**: `type:feat`, `type:fix`, `type:docs`, etc.
+- **File type filtering**: `javascript`, `python`, `css`, etc.
+- **Focus directives**: `focus on auth`, `focus on UI`, etc.
+- **Exclusion directives**: `ignore formatting`, `exclude tests`, etc.
+
+#### recursive-chunk
+When set to `true`, this enables recursive chunking for processing large diffs, which is helpful for large commits:
+
+```bash
+# Enable recursive chunking by default
+ngpt --cli-config set recursive-chunk true
+```
+
+With recursive chunking enabled, the system will:
+1. Split large diffs into chunks
+2. Process each chunk separately
+3. Further break down large intermediate results if needed
+4. Combine everything into a final commit message
+
+#### diff
+This specifies a default path to a diff file. When using the `--gitcommsg` command with `--diff` (without specifying a file), it will use this configured path:
+
+```bash
+# Set a default diff file path
+ngpt --cli-config set diff /path/to/changes.diff
+```
+
+**Important Note**: The diff file from CLI config is only used when you explicitly provide the `--diff` flag without a specific path. If you don't include the `--diff` flag, the system will always use git staged changes regardless of this setting.
+
+#### chunk-size
+Controls how many lines of diff are processed in each chunk when chunking is enabled:
+
+```bash
+# Set a larger chunk size (default is 200)
+ngpt --cli-config set chunk-size 300
+```
+
+Larger chunk sizes can provide more context but may hit token limits with some models. Smaller chunk sizes are better for very large commits but may lose some context between chunks.
+
+#### max-depth
+Sets the maximum recursion depth for recursive chunking:
+
+```bash
+# Increase max recursion depth (default is 3)
+ngpt --cli-config set max-depth 5
+```
+
+Higher values allow processing of extremely large diffs but may take longer.
+
 ### Context-Aware Application
 
 Each option configured via `--cli-config` is only applied if it's relevant to the current execution mode and if it wasn't already specified as a command-line argument.
@@ -140,6 +212,15 @@ ngpt --cli-config set prettify true
 
 # Set default provider to use
 ngpt --cli-config set provider Gemini
+
+# Enable recursive chunking for git commit messages by default
+ngpt --cli-config set recursive-chunk true
+
+# Set a default diff file path for git commit messages
+ngpt --cli-config set diff /path/to/changes.diff
+
+# Set a larger chunk size for git commit message processing
+ngpt --cli-config set chunk-size 300
 ```
 
 ### Using CLI Configuration

ngpt-2.14.1/docs/usage/gitcommsg.md

@@ -0,0 +1,255 @@
+# Git Commit Message Generation
+
+The `--gitcommsg` mode in NGPT helps you generate high-quality, conventional commit messages using AI to analyze your git diffs.
+
+## Basic Usage
+
+```bash
+# Generate commit message from staged changes
+ngpt --gitcommsg
+
+# Generate commit message with context/directives
+ngpt --gitcommsg -m "type:feat"
+
+# Process large diffs in chunks with recursive analysis
+ngpt --gitcommsg -r
+
+# Use a diff file instead of staged changes
+ngpt --gitcommsg --diff /path/to/changes.diff
+
+# Enable logging for debugging
+ngpt --gitcommsg --log
+```
+
+## Command Line Options
+
+| Option | Description |
+|--------|-------------|
+| `-m, --message-context` | Context to guide AI (file types, commit type directive, focus) |
+| `-r, --recursive-chunk` | Process large diffs in chunks with recursive analysis if needed |
+| `--diff FILE` | Use diff from specified file instead of staged changes |
+| `--log [FILE]` | Enable detailed logging (to specified file or auto-generated temp file) |
+| `--chunk-size NUM` | Set number of lines per chunk (default: 200) |
+| `--max-depth NUM` | Maximum recursion depth for recursive chunking (default: 3) |
+
+## Context Directives
+
+The `-m/--message-context` option is powerful and supports several directive types:
+
+### Commit Type Directive
+
+Force a specific commit type prefix:
+
+```bash
+# Force "feat:" prefix
+ngpt --gitcommsg -m "type:feat"
+
+# Force "fix:" prefix 
+ngpt --gitcommsg -m "type:fix"
+
+# Force "docs:" prefix
+ngpt --gitcommsg -m "type:docs"
+```
+
+### File Type Filtering
+
+Focus only on specific file types:
+
+```bash
+# Focus only on JavaScript changes
+ngpt --gitcommsg -m "javascript"
+
+# Focus only on CSS files 
+ngpt --gitcommsg -m "css"
+
+# Focus only on Python files
+ngpt --gitcommsg -m "python"
+```
+
+### Focus/Exclusion Directives
+
+Control what to include or exclude:
+
+```bash
+# Focus only on authentication-related changes
+ngpt --gitcommsg -m "focus on auth"
+
+# Ignore formatting changes
+ngpt --gitcommsg -m "ignore formatting"
+
+# Exclude test files from the summary
+ngpt --gitcommsg -m "exclude tests"
+```
+
+### Combined Directives
+
+You can combine multiple directives:
+
+```bash
+# Force "feat:" prefix and focus only on UI changes
+ngpt --gitcommsg -m "type:feat focus on UI"
+
+# Force "fix:" prefix and ignore formatting changes
+ngpt --gitcommsg -m "type:fix ignore formatting"
+```
+
+## Chunking Mechanism
+
+When processing large diffs with `-r/--recursive-chunk`, the chunking mechanism helps manage rate limits and token limits:
+
+1. Diffs are split into 200-line chunks and processed separately
+2. The partial analyses are then combined into a final commit message
+3. If the combined analysis is still too large, it's recursively processed again
+
+This is particularly useful for large pull requests or commits with many changes.
+
+## CLI Configuration
+
+You can set default values for gitcommsg options using the CLI configuration system:
+
+```bash
+# Set default chunk size
+ngpt --cli-config set chunk-size 150
+
+# Enable recursive chunking by default
+ngpt --cli-config set recursive-chunk true
+
+# Set a default diff file path (used with --diff flag)
+ngpt --cli-config set diff /path/to/your/changes.diff
+
+# Set maximum recursion depth
+ngpt --cli-config set max-depth 5
+
+# Set a context directive to always apply
+ngpt --cli-config set message-context "type:feat"
+```
+
+### Available CLI Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `recursive-chunk` | bool | false | Process large diffs in chunks with recursive analysis |
+| `diff` | string | null | Path to diff file to use instead of staged changes |
+| `chunk-size` | int | 200 | Number of lines per chunk when chunking is enabled |
+| `max-depth` | int | 3 | Maximum recursion depth for recursive chunking |
+| `message-context` | string | null | Context to guide AI generation |
+
+### Option Details
+
+#### recursive-chunk
+
+When enabled, this option automatically processes large diffs in chunks and then combines the results:
+
+```bash
+# Enable recursive chunking by default
+ngpt --cli-config set recursive-chunk true
+```
+
+This is particularly useful for large commits or codebases, as it helps:
+- Avoid token limits with large diffs
+- Handle rate limiting better by breaking requests into smaller pieces
+- Process very large changes that would otherwise fail
+
+#### chunk-size
+
+Controls how many lines of diff are processed in each chunk:
+
+```bash
+# Set a custom chunk size (smaller chunks for very large diffs)
+ngpt --cli-config set chunk-size 150
+
+# Or larger chunks for more context
+ngpt --cli-config set chunk-size 300
+```
+
+Smaller chunks (100-150 lines) work better for very large diffs or models with stricter token limits, while larger chunks (300-500 lines) provide more context but may hit token limits.
+
+#### max-depth
+
+Sets how many recursive analysis levels are allowed when using recursive chunking:
+
+```bash
+# Increase max recursion depth for extremely large diffs
+ngpt --cli-config set max-depth 5
+```
+
+Higher values allow processing larger diffs but may increase processing time.
+
+#### message-context
+
+Provides contextual guidance for the AI when generating commit messages:
+
+```bash
+# Always focus on a specific aspect
+ngpt --cli-config set message-context "focus on API changes"
+
+# Always use a specific commit type
+ngpt --cli-config set message-context "type:feat"
+
+# Combined directives
+ngpt --cli-config set message-context "type:fix exclude tests"
+```
+
+This is useful when you consistently work on the same type of changes and want to standardize your commit messages.
+
+### Using the Diff File Option
+
+When you've set a default diff file using the CLI config:
+
+```bash
+# Set a default diff file
+ngpt --cli-config set diff /path/to/changes.diff
+```
+
+The diff file from CLI config is only used when you specifically request it with the `--diff` flag without providing a path. You have three ways to control which diff is used:
+
+1. **Use git staged changes** (ignore the CLI config diff):
+   ```bash
+   ngpt --gitcommsg
+   ```
+   This will always use git staged changes regardless of your CLI config.
+
+2. **Use the CLI config diff file**:
+   ```bash
+   ngpt --gitcommsg --diff
+   ```
+   This explicitly tells ngpt to use the diff file specified in your CLI config.
+
+3. **Use a specific diff file** (override CLI config):
+   ```bash
+   ngpt --gitcommsg --diff /path/to/another.diff
+   ```
+   This overrides both git staged changes and your CLI config to use the specified file.
+
+This approach gives you flexibility with a default diff file while maintaining explicit control over when it's used.
+
+## Example Output
+
+```
+feat(auth): Add OAuth2 authentication flow
+
+- [feat] Implement OAuth2 provider in auth/oauth.py:get_oauth_client()
+- [feat] Add token validation in auth/utils.py:validate_token()
+- [test] Add integration tests for OAuth flow in tests/auth/test_oauth.py
+- [docs] Update authentication docs in README.md
+```
+
+The generated commit messages follow the conventional commit format with:
+1. Type prefix (feat, fix, docs, etc.)
+2. Optional scope in parentheses
+3. Brief summary
+4. Detailed bullet points with file and function references
+
+## Requirements
+
+- Git must be installed and available in your PATH
+- You must be in a git repository
+- For commit message generation, you need staged changes (`git add`)
+
+## Error Handling
+
+The command includes robust error handling:
+- Checks if in a git repository
+- Verifies staged changes exist
+- Includes automatic retries with exponential backoff for API failures
+- Provides detailed logs when `--log` is enabled 

{ngpt-2.13.0 → ngpt-2.14.1}/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-2.13.0 → ngpt-2.14.1}/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-2.13.0 → ngpt-2.14.1}/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']