devcommit 0.1.4.7__tar.gz → 0.1.4.9__tar.gz

{devcommit-0.1.4.7 → devcommit-0.1.4.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devcommit
-Version: 0.1.4.7
+Version: 0.1.4.9
 Summary: AI-powered git commit message generator
 License: GNU GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
@@ -713,6 +713,9 @@ A command-line AI tool for autocommits.
 - 🚀 Automatic commit generation using AI
 - 📁 Directory-based commits - create separate commits for each root directory
 - 🎯 Interactive mode to choose between global or directory-based commits
+- 📄 **Commit specific files or folders** - Stage and commit only selected files/directories
+- 🔄 **Regenerate commit messages** - Don't like the suggestions? Regenerate with one click
+- 🚀 **Push to remote** - Automatically push commits after committing
 - ⚙️ Flexible configuration - use environment variables or .dcommit file
 - 🏠 Self-hosted model support - use your own AI infrastructure
 - 🆓 Multiple free tier options available
@@ -865,6 +868,9 @@ devcommit --stageAll --files file1.py file2.py
 git add src/ tests/
 devcommit --files src/ tests/
 
+# Stage and commit multiple directories
+devcommit -s -f src/core src/modules/account/ src/modules/auth/
+
 # Short form
 devcommit -s -f file1.py file2.py
 ```
@@ -875,6 +881,66 @@ When using `--files` or `-f`:
 - With `--stageAll`: Stages the specified files/folders and then commits them
 - AI generates commit messages based on changes in those files
 - Works with both individual files and entire directories
+- Files with no changes are automatically filtered out
+
+#### Commit Mode Behavior with `--files`
+
+The `--files` flag respects your `COMMIT_MODE` setting:
+
+- **`COMMIT_MODE=directory`** with `--files`:
+  - **Individual files**: Each file gets its own separate commit
+    - Example: `devcommit -f src/test1.py src/test2.py` creates 2 separate commits
+  - **Directories**: Each directory gets one commit containing all its files
+    - Example: `devcommit -f src/core src/modules/account/` creates 2 commits (one per directory)
+
+- **`COMMIT_MODE=global`** with `--files`:
+  - All specified files/directories are committed together in a single commit
+  - Example: `devcommit -f src/test1.py src/test2.py` creates 1 commit for both files
+
+- **`COMMIT_MODE=auto`** with `--files`:
+  - Always prompts you to choose between one commit for all files or separate commits
+  - If you select directory mode: individual files get separate commits, directories get one commit each
+  - If you select global mode: everything is committed together
+
+### Push to Remote
+
+DevCommit can automatically push your commits to the remote repository after committing.
+
+**Usage:**
+
+```bash
+# Commit all staged changes and push
+devcommit --push
+
+# Commit specific files and push
+devcommit --files file1.py file2.py --push
+
+# Stage, commit, and push in one command
+devcommit --stageAll --push
+
+# Short form
+devcommit -p
+devcommit -f file1.py -p
+```
+
+**Note:** The push operation will only execute if commits were successfully made. If you cancel the commit, the push will be skipped.
+
+### Regenerate Commit Messages
+
+Don't like the AI-generated commit messages? You can regenerate them on the fly!
+
+When viewing commit message options, you'll see:
+- Numbered commit message suggestions
+- ✏️ Enter custom message
+- 🔄 **Regenerate commit messages** (new!)
+- ❌ Cancel
+
+Selecting "Regenerate commit messages" will:
+- Call the AI again to generate new suggestions
+- Show the new messages in the same prompt
+- Allow you to regenerate again or select a message
+
+This works for all commit modes (global, directory, and per-file commits).
 
 ### Additional Options
 
@@ -912,6 +978,12 @@ devcommit --push
 
 # Commit specific files and push
 devcommit --files file1.py file2.py --push
+
+# Stage and commit multiple directories with directory mode
+devcommit -s -f src/core src/modules/account/ --directory
+
+# Stage and commit, then push
+devcommit -s -f src/core src/modules/account/ -p
 ```
 
 ## AI Provider Support

{devcommit-0.1.4.7 → devcommit-0.1.4.9}/README.md

@@ -8,6 +8,9 @@ A command-line AI tool for autocommits.
 - 🚀 Automatic commit generation using AI
 - 📁 Directory-based commits - create separate commits for each root directory
 - 🎯 Interactive mode to choose between global or directory-based commits
+- 📄 **Commit specific files or folders** - Stage and commit only selected files/directories
+- 🔄 **Regenerate commit messages** - Don't like the suggestions? Regenerate with one click
+- 🚀 **Push to remote** - Automatically push commits after committing
 - ⚙️ Flexible configuration - use environment variables or .dcommit file
 - 🏠 Self-hosted model support - use your own AI infrastructure
 - 🆓 Multiple free tier options available
@@ -160,6 +163,9 @@ devcommit --stageAll --files file1.py file2.py
 git add src/ tests/
 devcommit --files src/ tests/
 
+# Stage and commit multiple directories
+devcommit -s -f src/core src/modules/account/ src/modules/auth/
+
 # Short form
 devcommit -s -f file1.py file2.py
 ```
@@ -170,6 +176,66 @@ When using `--files` or `-f`:
 - With `--stageAll`: Stages the specified files/folders and then commits them
 - AI generates commit messages based on changes in those files
 - Works with both individual files and entire directories
+- Files with no changes are automatically filtered out
+
+#### Commit Mode Behavior with `--files`
+
+The `--files` flag respects your `COMMIT_MODE` setting:
+
+- **`COMMIT_MODE=directory`** with `--files`:
+  - **Individual files**: Each file gets its own separate commit
+    - Example: `devcommit -f src/test1.py src/test2.py` creates 2 separate commits
+  - **Directories**: Each directory gets one commit containing all its files
+    - Example: `devcommit -f src/core src/modules/account/` creates 2 commits (one per directory)
+
+- **`COMMIT_MODE=global`** with `--files`:
+  - All specified files/directories are committed together in a single commit
+  - Example: `devcommit -f src/test1.py src/test2.py` creates 1 commit for both files
+
+- **`COMMIT_MODE=auto`** with `--files`:
+  - Always prompts you to choose between one commit for all files or separate commits
+  - If you select directory mode: individual files get separate commits, directories get one commit each
+  - If you select global mode: everything is committed together
+
+### Push to Remote
+
+DevCommit can automatically push your commits to the remote repository after committing.
+
+**Usage:**
+
+```bash
+# Commit all staged changes and push
+devcommit --push
+
+# Commit specific files and push
+devcommit --files file1.py file2.py --push
+
+# Stage, commit, and push in one command
+devcommit --stageAll --push
+
+# Short form
+devcommit -p
+devcommit -f file1.py -p
+```
+
+**Note:** The push operation will only execute if commits were successfully made. If you cancel the commit, the push will be skipped.
+
+### Regenerate Commit Messages
+
+Don't like the AI-generated commit messages? You can regenerate them on the fly!
+
+When viewing commit message options, you'll see:
+- Numbered commit message suggestions
+- ✏️ Enter custom message
+- 🔄 **Regenerate commit messages** (new!)
+- ❌ Cancel
+
+Selecting "Regenerate commit messages" will:
+- Call the AI again to generate new suggestions
+- Show the new messages in the same prompt
+- Allow you to regenerate again or select a message
+
+This works for all commit modes (global, directory, and per-file commits).
 
 ### Additional Options
 
@@ -207,6 +273,12 @@ devcommit --push
 
 # Commit specific files and push
 devcommit --files file1.py file2.py --push
+
+# Stage and commit multiple directories with directory mode
+devcommit -s -f src/core src/modules/account/ --directory
+
+# Stage and commit, then push
+devcommit -s -f src/core src/modules/account/ -p
 ```
 
 ## AI Provider Support

{devcommit-0.1.4.7 → devcommit-0.1.4.9}/devcommit/main.py

@@ -71,7 +71,9 @@ def main(flags: CommitFlag = None):
 
         # Handle staging
         push_files_list = []
+        original_paths = []  # Keep track of original paths (files or directories) passed
         if flags["files"] and len(flags["files"]) > 0:
+            original_paths = flags["files"]
             
             # Get the list of files from paths first
             try:
@@ -82,7 +84,7 @@ def main(flags: CommitFlag = None):
                 raise e
             except Exception as e:
                 raise KnownError(f"Failed to get files from paths: {str(e)}")
-        
+
         if flags["stageAll"]:
             if push_files_list:
                 # Stage specific files/folders only
@@ -158,6 +160,9 @@ def main(flags: CommitFlag = None):
         # Priority: CLI flag > config (file or env) > interactive prompt
         use_per_directory = flags.get("directory", False)
         
+        # Special handling when --files is used: check if we should use per-file commits
+        is_files_mode = push_files_list and len(push_files_list) > 0
+        
         # If not explicitly set via CLI, check config (file or environment variable)
         if not use_per_directory:
             commit_mode = config("COMMIT_MODE", default="auto").lower()
@@ -167,18 +172,58 @@ def main(flags: CommitFlag = None):
                 use_per_directory = False
             # If "auto" or not set, fall through to interactive prompt
         
-        # If still not set, check if there are multiple directories and prompt
+        # If still not set (auto mode), check if there are multiple directories and prompt
         if not use_per_directory and config("COMMIT_MODE", default="auto").lower() == "auto":
-            grouped = group_files_by_directory(staged["files"])
-            if len(grouped) > 1:
-                use_per_directory = prompt_commit_strategy(console, grouped)
+            if is_files_mode:
+                # When --files is used with auto mode, always prompt
+                # Group files to show directory structure, but prompt for per-file vs global
+                grouped = group_files_by_directory(staged["files"])
+                console.print()
+                console.print("╭" + "─" * 60 + "╮", style="bold yellow")
+                console.print("│" + "  📂 [bold white]Files from multiple locations detected[/bold white]".ljust(70) + "│", style="bold yellow")
+                console.print("╰" + "─" * 60 + "╯", style="bold yellow")
+                console.print()
+                console.print(f"  [dim]Found {len(staged['files'])} file(s) to commit[/dim]")
+                console.print()
+                # Prompt for per-file vs global commit
+                use_per_directory = prompt_commit_strategy(console, grouped, is_files_mode=True)
+            else:
+                # Regular auto mode: check directories
+                grouped = group_files_by_directory(staged["files"])
+                if len(grouped) > 1:
+                    use_per_directory = prompt_commit_strategy(console, grouped, is_files_mode=False)
+            # If only one directory and not files mode, use global commit (single commit for all files)
         
         # Track if any commits were made
         commit_made = False
         if use_per_directory:
-            commit_made = process_per_directory_commits(console, staged, flags)
+            # When --files is used with directory mode
+            if is_files_mode:
+                # Check if original paths were directories or individual files
+                # If directories were passed, group by those directories
+                # If individual files were passed, treat each file separately
+                has_directories = False
+                if original_paths:
+                    repo_root = assert_git_repo()
+                    for path in original_paths:
+                        normalized_path = os.path.normpath(path)
+                        full_path = os.path.join(repo_root, normalized_path) if not os.path.isabs(path) else path
+                        if os.path.isdir(full_path):
+                            has_directories = True
+                            break
+                
+                if has_directories:
+                    # Group files by the original directories passed
+                    commit_made = process_per_directory_commits_from_paths(console, staged, flags, original_paths)
+                else:
+                    # Individual files passed, treat each file separately
+                    commit_made = process_per_file_commits(console, staged, flags)
+            else:
+                commit_made = process_per_directory_commits(console, staged, flags)
         else:
-            commit_made = process_global_commit(console, flags)
+            # Pass staged dict so process_global_commit knows which files to commit
+            # (important when --files is used)
+            commit_made = process_global_commit(console, flags, staged=staged)
         
         # Handle push if requested and a commit was actually made
         if flags.get("push", False) and commit_made:
@@ -216,7 +261,7 @@ def stage_changes(console):
         spinner="dots",
         spinner_style="cyan"
     ):
