devcommit 0.1.2__tar.gz → 0.1.4.4__tar.gz

devcommit-0.1.4.4/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: devcommit
+Version: 0.1.4.4
+Summary: AI-powered git commit message generator
+License-File: COPYING
+Author: Hordunlarmy
+Author-email: Hordunlarmy@gmail.com
+Requires-Python: >=3.10
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: anthropic (>=0.25.0)
+Requires-Dist: google-generativeai (>=0.7.1)
+Requires-Dist: inquirerpy (>=0.3.4)
+Requires-Dist: openai (>=1.0.0)
+Requires-Dist: python-decouple (>=3.8)
+Requires-Dist: requests (>=2.31.0)
+Requires-Dist: rich (>=13.7.1)

devcommit-0.1.4.4/devcommit/app/ai_providers.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python
+"""AI provider abstraction layer for multiple AI models"""
+
+import os
+import sys
+from abc import ABC, abstractmethod
+from typing import Optional
+
+# Suppress stderr for all AI imports
+_stderr = sys.stderr
+_devnull = open(os.devnull, 'w')
+sys.stderr = _devnull
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+try:
+    import openai
+except ImportError:
+    openai = None
+
+try:
+    import anthropic
+except ImportError:
+    anthropic = None
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+sys.stderr = _stderr
+_devnull.close()
+
+
+class AIProvider(ABC):
+    """Base class for AI providers"""
+    
+    @abstractmethod
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        """Generate commit message from diff"""
+        pass
+
+
+class GeminiProvider(AIProvider):
+    """Google Gemini AI provider"""
+    
+    def __init__(self, api_key: str, model: str = "gemini-1.5-flash"):
+        if not genai:
+            raise ImportError("google-generativeai not installed. Run: pip install google-generativeai")
+        
+        # Suppress stderr during configuration
+        _stderr = sys.stderr
+        _devnull = open(os.devnull, 'w')
+        sys.stderr = _devnull
+        genai.configure(api_key=api_key)
+        sys.stderr = _stderr
+        _devnull.close()
+        
+        self.model_name = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        generation_config = {
+            "response_mime_type": "text/plain",
+            "max_output_tokens": max_tokens,
+            "top_k": 40,
+            "top_p": 0.9,
+            "temperature": 0.7,
+        }
+        
+        model = genai.GenerativeModel(
+            generation_config=generation_config,
+            model_name=self.model_name,
+        )
+        
+        chat_session = model.start_chat(
+            history=[
+                {
+                    "role": "user",
+                    "parts": [prompt],
+                },
+            ]
+        )
+        
+        # Suppress stderr during API call
+        _stderr = sys.stderr
+        _devnull = open(os.devnull, 'w')
+        sys.stderr = _devnull
+        response = chat_session.send_message(diff)
+        sys.stderr = _stderr
+        _devnull.close()
+        
+        if response and hasattr(response, "text"):
+            return response.text.strip()
+        return "No valid commit message generated."
+
+
+class OpenAIProvider(AIProvider):
+    """OpenAI GPT provider"""
+    
+    def __init__(self, api_key: str, model: str = "gpt-4o-mini"):
+        if not openai:
+            raise ImportError("openai not installed. Run: pip install openai")
+        self.client = openai.OpenAI(api_key=api_key)
+        self.model = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": diff}
+            ],
+            max_tokens=max_tokens,
+            temperature=0.7
+        )
+        return response.choices[0].message.content.strip()
+
+
+class GroqProvider(AIProvider):
+    """Groq AI provider (OpenAI-compatible)"""
+    
+    def __init__(self, api_key: str, model: str = "llama-3.3-70b-versatile"):
+        if not openai:
+            raise ImportError("openai not installed. Run: pip install openai")
+        self.client = openai.OpenAI(
+            api_key=api_key,
+            base_url="https://api.groq.com/openai/v1"
+        )
+        self.model = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": diff}
+            ],
+            max_tokens=max_tokens,
+            temperature=0.7
+        )
+        return response.choices[0].message.content.strip()
+
+
+class AnthropicProvider(AIProvider):
+    """Anthropic Claude provider"""
+    
+    def __init__(self, api_key: str, model: str = "claude-3-haiku-20240307"):
+        if not anthropic:
+            raise ImportError("anthropic not installed. Run: pip install anthropic")
+        self.client = anthropic.Anthropic(api_key=api_key)
+        self.model = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        message = self.client.messages.create(
+            model=self.model,
+            max_tokens=max_tokens,
+            system=prompt,
+            messages=[
+                {"role": "user", "content": diff}
+            ]
+        )
+        return message.content[0].text.strip()
+
+
+class OllamaProvider(AIProvider):
+    """Ollama local model provider"""
+    
+    def __init__(self, base_url: str = "http://localhost:11434", model: str = "llama3"):
+        if not requests:
+            raise ImportError("requests not installed. Run: pip install requests")
+        self.base_url = base_url.rstrip('/')
+        self.model = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        url = f"{self.base_url}/api/generate"
+        data = {
+            "model": self.model,
+            "prompt": f"{prompt}\n\n{diff}",
+            "stream": False,
+            "options": {
+                "temperature": 0.7,
+                "num_predict": max_tokens
+            }
+        }
+        
+        response = requests.post(url, json=data, timeout=60)
+        response.raise_for_status()
+        result = response.json()["response"].strip()
+        
+        # Return raw result - normalization is done centrally in gemini_ai.py
+        return result
+
+
+class CustomProvider(AIProvider):
+    """Custom OpenAI-compatible API provider"""
+    
+    def __init__(self, api_url: str, api_key: Optional[str] = None, model: str = "default"):
+        if not openai:
+            raise ImportError("openai not installed. Run: pip install openai")
+        
+        # Extract base URL (remove /chat/completions if present)
+        base_url = api_url.replace('/chat/completions', '').replace('/v1/chat/completions', '')
+        if not base_url.endswith('/v1'):
+            base_url = base_url.rstrip('/') + '/v1'
+            
+        self.client = openai.OpenAI(
+            api_key=api_key or "dummy-key",
+            base_url=base_url
+        )
+        self.model = model
+        
+    def generate_commit_message(self, diff: str, prompt: str, max_tokens: int) -> str:
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=[
+                {"role": "system", "content": prompt},
+                {"role": "user", "content": diff}
+            ],
+            max_tokens=max_tokens,
+            temperature=0.7
+        )
+        return response.choices[0].message.content.strip()
+
+
+def get_ai_provider(config) -> AIProvider:
+    """Factory function to get the appropriate AI provider based on config"""
+    
+    provider_name = config("AI_PROVIDER", default="gemini").lower()
+    
+    if provider_name == "gemini":
+        api_key = config("GEMINI_API_KEY", default=None)
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY not set")
+        # Support legacy MODEL_NAME for backward compatibility
+        model = config("GEMINI_MODEL", default=None) or config("MODEL_NAME", default="gemini-1.5-flash")
+        return GeminiProvider(api_key, model)
+    
+    elif provider_name == "openai":
+        api_key = config("OPENAI_API_KEY", default=None)
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY not set")
+        model = config("OPENAI_MODEL", default="gpt-4o-mini")
+        return OpenAIProvider(api_key, model)
+    
+    elif provider_name == "groq":
+        api_key = config("GROQ_API_KEY", default=None)
+        if not api_key:
+            raise ValueError("GROQ_API_KEY not set")
+        model = config("GROQ_MODEL", default="llama-3.3-70b-versatile")
+        return GroqProvider(api_key, model)
+    
+    elif provider_name == "anthropic":
+        api_key = config("ANTHROPIC_API_KEY", default=None)
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY not set")
+        model = config("ANTHROPIC_MODEL", default="claude-3-haiku-20240307")
+        return AnthropicProvider(api_key, model)
+    
+    elif provider_name == "ollama":
+        base_url = config("OLLAMA_BASE_URL", default="http://localhost:11434")
+        model = config("OLLAMA_MODEL", default="llama3")
+        return OllamaProvider(base_url, model)
+    
+    elif provider_name == "custom":
+        api_url = config("CUSTOM_API_URL", default=None)
+        if not api_url:
+            raise ValueError("CUSTOM_API_URL not set for custom provider")
+        api_key = config("CUSTOM_API_KEY", default=None)
+        model = config("CUSTOM_MODEL", default="default")
+        return CustomProvider(api_url, api_key, model)
+    
+    else:
+        raise ValueError(
+            f"Unknown AI provider: {provider_name}. "
+            f"Supported: gemini, openai, groq, anthropic, ollama, custom"
+        )
+

