git-llm-tool 0.1.12__py3-none-any.whl

git_llm_tool/__init__.py

@@ -0,0 +1,5 @@
+"""Git-LLM-Tool: AI-powered git commit message and changelog generator."""
+
+__version__ = "0.1.5"
+__author__ = "skyler-gogolook"
+__email__ = "skyler.lo@gogolook.com"

git_llm_tool/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running git-llm-tool as a module."""
+
+from git_llm_tool.cli import main
+
+if __name__ == "__main__":
+    main()

git_llm_tool/cli.py

@@ -0,0 +1,167 @@
+"""Main CLI interface for git-llm-tool."""
+
+import click
+from pathlib import Path
+
+from git_llm_tool import __version__
+from git_llm_tool.core.config import ConfigLoader, get_config
+from git_llm_tool.core.exceptions import ConfigError
+from git_llm_tool.commands.commit_cmd import execute_commit
+from git_llm_tool.commands.changelog_cmd import execute_changelog
+
+
+@click.group()
+@click.version_option(version=__version__)
+@click.pass_context
+def main(ctx):
+    """AI-powered git commit message and changelog generator."""
+    ctx.ensure_object(dict)
+
+
+@main.command()
+@click.option(
+    "--apply", "-a", is_flag=True,
+    help="Apply the commit message directly without opening editor"
+)
+@click.option(
+    "--model", "-m",
+    help="LLM model to use (overrides config)"
+)
+@click.option(
+    "--language", "-l",
+    help="Output language (overrides config)"
+)
+@click.option(
+    "--verbose", "-v", is_flag=True,
+    help="Enable verbose output"
+)
+@click.option(
+    "--no-jira", is_flag=True,
+    help="Skip Jira ticket input"
+)
+@click.pass_context
+def commit(ctx, apply, model, language, verbose, no_jira):
+    """Generate AI-powered commit message from staged changes."""
+    execute_commit(apply=apply, model=model, language=language, verbose=verbose, no_jira=no_jira)
+
+
+@main.command()
+@click.option(
+    "--from", "from_ref",
+    help="Starting reference (default: last tag)"
+)
+@click.option(
+    "--to", "to_ref", default="HEAD",
+    help="Ending reference (default: HEAD)"
+)
+@click.option(
+    "--output", "-o",
+    help="Output file (default: stdout)"
+)
+@click.option(
+    "--force", "-f", is_flag=True,
+    help="Force overwrite existing output file"
+)
+@click.option(
+    "--verbose", "-v", is_flag=True,
+    help="Enable verbose output"
+)
+@click.pass_context
+def changelog(ctx, from_ref, to_ref, output, force, verbose):
+    """Generate changelog from git history."""
+    execute_changelog(from_ref=from_ref, to_ref=to_ref, output=output, force=force, verbose=verbose)
+
+
+@main.group()
+def config():
+    """Configuration management commands."""
+    pass
+
+
+@config.command()
+@click.argument("key")
+@click.argument("value")
+def set(key, value):
+    """Set configuration value."""
+    try:
+        config_loader = ConfigLoader()
+        config_loader.set_value(key, value)
+
+        # Save to global config
+        config_loader.save_config()
+
+        click.echo(f"✅ Set {key} = {value}")
+    except ConfigError as e:
+        click.echo(f"❌ Configuration error: {e}", err=True)
+    except Exception as e:
+        click.echo(f"❌ Unexpected error: {e}", err=True)
+
+
+@config.command()
+@click.argument("key", required=False)
+def get(key):
+    """Get configuration value(s)."""
+    try:
+        config = get_config()
+
+        if key:
+            # Get specific key
+            config_loader = ConfigLoader()
+            value = config_loader.get_value(key)
+            click.echo(f"{key} = {value}")
+        else:
+            # Show all configuration
+            click.echo("📋 Current Configuration:")
+            click.echo(f"  llm.default_model = {config.llm.default_model}")
+            click.echo(f"  llm.language = {config.llm.language}")
+
+            if config.llm.api_keys:
+                click.echo("  llm.api_keys:")
+                for provider, key_value in config.llm.api_keys.items():
+                    # Hide API key for security
+                    masked_key = key_value[:8] + "..." if len(key_value) > 8 else "***"
+                    click.echo(f"    {provider} = {masked_key}")
+
+            if config.llm.azure_openai:
+                click.echo("  llm.azure_openai:")
+                for key, value in config.llm.azure_openai.items():
+                    click.echo(f"    {key} = {value}")
+
+            click.echo(f"  jira.enabled = {config.jira.enabled}")
+            if config.jira.ticket_pattern:
+                click.echo(f"  jira.ticket_pattern = {config.jira.ticket_pattern}")
+
+            if config.editor.preferred_editor:
+                click.echo(f"  editor.preferred_editor = {config.editor.preferred_editor}")
+
+    except ConfigError as e:
+        click.echo(f"❌ Configuration error: {e}", err=True)
+    except Exception as e:
+        click.echo(f"❌ Unexpected error: {e}", err=True)
+
+
+@config.command()
+def init():
+    """Initialize configuration file."""
+    try:
+        config_path = Path.home() / ".git-llm-tool" / "config.yaml"
+
+        if config_path.exists():
+            if not click.confirm(f"Configuration file already exists at {config_path}. Overwrite?"):
+                click.echo("❌ Initialization cancelled.")
+                return
+
+        # Create default configuration
+        config_loader = ConfigLoader()
+        config_loader.save_config(config_path)
+
+        click.echo(f"✅ Configuration initialized at {config_path}")
+        click.echo("💡 You can now set API keys with:")
+        click.echo("   git-llm config set llm.api_keys.openai sk-your-key-here")
+
+    except Exception as e:
+        click.echo(f"❌ Failed to initialize configuration: {e}", err=True)
+
+
+if __name__ == "__main__":
+    main()

git_llm_tool/commands/__init__.py

@@ -0,0 +1 @@
+"""Commands module."""

git_llm_tool/commands/changelog_cmd.py

@@ -0,0 +1,189 @@
+"""Changelog command implementation."""
+
+import click
+import os
+from datetime import datetime
+from typing import Optional
+
+from git_llm_tool.core.config import get_config
+from git_llm_tool.core.git_helper import GitHelper
+from git_llm_tool.core.exceptions import GitError, ApiError, ConfigError
+from git_llm_tool.providers import get_provider
+
+
+def _manage_changelog_file(new_content: str, verbose: bool = False) -> str:
+    """Manage the changelog.md file in the repository root.
+
+    Args:
+        new_content: New changelog content to add
+        verbose: Enable verbose output
+
+    Returns:
+        Path to the changelog file
+    """
+    # Get repository root
+    git_helper = GitHelper()
+    repo_info = git_helper.get_repository_info()
+    repo_root = repo_info.get('repository_root', os.getcwd())
+
+    changelog_path = os.path.join(repo_root, 'changelog.md')
+
+    # Get current date
+    current_date = datetime.now().strftime('%Y-%m-%d')
+
+    # Create header with date
+    header = f"\n## {current_date}\n\n"
+
+    # Clean the new content (remove any duplicate titles)
+    cleaned_content = new_content.strip()
+    if cleaned_content.startswith('# Changelog'):
+        # Remove the duplicate title line
+        lines = cleaned_content.split('\n')
+        lines = [line for line in lines[1:] if line.strip()]  # Skip title and empty lines
+        cleaned_content = '\n'.join(lines)
+
+    # Prepare content to add
+    content_to_add = header + cleaned_content + "\n"
+
+    if os.path.exists(changelog_path):
+        if verbose:
+            click.echo(f"📝 Found existing changelog at {changelog_path}")
+
+        # Read existing content
+        try:
+            with open(changelog_path, 'r', encoding='utf-8') as f:
+                existing_content = f.read()
+        except IOError as e:
+            raise Exception(f"Failed to read existing changelog: {e}")
+
+        # Check if we're at the beginning of the file or need to add after title
+        if existing_content.strip().startswith('# '):
+            # Find the end of the title line
+            lines = existing_content.split('\n')
+            title_line = lines[0]
+            rest_content = '\n'.join(lines[1:])
+
+            # Insert new content after title
+            final_content = title_line + '\n' + content_to_add + rest_content
+        else:
+            # Prepend to existing content
+            final_content = content_to_add + existing_content
+
+    else:
+        if verbose:
+            click.echo(f"📄 Creating new changelog at {changelog_path}")
+
+        # Create new changelog with header
+        final_content = f"# Changelog\n{content_to_add}"
+
+    # Write the file
+    try:
+        with open(changelog_path, 'w', encoding='utf-8') as f:
+            f.write(final_content)
+        if verbose:
+            click.echo(f"✅ Updated changelog at {changelog_path}")
+    except IOError as e:
+        raise Exception(f"Failed to write changelog: {e}")
+
+    return changelog_path
+
+
+def execute_changelog(
+    from_ref: Optional[str] = None,
+    to_ref: str = "HEAD",
+    output: Optional[str] = None,
+    force: bool = False,
+    verbose: bool = False
+) -> None:
+    """Execute the changelog command logic.
+
+    Args:
+        from_ref: Starting reference (default: last tag)
+        to_ref: Ending reference (default: HEAD)
+        output: Output file path
+        force: Force overwrite existing file
+        verbose: Enable verbose output
+    """
+    try:
+        # Load configuration
+        config = get_config()
+
+        if verbose:
+            click.echo(f"📄 Using model: {config.llm.default_model}")
+            click.echo(f"🌐 Using language: {config.llm.language}")
+
+        # Initialize Git helper
+        git_helper = GitHelper()
+
+        # Get commit messages in range
+        if verbose:
+            click.echo("📊 Getting commit messages...")
+
+        try:
+            commit_messages = git_helper.get_commit_messages(from_ref, to_ref)
+        except GitError as e:
+            click.echo(f"❌ {e}", err=True)
+            return
+
+        if verbose:
+            click.echo(f"📝 Found {len(commit_messages)} commits")
+
+        # Get LLM provider
+        try:
+            provider = get_provider(config)
+            if verbose:
+                click.echo(f"🤖 Using provider: {provider.__class__.__name__}")
+        except ApiError as e:
+            click.echo(f"❌ {e}", err=True)
+            return
+
+        # Generate changelog
+        click.echo("🤖 Generating changelog...")
+
+        try:
+            changelog = provider.generate_changelog(commit_messages)
+        except ApiError as e:
+            click.echo(f"❌ API Error: {e}", err=True)
+            return
+
+        if verbose:
+            click.echo(f"✨ Generated changelog ({len(changelog)} characters)")
+
+        # Output changelog
+        if output:
+            # Custom output file specified
+            if os.path.exists(output) and not force:
+                if not click.confirm(f"File {output} exists. Overwrite?"):
+                    click.echo("❌ Changelog generation cancelled.")
+                    return
+
+            # Write to custom file
+            try:
+                with open(output, 'w', encoding='utf-8') as f:
+                    f.write(changelog)
+                click.echo(f"✅ Changelog saved to {output}")
+            except IOError as e:
+                click.echo(f"❌ Failed to write to {output}: {e}", err=True)
+        else:
+            # Auto-manage changelog.md in repository root
+            try:
+                changelog_path = _manage_changelog_file(changelog, verbose)
+                click.echo(f"✅ Changelog updated in {changelog_path}")
+
+                # Also show the generated content
+                if verbose:
+                    click.echo("\n" + "="*60)
+                    click.echo("📋 Generated Content:")
+                    click.echo("="*60)
+                    click.echo(changelog)
+                    click.echo("="*60)
+            except Exception as e:
+                click.echo(f"❌ Failed to update changelog.md: {e}", err=True)
+
+    except ConfigError as e:
+        click.echo(f"❌ Configuration error: {e}", err=True)
+    except Exception as e:
+        click.echo(f"❌ Unexpected error: {e}", err=True)
+        if verbose:
+            import traceback
+            click.echo(traceback.format_exc(), err=True)

git_llm_tool/commands/commit_cmd.py

@@ -0,0 +1,134 @@
+"""Commit command implementation."""
+
+import click
+from typing import Optional
+
+from git_llm_tool.core.config import get_config
+from git_llm_tool.core.git_helper import GitHelper
+from git_llm_tool.core.jira_helper import JiraHelper
+from git_llm_tool.core.exceptions import GitError, ApiError, ConfigError, JiraError
+from git_llm_tool.providers import get_provider
+
+
+def execute_commit(
+    apply: bool = False,
+    model: Optional[str] = None,
+    language: Optional[str] = None,
+    verbose: bool = False,
+    no_jira: bool = False
+) -> None:
+    """Execute the commit command logic.
+
+    Args:
+        apply: Whether to apply commit directly without editor
+        model: Override model from config
+        language: Override language from config
+        verbose: Enable verbose output
+        no_jira: Skip Jira ticket input
+    """
+    try:
+        # Load configuration
+        config = get_config()
+
+        # Override config with CLI parameters
+        if model:
+            config.llm.default_model = model
+        if language:
+            config.llm.language = language
+
+        if verbose:
+            click.echo(f"📄 Using model: {config.llm.default_model}")
+            click.echo(f"🌐 Using language: {config.llm.language}")
+
+        # Initialize Git helper
+        git_helper = GitHelper()
+
+        # Get staged diff
+        if verbose:
+            click.echo("📊 Getting staged changes...")
+
+        try:
+            diff = git_helper.get_staged_diff()
+        except GitError as e:
+            click.echo(f"❌ {e}", err=True)
+            click.echo("💡 Tip: Use 'git add' to stage files before committing", err=True)
+            return
+
+        if verbose:
+            click.echo(f"📝 Found {len(diff.splitlines())} lines of changes")
+
+        # Get LLM provider
+        try:
+            provider = get_provider(config)
+            if verbose:
+                click.echo(f"🤖 Using provider: {provider.__class__.__name__}")
+        except ApiError as e:
+            click.echo(f"❌ {e}", err=True)
+            return
+
+        # Initialize Jira helper and get Jira context
+        jira_ticket, work_hours = None, None
+
+        if not no_jira:
+            jira_helper = JiraHelper(config, git_helper)
+
+            try:
+                jira_helper.validate_config()
+                jira_ticket, work_hours = jira_helper.get_jira_context(verbose=verbose)
+
+                if jira_ticket or work_hours:
+                    jira_info = jira_helper.format_jira_info(jira_ticket, work_hours)
+                    click.echo(f"📋 Jira Info: {jira_info}")
+            except JiraError as e:
+                if verbose:
+                    click.echo(f"⚠️ Jira processing skipped: {e}")
+                # Continue without Jira integration
+                pass
+        else:
+            if verbose:
+                click.echo("🔒 Jira integration skipped (--no-jira flag)")
+
+        # Generate commit message
+        click.echo("🤖 Generating commit message...")
+
+        try:
+            commit_message = provider.generate_commit_message(
+                diff=diff,
+                jira_ticket=jira_ticket,
+                work_hours=work_hours
+            )
+        except ApiError as e:
+            click.echo(f"❌ API Error: {e}", err=True)
+            return
+
+        if verbose:
+            click.echo(f"✨ Generated message: {commit_message}")
+
+        # Apply commit or open editor
+        if apply:
+            # Direct commit
+            try:
+                git_helper.commit_with_message(commit_message)
+                click.echo("✅ Commit applied successfully!")
+                click.echo(f"📝 Message: {commit_message}")
+            except GitError as e:
+                click.echo(f"❌ Commit failed: {e}", err=True)
+        else:
+            # Open editor for review
+            click.echo("📝 Opening editor for review...")
+            try:
+                committed = git_helper.open_commit_editor(commit_message, config)
+                if committed:
+                    click.echo("✅ Commit created successfully!")
+                else:
+                    click.echo("❌ Commit cancelled by user")
+            except GitError as e:
+                click.echo(f"❌ Editor error: {e}", err=True)
+
+    except ConfigError as e:
+        click.echo(f"❌ Configuration error: {e}", err=True)
+    except Exception as e:
+        click.echo(f"❌ Unexpected error: {e}", err=True)
+        if verbose:
+            import traceback
+            click.echo(traceback.format_exc(), err=True)

git_llm_tool/core/__init__.py

@@ -0,0 +1 @@
+"""Core module."""