-        subprocess.run(["git", "add", "--update"], check=True)
+        subprocess.run(["git", "add", "--all"], check=True)
 
 
 def detect_staged_files(console, exclude_files):
@@ -241,7 +286,13 @@ def detect_staged_files(console, exclude_files):
         return staged
 
 
-def analyze_changes(console):
+def analyze_changes(console, files=None):
+    """Analyze changes for commit message generation.
+    
+    Args:
+        console: Rich console for output
+        files: Optional list of specific files to analyze. If None, analyzes all staged files.
+    """
     import sys
     
     with console.status(
@@ -249,11 +300,16 @@ def analyze_changes(console):
         spinner="dots",
         spinner_style="magenta"
     ):
-        diff = subprocess.run(
-            ["git", "diff", "--staged"],
-            stdout=subprocess.PIPE,
-            text=True,
-        ).stdout
+        if files:
+            # Analyze only specific files
+            diff = get_diff_for_files(files)
+        else:
+            # Analyze all staged files
+            diff = subprocess.run(
+                ["git", "diff", "--staged"],
+                stdout=subprocess.PIPE,
+                text=True,
+            ).stdout
 
         if not diff:
             raise KnownError(
@@ -280,7 +336,18 @@ def analyze_changes(console):
         return commit_message
 
 
-def prompt_commit_message(console, commit_message):
+def prompt_commit_message(console, commit_message, regenerate_callback=None):
+    """Prompt user to select a commit message.
+    
+    Args:
+        console: Rich console for output
+        commit_message: List of generated commit messages
+        regenerate_callback: Optional function to call when regenerate is selected.
+                            Should return a new list of commit messages.
+    
+    Returns:
+        Selected commit message string, "regenerate" to regenerate, or None if cancelled
+    """
     tag = (
         "Select commit message"
         if len(commit_message) > 1
@@ -310,9 +377,14 @@ def prompt_commit_message(console, commit_message):
     choices = [
         *numbered_choices,
         {"name": "  ✏️  Enter custom message", "value": "custom"},
-        {"name": "  ❌ Cancel", "value": "cancel"}
     ]
     
+    # Add regenerate option if callback is provided
+    if regenerate_callback:
+        choices.append({"name": "  🔄 Regenerate commit messages", "value": "regenerate"})
+    
+    choices.append({"name": "  ❌ Cancel", "value": "cancel"})
+    
     action = inquirer.fuzzy(
         message=tag,
         style=style,
@@ -328,6 +400,8 @@ def prompt_commit_message(console, commit_message):
         return None
     elif action == "custom":
         return prompt_custom_message(console)
+    elif action == "regenerate":
+        return "regenerate"
     return action
 
 
@@ -360,8 +434,21 @@ def prompt_custom_message(console):
     return custom_message
 
 
-def commit_changes(console, commit, raw_argv):
-    subprocess.run(["git", "commit", "-m", commit, *raw_argv])
+def commit_changes(console, commit, raw_argv, files=None):
+    """Commit changes.
+    
+    Args:
+        console: Rich console for output
+        commit: Commit message
+        raw_argv: Additional git commit arguments
+        files: Optional list of specific files to commit. If None, commits all staged files.
+    """
+    if files:
+        # Commit only specific files
+        subprocess.run(["git", "commit", "-m", commit, *raw_argv, "--"] + files)
+    else:
+        # Commit all staged files
+        subprocess.run(["git", "commit", "-m", commit, *raw_argv])
     console.print("\n[bold green]✅ Committed successfully![/bold green]")
 
 
@@ -402,8 +489,14 @@ def push_changes(console):
         raise KnownError(f"Push failed: {str(e)}")
 
 
-def prompt_commit_strategy(console, grouped):
-    """Prompt user to choose between global or directory-based commits."""
+def prompt_commit_strategy(console, grouped, is_files_mode=False):
+    """Prompt user to choose between global or directory-based commits.
+    
+    Args:
+        console: Rich console for output
+        grouped: Dictionary of directories and their files
+        is_files_mode: If True, directory mode means per-file commits (when --files is used)
+    """
     console.print()
     console.print("╭" + "─" * 60 + "╮", style="bold yellow")
     console.print("│" + "  📂 [bold white]Multiple directories detected[/bold white]".ljust(70) + "│", style="bold yellow")
@@ -422,13 +515,23 @@ def prompt_commit_strategy(console, grouped):
         "answer": "#00d7ff bold"
     }, style_override=False)
     
+    if is_files_mode:
+        # When --files is used, directory mode means per-file commits
+        choices = [
+            {"name": "  🌐 One commit for all files", "value": False},
+            {"name": "  📄 Separate commit for each file", "value": True},
+        ]
+    else:
+        # Normal mode: directory mode means per-directory commits
+        choices = [
+            {"name": "  🌐 One commit for all changes", "value": False},
+            {"name": "  📁 Separate commits per directory", "value": True},
+        ]
+    
     strategy = inquirer.select(
         message="Commit strategy",
         style=style,
-        choices=[
-            {"name": "  🌐 One commit for all changes", "value": False},
-            {"name": "  📁 Separate commits per directory", "value": True},
-        ],
+        choices=choices,
         default=None,
         instruction="(Use arrow keys)",
         qmark="❯"
@@ -437,15 +540,36 @@ def prompt_commit_strategy(console, grouped):
     return strategy
 
 
-def process_global_commit(console, flags):
+def process_global_commit(console, flags, staged=None):
     """Process a single global commit for all changes.
+    
+    Args:
+        console: Rich console for output
+        flags: Commit flags
+        staged: Optional staged dict with files. If provided, only commits those files.
+    
     Returns True if a commit was made, False otherwise."""
-    commit_message = analyze_changes(console)
-    selected_commit = prompt_commit_message(console, commit_message)
-    if selected_commit:
-        commit_changes(console, selected_commit, flags["rawArgv"])
-        return True
-    return False
+    # If staged dict is provided (e.g., from --files), use only those files
+    files_to_commit = staged["files"] if staged and staged.get("files") else None
+    
+    # Regenerate loop
+    while True:
+        commit_message = analyze_changes(console, files=files_to_commit)
+        
+        # Create regenerate callback
+        def regenerate():
+            return analyze_changes(console, files=files_to_commit)
+        
+        selected_commit = prompt_commit_message(console, commit_message, regenerate_callback=regenerate)
+        
+        if selected_commit == "regenerate":
+            # User wants to regenerate, loop again
+            continue
+        elif selected_commit:
+            commit_changes(console, selected_commit, flags["rawArgv"], files=files_to_commit)
+            return True
+        else:
+            return False
 
 
 def process_per_directory_commits(console, staged, flags):
@@ -546,16 +670,336 @@ def process_per_directory_commits(console, staged, flags):
                 console.print(f"\n[bold yellow]⚠️  No commit message generated for {directory}, skipping[/bold yellow]\n")
                 continue
         
-        # Prompt for commit message selection
-        selected_commit = prompt_commit_message(console, commit_message)
+        # Prompt for commit message selection with regenerate option
+        while True:
+            def regenerate():
+                diff = get_diff_for_files(files, flags["excludeFiles"])
+                if not diff:
+                    return []
+                import sys
+                _stderr = sys.stderr
+                _devnull = open(os.devnull, 'w')
+                sys.stderr = _devnull
+                try:
+                    msg = generateCommitMessage(diff)
+                    if isinstance(msg, str):
+                        msg = msg.split("|")
+                    return msg
+                finally:
+                    sys.stderr = _stderr
+                    _devnull.close()
+            
+            selected_commit = prompt_commit_message(console, commit_message, regenerate_callback=regenerate)
+            
+            if selected_commit == "regenerate":
+                # Regenerate commit messages
+                with console.status(
+                    f"[magenta]🤖 Regenerating commit messages for {directory}...[/magenta]",
+                    spinner="dots",
+                    spinner_style="magenta"
+                ):
+                    commit_message = regenerate()
+                    if not commit_message:
+                        console.print(f"\n[bold yellow]⚠️  No commit message generated for {directory}, skipping[/bold yellow]\n")
+                        break
+                continue
+            elif selected_commit:
+                # Commit only the files in this directory
+                subprocess.run(["git", "commit", "-m", selected_commit, *flags["rawArgv"], "--"] + files)
+                console.print(f"\n[bold green]✅ Committed {directory}[/bold green]")
+                commits_made = True
+                break
+            else:
+                console.print(f"\n[bold yellow]⊘ Skipped {directory}[/bold yellow]")
+                break
+    
+    return commits_made
+
+
+def process_per_file_commits(console, staged, flags):
+    """Process separate commits for each file when --files is used with directory mode.
+    Returns True if at least one commit was made, False otherwise."""
+    files = staged["files"]
+    commits_made = False
+    
+    # Filter out files with no diff before processing
+    files_with_changes = []
+    for file in files:
+        diff = get_diff_for_files([file], flags["excludeFiles"])
+        if diff:
+            files_with_changes.append(file)
+    
+    if not files_with_changes:
+        console.print("\n[bold yellow]⚠️  No files with changes to commit[/bold yellow]\n")
+        return False
+    
+    # If some files were filtered out, show a message
+    if len(files_with_changes) < len(files):
+        skipped_count = len(files) - len(files_with_changes)
+        console.print(f"\n[dim]Skipping {skipped_count} file(s) with no changes[/dim]\n")
+    
+    console.print()
+    console.print("╭" + "─" * 60 + "╮", style="bold magenta")
+    console.print("│" + f"  🔮 [bold white]Processing {len(files_with_changes)} file(s)[/bold white]".ljust(71) + "│", style="bold magenta")
+    console.print("╰" + "─" * 60 + "╯", style="bold magenta")
+    console.print()
+    
+    # Ask if user wants to commit all or select specific files
+    style = get_style({
+        "question": "#00d7ff bold",
+        "questionmark": "#00d7ff bold",
+        "pointer": "#00d7ff bold",
+        "instruction": "#7f7f7f",
+        "answer": "#00d7ff bold",
+        "checkbox": "#00d7ff bold"
+    }, style_override=False)
+    
+    if len(files_with_changes) > 1:
+        commit_all = inquirer.confirm(
+            message="Commit all files?",
+            style=style,
+            default=True,
+            instruction="(y/n)",
+            qmark="❯"
+        ).execute()
         
-        if selected_commit:
-            # Commit only the files in this directory
-            subprocess.run(["git", "commit", "-m", selected_commit, *flags["rawArgv"], "--"] + files)
-            console.print(f"\n[bold green]✅ Committed {directory}[/bold green]")
-            commits_made = True
+        if commit_all:
+            selected_files = files_with_changes
         else:
-            console.print(f"\n[bold yellow]⊘ Skipped {directory}[/bold yellow]")
+            # Let user select which files to commit
+            file_choices = [
+                {"name": file, "value": file}
+                for file in files_with_changes
+            ]
+            
+            selected_files = inquirer.checkbox(
+                message="Select files to commit",
+                style=style,
+                choices=file_choices,
+                default=files_with_changes,
+                instruction="(Space to select, Enter to confirm)",
+                qmark="❯"
+            ).execute()
+    else:
+        selected_files = files_with_changes
+    
+    if not selected_files:
+        console.print("\n[bold yellow]⚠️  No files selected[/bold yellow]\n")
+        return False
+    
+    # Process each selected file (all should have changes since we filtered)
+    for idx, file in enumerate(selected_files, 1):
+        console.print()
+        console.print("┌" + "─" * 60 + "┐", style="bold cyan")
+        console.print("│" + f"  📄 [{idx}/{len(selected_files)}] [bold white]{file}[/bold white]".ljust(69) + "│", style="bold cyan")
+        console.print("└" + "─" * 60 + "┘", style="bold cyan")
+        console.print()
+        
+        # Get diff for this file (should already have changes, but double-check)
+        with console.status(
+            f"[magenta]🤖 Analyzing {file}...[/magenta]",
+            spinner="dots",
+            spinner_style="magenta"
+        ):
+            diff = get_diff_for_files([file], flags["excludeFiles"])
+            
+            if not diff:
+                console.print(f"\n[bold yellow]⚠️  No diff for {file}, skipping[/bold yellow]\n")
+                continue
+            
+            # Suppress stderr during AI call to hide ALTS warnings
+            import sys
+            _stderr = sys.stderr
+            _devnull = open(os.devnull, 'w')
+            sys.stderr = _devnull
+            
+            try:
+                commit_message = generateCommitMessage(diff)
+            finally:
+                sys.stderr = _stderr
+                _devnull.close()
+            
+            if isinstance(commit_message, str):
+                commit_message = commit_message.split("|")
+            
+            if not commit_message:
+                console.print(f"\n[bold yellow]⚠️  No commit message generated for {file}, skipping[/bold yellow]\n")
+                continue
+        
+        # Prompt for commit message selection with regenerate option
+        while True:
+            def regenerate():
+                diff = get_diff_for_files([file], flags["excludeFiles"])
+                if not diff:
+                    return []
+                import sys
+                _stderr = sys.stderr
+                _devnull = open(os.devnull, 'w')
+                sys.stderr = _devnull
+                try:
+                    msg = generateCommitMessage(diff)
+                    if isinstance(msg, str):
+                        msg = msg.split("|")
+                    return msg
+                finally:
+                    sys.stderr = _stderr
+                    _devnull.close()
+            
+            selected_commit = prompt_commit_message(console, commit_message, regenerate_callback=regenerate)
+            
+            if selected_commit == "regenerate":
+                # Regenerate commit messages
+                with console.status(
+                    f"[magenta]🤖 Regenerating commit messages for {file}...[/magenta]",
+                    spinner="dots",
+                    spinner_style="magenta"
+                ):
+                    commit_message = regenerate()
+                    if not commit_message:
+                        console.print(f"\n[bold yellow]⚠️  No commit message generated for {file}, skipping[/bold yellow]\n")
+                        break
+                continue
+            elif selected_commit:
+                # Commit only this file
+                subprocess.run(["git", "commit", "-m", selected_commit, *flags["rawArgv"], "--", file])
+                console.print(f"\n[bold green]✅ Committed {file}[/bold green]")
+                commits_made = True
+                break
+            else:
+                console.print(f"\n[bold yellow]⊘ Skipped {file}[/bold yellow]")
+                break
+    
+    return commits_made
+
+
+def process_per_directory_commits_from_paths(console, staged, flags, original_paths):
+    """Process separate commits for each directory/path when --files is used with directory mode.
+    Groups files by the original paths passed (directories or files).
+    Returns True if at least one commit was made, False otherwise."""
+    repo_root = assert_git_repo()
+    commits_made = False
+    
+    # Group files by the original paths they came from
+    path_to_files = {}
+    for path in original_paths:
+        normalized_path = os.path.normpath(path)
+        full_path = os.path.join(repo_root, normalized_path) if not os.path.isabs(path) else path
+        
+        if os.path.isdir(full_path):
+            # It's a directory - find all files that belong to this directory
+            dir_files = [f for f in staged["files"] if f.startswith(normalized_path + os.sep) or f == normalized_path]
+            if dir_files:
+                path_to_files[normalized_path] = dir_files
+        else:
+            # It's a file - add it directly
+            if normalized_path in staged["files"]:
+                path_to_files[normalized_path] = [normalized_path]
+    
+    if not path_to_files:
+        console.print("\n[bold yellow]⚠️  No files found for the specified paths[/bold yellow]\n")
+        return False
+    
+    # Filter out paths with no changes
+    paths_with_changes = {}
+    for path, files in path_to_files.items():
+        diff = get_diff_for_files(files, flags["excludeFiles"])
+        if diff:
+            paths_with_changes[path] = files
+    
+    if not paths_with_changes:
+        console.print("\n[bold yellow]⚠️  No paths with changes to commit[/bold yellow]\n")
+        return False
+    
+    console.print()
+    console.print("╭" + "─" * 60 + "╮", style="bold magenta")
+    console.print("│" + f"  🔮 [bold white]Processing {len(paths_with_changes)} path(s)[/bold white]".ljust(71) + "│", style="bold magenta")
+    console.print("╰" + "─" * 60 + "╯", style="bold magenta")
+    console.print()
+    
+    # Process each path
+    for idx, (path, files) in enumerate(paths_with_changes.items(), 1):
+        console.print()
+        console.print("┌" + "─" * 60 + "┐", style="bold cyan")
+        console.print("│" + f"  📂 [{idx}/{len(paths_with_changes)}] [bold white]{path}[/bold white]".ljust(69) + "│", style="bold cyan")
+        console.print("└" + "─" * 60 + "┘", style="bold cyan")
+        console.print()
+        
+        for file in files:
+            console.print(f"  [cyan]▸[/cyan] [white]{file}[/white]")
+        
+        # Get diff for this path's files
+        with console.status(
+            f"[magenta]🤖 Analyzing {path}...[/magenta]",
+            spinner="dots",
+            spinner_style="magenta"
+        ):
+            diff = get_diff_for_files(files, flags["excludeFiles"])
+            
+            if not diff:
+                console.print(f"\n[bold yellow]⚠️  No diff for {path}, skipping[/bold yellow]\n")
+                continue
+            
+            # Suppress stderr during AI call to hide ALTS warnings
+            import sys
+            _stderr = sys.stderr
+            _devnull = open(os.devnull, 'w')
+            sys.stderr = _devnull
+            
+            try:
+                commit_message = generateCommitMessage(diff)
+            finally:
+                sys.stderr = _stderr
+                _devnull.close()
+            
+            if isinstance(commit_message, str):
+                commit_message = commit_message.split("|")
+            
+            if not commit_message:
+                console.print(f"\n[bold yellow]⚠️  No commit message generated for {path}, skipping[/bold yellow]\n")
+                continue
+        
+        # Prompt for commit message selection with regenerate option
+        while True:
+            def regenerate():
+                diff = get_diff_for_files(files, flags["excludeFiles"])
+                if not diff:
+                    return []
+                import sys
+                _stderr = sys.stderr
+                _devnull = open(os.devnull, 'w')
+                sys.stderr = _devnull
+                try:
+                    msg = generateCommitMessage(diff)
+                    if isinstance(msg, str):
+                        msg = msg.split("|")
+                    return msg
+                finally:
+                    sys.stderr = _stderr
+                    _devnull.close()
+            
+            selected_commit = prompt_commit_message(console, commit_message, regenerate_callback=regenerate)
+            
+            if selected_commit == "regenerate":
+                # Regenerate commit messages
+                with console.status(
+                    f"[magenta]🤖 Regenerating commit messages for {path}...[/magenta]",
+                    spinner="dots",
+                    spinner_style="magenta"
+                ):
+                    commit_message = regenerate()
+                    if not commit_message:
+                        console.print(f"\n[bold yellow]⚠️  No commit message generated for {path}, skipping[/bold yellow]\n")
+                        break
+                continue
+            elif selected_commit:
+                # Commit only the files for this path
+                subprocess.run(["git", "commit", "-m", selected_commit, *flags["rawArgv"], "--"] + files)
+                console.print(f"\n[bold green]✅ Committed {path}[/bold green]")
+                commits_made = True
+                break
+            else:
+                console.print(f"\n[bold yellow]⊘ Skipped {path}[/bold yellow]")
+                break
     
     return commits_made
 

{devcommit-0.1.4.7 → devcommit-0.1.4.9}/devcommit/utils/git.py

@@ -56,13 +56,8 @@ def get_default_excludes() -> List[str]:
     except:
         pass
     
-    # Default exclusions
-    return [
-        'package-lock.json',
-        'pnpm-lock.yaml',
-        'yarn.lock',
-        '*.lock'
-    ]
+    # No default exclusions; rely entirely on user configuration.
+    return []
 
 
 # Get default files to exclude (can be overridden via config)

{devcommit-0.1.4.7 → devcommit-0.1.4.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devcommit"
-version = "0.1.4.7"
+version = "0.1.4.9"
 description = "AI-powered git commit message generator"
 readme = "README.md"
 license = {file = "COPYING"}