devcommit-0.1.4.4/devcommit/app/gemini_ai.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+"""Generate a git commit message using AI"""
+
+import os
+import re
+import sys
+import warnings
+
+# Suppress warnings from AI libraries
+os.environ['GRPC_ENABLE_FORK_SUPPORT'] = '1'
+os.environ['GRPC_VERBOSITY'] = 'ERROR'
+os.environ['GLOG_minloglevel'] = '3'
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+
+warnings.filterwarnings('ignore', message='.*ALTS.*')
+warnings.filterwarnings('ignore', category=UserWarning)
+
+from devcommit.utils.logger import Logger, config
+from .ai_providers import get_ai_provider
+from .prompt import generate_prompt
+
+logger_instance = Logger("__ai__")
+logger = logger_instance.get_logger()
+
+
+def normalize_commit_response(response: str) -> str:
+    """Normalize AI response to ensure proper formatting of commit messages"""
+    result = response.strip()
+    
+    # Remove markdown code fences that some models add
+    result = re.sub(r'^```[\w]*\n?', '', result)  # Remove opening ```
+    result = re.sub(r'\n?```$', '', result)        # Remove closing ```
+    result = result.strip()
+    
+    # If no pipe separator but has newlines, convert newlines to pipes
+    if "|" not in result and "\n" in result:
+        messages = []
+        for line in result.split("\n"):
+            line = line.strip()
+            if line:
+                # Skip markdown code fences
+                if line.startswith('```') or line == '```':
+                    continue
+                # Remove common numbering patterns: "1. ", "1) ", "- ", etc.
+                line = re.sub(r'^\d+[\.\)]\s*', '', line)  # Remove "1. " or "1) "
+                line = re.sub(r'^[-*•]\s*', '', line)      # Remove "- " or "* " or "• "
+                if line:
+                    messages.append(line)
+        result = "|".join(messages)
+    
+    return result
+
+
+def generateCommitMessage(diff: str) -> str:
+    """Return a generated commit message using configured AI provider"""
+    # Suppress stderr to hide warnings during API calls
+    _stderr = sys.stderr
+    _devnull_out = open(os.devnull, 'w')
+    
+    try:
+        # Load Configuration Values
+        max_no = config("MAX_NO", default=1, cast=int)
+        locale = config("LOCALE", default="en-US")
+        commit_type = config("COMMIT_TYPE", default="general")
+        max_tokens = config("MAX_TOKENS", default=8192, cast=int)
+        
+        # Generate prompt
+        prompt_text = generate_prompt(max_tokens, max_no, locale, commit_type)
+        
+        # Get AI provider based on configuration
+        sys.stderr = _devnull_out
+        provider = get_ai_provider(config)
+        sys.stderr = _stderr
+        
+        # Generate commit message
+        sys.stderr = _devnull_out
+        response = provider.generate_commit_message(diff, prompt_text, max_tokens)
+        sys.stderr = _stderr
+        
+        # Normalize response to handle different formatting from various providers
+        normalized_response = normalize_commit_response(response)
+        
+        return normalized_response
+
+    except Exception as e:
+        logger.error(f"Error generating commit message: {e}")
+        return f"Error generating commit message: {str(e)}"
+    finally:
+        # Restore stderr and close devnull
+        sys.stderr = _stderr
+        _devnull_out.close()

{devcommit-0.1.2 → devcommit-0.1.4.4}/devcommit/app/prompt.py

@@ -56,18 +56,30 @@ def specify_commit_format(commit_type: CommitType) -> str:
 def generate_prompt(
     max_length: int, max_no: int, locale: str, commit_type: CommitType
 ) -> str:
-    """Prompt Passed to Gemini for Generating a Git Commit Message"""
+    """Generate a detailed prompt for Gemini to create a strict Git commit message."""
 
     prompt_parts = [
-        "Generate a concise git commit message written in present tense for the following code diff with the given specifications below:",
-        f"Message language: {locale}",
-        f"Commit count: {max_no}",
-        "Max_line_per_commit: 1",
-        "Separator: '|'",
-        f"Commit message must be a maximum of {max_length} characters.",
-        "You are to generate commit message or messages based on the count passed. Reply with only the commit message or messages. Exclude anything unnecessary such as translation or description. Only return the commit message or messages. Separation should only be done with Separator not newline.",
-        commit_types[commit_type],
-        specify_commit_format(commit_type),
+        "You are tasked with generating Git commit messages based solely on the following code diff.",
+        "Please adhere to the following specifications meticulously:",
+        # Language of the commit message
+        f"1. The language of the commit message should be: {locale}. This specifies the linguistic format of the message.",
+        # Number of commit messages
+        f"2. You MUST generate EXACTLY {max_no} commit message(s). No more, no less. This is mandatory.",
+        # Line and message formatting
+        "3. Each commit message must be succinct and limited to a single line. Do not exceed one line per message.",
+        # Separator specifications
+        f"4. IMPORTANT: If generating {max_no} > 1 messages, separate them with '|' OR put each on a new line. Example for 3 messages:",
+        "   - Option 1: message1|message2|message3",
+        "   - Option 2: message1\\nmessage2\\nmessage3",
+        # Length restrictions
+        f"5. Each individual commit message must not exceed {max_length} characters in length. This is a strict upper limit.",
+        # Exclusions from response
+        "6. Generate ONLY the commit message(s) as specified. Do NOT include: markdown code blocks (```), numbering, bullet points, explanations, or any formatting.",
+        # Commit Type instructions
+        f"7. Refer to the following commit type specification: {commit_types[commit_type]}. This will guide the nature of the commit messages you produce.",
+        # Formatting requirements
+        f"8. Follow the specific format required for the given commit type, which is defined as follows: {specify_commit_format(commit_type)}.",
     ]
 
+    # Return the fully constructed prompt as a single formatted string
     return "\n".join(filter(bool, prompt_parts))

devcommit-0.1.4.4/devcommit/main.py

@@ -0,0 +1,396 @@
+import os
+import subprocess
+
+# Suppress Google gRPC/ALTS warnings before any imports
+os.environ['GRPC_VERBOSITY'] = 'ERROR'
+os.environ['GLOG_minloglevel'] = '3'
+os.environ['GRPC_ENABLE_FORK_SUPPORT'] = '1'
+
+from InquirerPy import get_style, inquirer
+from rich.console import Console
+
+from devcommit.app.gemini_ai import generateCommitMessage
+from devcommit.utils.git import (KnownError, assert_git_repo,
+                                 get_detected_message, get_diff_for_files,
+                                 get_staged_diff, group_files_by_directory)
+from devcommit.utils.logger import Logger, config
+from devcommit.utils.parser import CommitFlag, parse_arguments
+
+logger_instance = Logger("__devcommit__")
+logger = logger_instance.get_logger()
+
+
+# Function to check if any commits exist
+def has_commits() -> bool:
+    result = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    return result.returncode == 0
+
+
+# Main function
+def main(flags: CommitFlag = None):
+    if flags is None:
+        flags = parse_arguments()
+
+    try:
+        assert_git_repo()
+        console = Console()
+        
+        # Print stylish header with gradient effect
+        console.print()
+        console.print("╭" + "─" * 60 + "╮", style="bold cyan")
+        console.print("│" + " " * 60 + "│", style="bold cyan")
+        console.print("│" + "  🚀 [bold white on cyan] DevCommit [/bold white on cyan]  [bold white]AI-Powered Commit Generator[/bold white]".ljust(76) + "│", style="bold cyan")
+        console.print("│" + " " * 60 + "│", style="bold cyan")
+        console.print("╰" + "─" * 60 + "╯", style="bold cyan")
+        
+        # Display provider and model info
+        provider = config("AI_PROVIDER", default="gemini").lower()
+        model = ""
+        
+        if provider == "ollama":
+            model = config("OLLAMA_MODEL", default="llama3")
+        elif provider == "gemini":
+            model = config("GEMINI_MODEL", default=None) or config("MODEL_NAME", default="gemini-1.5-flash")
+        elif provider == "openai":
+            model = config("OPENAI_MODEL", default="gpt-4o-mini")
+        elif provider == "groq":
+            model = config("GROQ_MODEL", default="llama-3.3-70b-versatile")
+        elif provider == "anthropic":
+            model = config("ANTHROPIC_MODEL", default="claude-3-haiku-20240307")
+        elif provider == "custom":
+            model = config("CUSTOM_MODEL", default="default")
+        
+        console.print(f"[dim]Provider:[/dim] [bold magenta]{provider}[/bold magenta] [dim]│[/dim] [dim]Model:[/dim] [bold magenta]{model}[/bold magenta]")
+        console.print()
+
+        if flags["stageAll"]:
+            stage_changes(console)
+
+        staged = detect_staged_files(console, flags["excludeFiles"])
+        
+        # Determine commit strategy
+        # Priority: CLI flag > config (file or env) > interactive prompt
+        use_per_directory = flags.get("directory", False)
+        
+        # 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()
+            if commit_mode == "directory":
+                use_per_directory = True
+            elif commit_mode == "global":
+                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 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 use_per_directory:
+            process_per_directory_commits(console, staged, flags)
+        else:
+            process_global_commit(console, flags)
+        
+        # Print stylish completion message
+        console.print()
+        console.print("╭" + "─" * 60 + "╮", style="bold green")
+        console.print("│" + " " * 60 + "│", style="bold green")
+        console.print("│" + "     ✨ [bold white]All commits completed successfully![/bold white] ✨     ".ljust(68) + "│", style="bold green")
+        console.print("│" + " " * 60 + "│", style="bold green")
+        console.print("╰" + "─" * 60 + "╯", style="bold green")
+        console.print()
+
+    except KeyboardInterrupt:
+        console.print("\n\n[bold yellow]⚠️  Operation cancelled by user[/bold yellow]\n")
+        return
+    except KnownError as error:
+        logger.error(str(error))
+        console.print(f"\n[bold red]❌ Error:[/bold red] [red]{error}[/red]\n")
+    except subprocess.CalledProcessError as error:
+        logger.error(str(error))
+        console.print(f"\n[bold red]❌ Git command failed:[/bold red] [red]{error}[/red]\n")
+    except Exception as error:
+        logger.error(str(error))
+        console.print(f"\n[bold red]❌ Unexpected error:[/bold red] [red]{error}[/red]\n")
+
+
+def stage_changes(console):
+    with console.status(
+        "[cyan]🔄 Staging changes...[/cyan]",
+        spinner="dots",
+        spinner_style="cyan"
+    ):
+        subprocess.run(["git", "add", "--update"], check=True)
+
+
+def detect_staged_files(console, exclude_files):
+    with console.status(
+        "[cyan]🔍 Detecting staged files...[/cyan]",
+        spinner="dots",
+        spinner_style="cyan"
+    ):
+        staged = get_staged_diff(exclude_files)
+        if not staged:
+            raise KnownError(
+                "No staged changes found. Stage your changes manually, or "
+                "automatically stage all changes with the `--stageAll` flag."
+            )
+        console.print(
+            f"\n[bold green]✅ {get_detected_message(staged['files'])}[/bold green]"
+        )
+        console.print("[dim]" + "─" * 60 + "[/dim]")
+        for file in staged["files"]:
+            console.print(f"  [cyan]▸[/cyan] [white]{file}[/white]")
+        console.print("[dim]" + "─" * 60 + "[/dim]")
+        return staged
+
+
+def analyze_changes(console):
+    import sys
+    
+    with console.status(
+        "[magenta]🤖 AI analyzing changes...[/magenta]",
+        spinner="dots",
+        spinner_style="magenta"
+    ):
+        diff = subprocess.run(
+            ["git", "diff", "--staged"],
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout
+
+        if not diff:
+            raise KnownError(
+                "No diff could be generated. Ensure you have changes staged."
+            )
+
+        # Suppress stderr during AI call to hide ALTS warnings
+        _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:
+            raise KnownError("No commit messages were generated. Try again.")
+
+        return commit_message
+
+
+def prompt_commit_message(console, commit_message):
+    tag = (
+        "Select commit message"
+        if len(commit_message) > 1
+        else "Confirm commit message"
+    )
+    style = get_style({
+        "question": "#00d7ff bold",
+        "questionmark": "#00d7ff bold",
+        "pointer": "#00d7ff bold",
+        "instruction": "#7f7f7f",
+        "answer": "#00d7ff bold",
+        "fuzzy_info": ""  # Hide the counter
+    }, style_override=False)
+    
+    console.print()
+    console.print("[bold cyan]📝 Generated Commit Messages:[/bold cyan]")
+    console.print()
+    
+    # Add numbered options (plain text since InquirerPy doesn't support ANSI in choices)
+    numbered_choices = []
+    for idx, msg in enumerate(commit_message, 1):
+        if isinstance(msg, str):
+            numbered_choices.append({"name": f"  {idx}. {msg}", "value": msg})
+        else:
+            numbered_choices.append(msg)
+    
+    choices = [
+        *numbered_choices,
+        {"name": "  ❌ [Cancel]", "value": "cancel"}
+    ]
+    
+    action = inquirer.fuzzy(
+        message=tag,
+        style=style,
+        choices=choices,
+        default=None,
+        instruction="(Type to filter or use arrows)",
+        qmark="❯",
+        info=False  # Disable info/counter
+    ).execute()
+
+    if action == "cancel":
+        console.print("\n[bold yellow]⚠️  Commit cancelled[/bold yellow]\n")
+        return None
+    return action
+
+
+def commit_changes(console, commit, raw_argv):
+    subprocess.run(["git", "commit", "-m", commit, *raw_argv])
+    console.print("\n[bold green]✅ Committed successfully![/bold green]")
+
+
+def prompt_commit_strategy(console, grouped):
+    """Prompt user to choose between global or directory-based commits."""
+    console.print()
+    console.print("╭" + "─" * 60 + "╮", style="bold yellow")
+    console.print("│" + "  📂 [bold white]Multiple directories detected[/bold white]".ljust(70) + "│", style="bold yellow")
+    console.print("╰" + "─" * 60 + "╯", style="bold yellow")
+    console.print()
+    
+    for directory, files in grouped.items():
+        console.print(f"  [yellow]▸[/yellow] [bold white]{directory}[/bold white] [dim]({len(files)} file(s))[/dim]")
+    console.print()
+    
+    style = get_style({
+        "question": "#00d7ff bold",
+        "questionmark": "#00d7ff bold",
+        "pointer": "#00d7ff bold",
+        "instruction": "#7f7f7f",
+        "answer": "#00d7ff bold"
+    }, style_override=False)
+    
+    strategy = inquirer.select(
+        message="Commit strategy",
+        style=style,
+        choices=[
+            {"name": "  🌐 One commit for all changes", "value": False},
+            {"name": "  📁 Separate commits per directory", "value": True},
+        ],
+        default=None,
+        instruction="(Use arrow keys)",
+        qmark="❯"
+    ).execute()
+    
+    return strategy
+
+
+def process_global_commit(console, flags):
+    """Process a single global commit for all changes."""
+    commit_message = analyze_changes(console)
+    selected_commit = prompt_commit_message(console, commit_message)
+    if selected_commit:
+        commit_changes(console, selected_commit, flags["rawArgv"])
+
+
+def process_per_directory_commits(console, staged, flags):
+    """Process separate commits for each directory."""
+    grouped = group_files_by_directory(staged["files"])
+    
+    console.print()
+    console.print("╭" + "─" * 60 + "╮", style="bold magenta")
+    console.print("│" + f"  🔮 [bold white]Processing {len(grouped)} directories[/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 directories
+    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(grouped) > 1:
+        commit_all = inquirer.confirm(
+            message="Commit all directories?",
+            style=style,
+            default=True,
+            instruction="(y/n)",
+            qmark="❯"
+        ).execute()
+        
+        if commit_all:
+            selected_directories = list(grouped.keys())
+        else:
+            # Let user select which directories to commit
+            directory_choices = [
+                {"name": f"{directory} ({len(files)} file(s))", "value": directory}
+                for directory, files in grouped.items()
+            ]
+            
+            selected_directories = inquirer.checkbox(
+                message="Select directories to commit",
+                style=style,
+                choices=directory_choices,
+                default=list(grouped.keys()),
+                instruction="(Space to select, Enter to confirm)",
+                qmark="❯"
+            ).execute()
+    else:
+        selected_directories = list(grouped.keys())
+    
+    if not selected_directories:
+        console.print("\n[bold yellow]⚠️  No directories selected[/bold yellow]\n")
+        return
+    
+    # Process each selected directory
+    for idx, directory in enumerate(selected_directories, 1):
+        files = grouped[directory]
+        console.print()
+        console.print("┌" + "─" * 60 + "┐", style="bold cyan")
+        console.print("│" + f"  📂 [{idx}/{len(selected_directories)}] [bold white]{directory}[/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 directory's files
+        with console.status(
+            f"[magenta]🤖 Analyzing {directory}...[/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 {directory}, 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 {directory}, skipping[/bold yellow]\n")
+                continue
+        
+        # Prompt for commit message selection
+        selected_commit = prompt_commit_message(console, commit_message)
+        
+        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]")
+        else:
+            console.print(f"\n[bold yellow]⊘ Skipped {directory}[/bold yellow]")
+
+
+if __name__ == "__main__":
+    main()

{devcommit-0.1.2 → devcommit-0.1.4.4}/devcommit/utils/git.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python3
 """Git utilities"""
 
+import os
 import subprocess
-from typing import List, Optional
+from collections import defaultdict
+from typing import Dict, List, Optional
 
 
 class KnownError(Exception):
@@ -36,12 +38,35 @@ def exclude_from_diff(path: str) -> str:
     return f':(exclude){path}'
 
 
-# List of default files to exclude from the diff
-files_to_exclude = [
-    'package-lock.json',
-    'pnpm-lock.yaml',
-    '*.lock'
-]
+def get_default_excludes() -> List[str]:
+    """
+    Get list of files to exclude from diff.
+    Priority: Config > Defaults
+    """
+    try:
+        from devcommit.utils.logger import config
+        
+        # Get from config (supports comma-separated list)
+        exclude_config = config("EXCLUDE_FILES", default="")
+        
+        if exclude_config:
+            # Parse comma-separated values and strip whitespace
+            config_excludes = [f.strip() for f in exclude_config.split(",") if f.strip()]
+            return config_excludes
+    except:
+        pass
+    
+    # Default exclusions
+    return [
+        'package-lock.json',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+        '*.lock'
+    ]
+
+
+# Get default files to exclude (can be overridden via config)
+files_to_exclude = get_default_excludes()
 
 
 def get_staged_diff(
@@ -94,3 +119,52 @@ def get_detected_message(files: List[str]) -> str:
     return (
         f"Detected {len(files):,} staged file{'s' if len(files) > 1 else ''}"
     )
+
+
+def group_files_by_directory(files: List[str]) -> Dict[str, List[str]]:
+    """
+    Groups files by their root directory (first-level directory).
+    Files in the repository root are grouped under 'root'.
+    """
+    grouped = defaultdict(list)
+    
+    for file_path in files:
+        # Get the first directory in the path
+        parts = file_path.split(os.sep)
+        if len(parts) > 1:
+            root_dir = parts[0]
+        else:
+            root_dir = 'root'
+        grouped[root_dir].append(file_path)
+    
+    return dict(grouped)
+
+
+def get_diff_for_files(files: List[str], exclude_files: Optional[List[str]] = None) -> str:
+    """
+    Gets the diff for specific files.
+    """
+    exclude_files = exclude_files or []
+    
+    # Filter out excluded files from the list
+    all_excluded = files_to_exclude + exclude_files
+    filtered_files = [
+        f for f in files 
+        if not any(f.endswith(excl.replace('*', '')) or excl.replace(':(exclude)', '') in f 
+                   for excl in all_excluded)
+    ]
+    
+    if not filtered_files:
+        return ""
+    
+    try:
+        diff = subprocess.run(
+            ['git', 'diff', '--cached', '--diff-algorithm=minimal', '--'] + filtered_files,
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return diff.stdout.strip()
+    except subprocess.CalledProcessError:
+        return ""

{devcommit-0.1.2 → devcommit-0.1.4.4}/devcommit/utils/logger.py

@@ -1,12 +1,23 @@
 import logging
 import os
 
-from decouple import Config, RepositoryEnv
+from decouple import Config, RepositoryEnv, AutoConfig
 
-# Load configuration from the custom file
-home_dir = os.path.expanduser("~/.dcommit")
+# Determine config file path
+if "VIRTUAL_ENV" in os.environ:
+    config_path = os.path.join(os.environ["VIRTUAL_ENV"], "config", ".dcommit")
+else:
+    config_path = os.path.expanduser("~/.dcommit")
 
-config = Config(RepositoryEnv(home_dir))
+# Create config with priority: .dcommit file > environment variables > defaults
+if os.path.isfile(config_path):
+    # Use file-based config with environment variable fallback
+    config = Config(RepositoryEnv(config_path))
+    print("Configuration loaded from:", config_path)
+else:
+    # Use environment variables only
+    config = AutoConfig()
+    print("Using environment variables and defaults (no .dcommit file found)")
 
 
 class Logger:
@@ -15,7 +26,7 @@ class Logger:
     def __init__(
         self,
         logger_name: str,
-        log_file: str = "dc.logs",
+        log_file: str = "devcommits.logs",
         log_level: int = logging.DEBUG,
     ):
         self.logger = logging.getLogger(logger_name)

{devcommit-0.1.2 → devcommit-0.1.4.4}/devcommit/utils/parser.py

@@ -8,6 +8,7 @@ class CommitFlag(TypedDict):
     excludeFiles: List[str]
     stageAll: bool
     commitType: Optional[str]
+    directory: bool
     rawArgv: List[str]
 
 
@@ -37,6 +38,10 @@ def parse_arguments() -> CommitFlag:
     parser.add_argument(
         "--commitType", "-t", type=str, default=None, help="Type of commit"
     )
+    parser.add_argument(
+        "--directory", "-d", action="store_true", 
+        help="Generate separate commits per root directory"
+    )
     parser.add_argument(
         "rawArgv", nargs="*", help="Additional arguments for git commit"
     )
@@ -48,5 +53,6 @@ def parse_arguments() -> CommitFlag:
         excludeFiles=args.excludeFiles,
         stageAll=args.stageAll,
         commitType=args.commitType,
+        directory=args.directory,
         rawArgv=args.rawArgv,
     )

devcommit-0.1.4.4/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "devcommit"
+version = "0.1.4.4"
+description = "AI-powered git commit message generator"
+authors = [
+    {name = "Hordunlarmy", email = "Hordunlarmy@gmail.com"}
+]
+requires-python = ">=3.10"
+dependencies = [
+    "inquirerpy>=0.3.4",
+    "google-generativeai>=0.7.1",
+    "openai>=1.0.0",
+    "anthropic>=0.25.0",
+    "rich>=13.7.1",
+    "python-decouple>=3.8",
+    "requests>=2.31.0",
+]
+
+[project.optional-dependencies]
+
+[project.scripts]
+devcommit = "devcommit.main:main"
+create-dcommit = "scripts.create_dcommit:create_dcommit"
+
+[tool.poetry]
+name = "devcommit"
+version = "0.1.4.4"
+description = "AI-powered git commit message generator"
+authors = ["Hordunlarmy <Hordunlarmy@gmail.com>"]
+
+[tool.poetry.dependencies]
+python = ">=3.10,<3.13"
+inquirerpy = "0.3.4"
+google-generativeai = "0.8.5"
+openai = "2.3.0"
+anthropic = "0.69.0"
+rich = "14.2.0"
+python-decouple = "3.8"
+requests = "2.32.5"
+
+[tool.poetry.group.dev.dependencies]
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

devcommit-0.1.2/PKG-INFO

@@ -1,37 +0,0 @@
-Metadata-Version: 2.1
-Name: devcommit
-Version: 0.1.2
-Summary: A command-line AI tool for autocommits
-Home-page: https://github.com/hordunlarmy/DevCommit
-License: MIT
-Author: HordunTech
-Author-email: horduntech@gmail.com
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Project-URL: Repository, https://github.com/hordunlarmy/DevCommit
-Description-Content-Type: text/markdown
-
-# DevCommit
-
-A command-line AI tool for autocommits.
-
-## Features
-
-- Automatic commit generation using AI.
-- Easy integration with your Git workflow.
-- Customizable options for commit messages.
-
-![README image](https://i.imgur.com/erPaZjc.png)
-

devcommit-0.1.2/README.md

@@ -1,11 +0,0 @@
-# DevCommit
-
-A command-line AI tool for autocommits.
-
-## Features
-
-- Automatic commit generation using AI.
-- Easy integration with your Git workflow.
-- Customizable options for commit messages.
-
-![README image](https://i.imgur.com/erPaZjc.png)

devcommit-0.1.2/devcommit/app/gemini_ai.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python
-"""Generate a git commit message using Gemini AI"""
-
-
-import google.generativeai as genai
-
-from devcommit.utils.logger import Logger, config
-
-from .prompt import generate_prompt
-
-logger_instance = Logger("__gemini_ai__")
-logger = logger_instance.get_logger()
-
-
-def generateCommitMessage(diff: str) -> str:
-    """Return a generated commit message using Gemini AI"""
-    try:
-        # Configure API Key
-        api_key = config("GEMINI_API_KEY")
-        if not api_key:
-            raise ValueError("GEMINI_API_KEY not set.")
-        genai.configure(api_key=api_key)
-
-        # Load Configuration Values
-        max_no = config("MAX_NO", default=1)
-        locale = config("LOCALE", default="en-US")
-        commit_type = config("COMMIT_TYPE", default="general")
-        model_name = config("MODEL_NAME", default="gemini-1.5-flash")
-        if not model_name:
-            raise ValueError("MODEL_NAME not set.")
-
-        generation_config = {
-            "response_mime_type": "text/plain",
-            "max_output_tokens": 8192,
-            "top_k": 64,
-            "top_p": 0.95,
-            "temperature": 0.7,
-        }
-
-        # Create Model and Start Chat
-        model = genai.GenerativeModel(
-            generation_config=generation_config,
-            model_name=model_name,
-        )
-
-        prompt_text = generate_prompt(8192, max_no, locale, commit_type)
-        # logger.info(f"Prompt: {prompt_text}")
-        chat_session = model.start_chat(
-            history=[
-                {
-                    "role": "user",
-                    "parts": [prompt_text],
-                },
-            ]
-        )
-
-        # Send the Diff as Message
-        # logger.info(f"Diff: {diff}")
-        response = chat_session.send_message(diff)
-        if response and hasattr(response, "text"):
-            return response.text.strip()
-        else:
-            logger.error("No valid response received from Gemini AI.")
-            return "No valid commit message generated."
-
-    except Exception as e:
-        logger.error(f"Error generating commit message: {e}")
-        return f"Error generating commit message: {str(e)}"

devcommit-0.1.2/devcommit/main.py

@@ -1,136 +0,0 @@
-import subprocess
-
-from InquirerPy import get_style, inquirer
-from rich.console import Console
-
-from devcommit.app.gemini_ai import generateCommitMessage
-from devcommit.utils.git import (KnownError, assert_git_repo,
-                                 get_detected_message, get_staged_diff)
-from devcommit.utils.logger import Logger
-from devcommit.utils.parser import CommitFlag, parse_arguments
-
-logger_instance = Logger("__devcommit__")
-logger = logger_instance.get_logger()
-
-
-# Function to check if any commits exist
-def has_commits() -> bool:
-    result = subprocess.run(
-        ["git", "rev-parse", "HEAD"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-    )
-    return result.returncode == 0
-
-
-# Main function
-def main(flags: CommitFlag = None):
-    if flags is None:
-        flags = parse_arguments()
-
-    try:
-        assert_git_repo()
-        console = Console()
-
-        if flags["stageAll"]:
-            stage_changes(console)
-
-        detect_staged_files(console, flags["excludeFiles"])
-        commit_message = analyze_changes(console)
-
-        selected_commit = prompt_commit_message(console, commit_message)
-        if selected_commit:
-            commit_changes(console, selected_commit, flags["rawArgv"])
-
-    except KnownError as error:
-        logger.error(str(error))
-        console.print(f"[bold red]✖ {error}[/bold red]")
-    except subprocess.CalledProcessError as error:
-        logger.error(str(error))
-        console.print(f"[bold red]✖ Git command failed: {error}[/bold red]")
-    except Exception as error:
-        logger.error(str(error))
-        console.print(f"[bold red]✖ {error}[/bold red]")
-
-
-def stage_changes(console):
-    with console.status(
-        "[bold green]Staging all changes...[/bold green]",
-        spinner="dots",
-    ):
-        subprocess.run(["git", "add", "--update"], check=True)
-
-
-def detect_staged_files(console, exclude_files):
-    with console.status(
-        "[bold green]Detecting staged files...[/bold green]",
-        spinner="dots",
-    ):
-        staged = get_staged_diff(exclude_files)
-        if not staged:
-            raise KnownError(
-                "No staged changes found. Stage your changes manually, or "
-                "automatically stage all changes with the `--stageAll` flag."
-            )
-        console.print(
-            f"[bold green]{get_detected_message(staged['files'])}:"
-            f"[/bold green]"
-        )
-        for file in staged["files"]:
-            console.print(f" - {file}")
-        return staged
-
-
-def analyze_changes(console):
-    with console.status(
-        "[bold green]The AI is analyzing your changes...[/bold green]",
-        spinner="dots",
-    ):
-        diff = subprocess.run(
-            ["git", "diff", "--staged"],
-            stdout=subprocess.PIPE,
-            text=True,
-        ).stdout
-
-        if not diff:
-            raise KnownError(
-                "No diff could be generated. Ensure you have changes staged."
-            )
-
-        commit_message = generateCommitMessage(diff)
-        if isinstance(commit_message, str):
-            commit_message = commit_message.split("|")
-
-        if not commit_message:
-            raise KnownError("No commit messages were generated. Try again.")
-
-        return commit_message
-
-
-def prompt_commit_message(console, commit_message):
-    tag = (
-        "Use This Commit Message? "
-        if len(commit_message) == 1
-        else "Select A Commit Message:"
-    )
-    style = get_style({"instruction": "#abb2bf"}, style_override=False)
-    action = inquirer.fuzzy(
-        message=tag,
-        style=style,
-        choices=[*commit_message, "cancel"],
-        default=None,
-    ).execute()
-
-    if action == "cancel":
-        console.print("[bold red]Commit cancelled[/bold red]")
-        return None
-    return action
-
-
-def commit_changes(console, commit, raw_argv):
-    subprocess.run(["git", "commit", "-m", commit, *raw_argv])
-    console.print("[bold green]✔ Successfully committed![/bold green]")
-
-
-if __name__ == "__main__":
-    main()

devcommit-0.1.2/pyproject.toml

@@ -1,25 +0,0 @@
-[tool.poetry]
-name = "devcommit"
-version = "0.1.2"
-description = "A command-line AI tool for autocommits"
-authors = ["HordunTech <horduntech@gmail.com>"]
-license = "MIT"
-readme = "README.md"
-homepage = "https://github.com/hordunlarmy/DevCommit"
-repository = "https://github.com/hordunlarmy/DevCommit"
-
-[project.dependencies]
-python = "^3.7"
-inquirerpy = "^0.3.4"
-google-generativeai = "^0.7.1"
-rich = "^13.7.1"
-python-decouple = "^3.8"
-
-[project.scripts]
-devcommit = "devcommit.main:main"
-create-dcommit = "scripts.create_dcommit:create_dcommit"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"
-