aiautocommit 0.6.0__tar.gz

aiautocommit-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Michael Bianco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiautocommit-0.6.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: aiautocommit
+Version: 0.6.0
+Summary: AI generated commit messages
+Author-email: Michael Bianco <mike@mikebian.co>
+Project-URL: Repository, https://github.com/iloveitaly/aiautocommit
+Keywords: git,commit,automation,ai,openai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.7
+Requires-Dist: openai>=1.54.3
+
+[![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# aiautocommit
+
+Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.
+
+Yes, there are a lot of these. Main ways this is different:
+
+* Simple codebase
+* Ability to easily customize prompts on a per-repo basis
+
+## Installation
+
+```shell
+pip install aiautocommit
+```
+
+## Features
+
+* Generates conventional commit messages
+* Customizable prompts and exclusions
+* Pre-commit hook integration
+* Supports custom config directories
+
+## Getting Started
+
+Set your OpenAI API key:
+
+```
+export OPENAI_API_KEY=<YOUR API KEY>
+```
+
+Stage your changes and run aiautocommit:
+
+```
+git add .
+aiautocommit
+```
+
+## Customization
+
+### Using Config Directory
+
+aiautocommit looks for configuration files in these locations (in priority order):
+
+* .aiautocommit/ in current directory
+* $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
+* Custom path via aiautocommit_CONFIG environment variable
+
+To get started with customization:
+
+```shell
+aiautocommit dump-prompts
+```
+
+This creates a `.aiautocommit/` directory with:
+
+* `diff_prompt.txt`: Template for generating diff summaries
+* `commit_prompt.txt`: Template for generating commit messages
+* `exclusions.txt`: List of files to exclude from processing
+
+### Installing Pre-commit Hook
+
+To automatically generate commit messages during git commits:
+
+```
+aiautocommit install-pre-commit
+```
+
+### Environment Variables
+
+* `OPENAI_API_KEY`: Your OpenAI API key
+* `aiautocommit_MODEL`: AI model to use (default: gpt-4-mini)
+* `aiautocommit_CONFIG`: Custom config directory path
+* `LOG_LEVEL`: Logging verbosity
+* `aiautocommit_LOG_PATH`: Custom log file path
+
+## Privacy Disclaimer
+
+`gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.
+
+## Special Thanks
+
+[This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.
+
+## Related Projects
+
+I looked at a bunch of projects before building this one.
+
+- https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
+- https://github.com/Sett17/turboCommit - rust, inactive.
+- https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
+- https://github.com/Elhameed/aicommits - python
+- https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
+- https://github.com/ywkim/gpt-commit - lisp, inactive.
+- https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
+- https://github.com/josenerydev/gpt-commit - also python
+- https://github.com/di-sukharev/opencommit - has conventional commit structure

aiautocommit-0.6.0/README.md

@@ -0,0 +1,98 @@
+[![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# aiautocommit
+
+Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.
+
+Yes, there are a lot of these. Main ways this is different:
+
+* Simple codebase
+* Ability to easily customize prompts on a per-repo basis
+
+## Installation
+
+```shell
+pip install aiautocommit
+```
+
+## Features
+
+* Generates conventional commit messages
+* Customizable prompts and exclusions
+* Pre-commit hook integration
+* Supports custom config directories
+
+## Getting Started
+
+Set your OpenAI API key:
+
+```
+export OPENAI_API_KEY=<YOUR API KEY>
+```
+
+Stage your changes and run aiautocommit:
+
+```
+git add .
+aiautocommit
+```
+
+## Customization
+
+### Using Config Directory
+
+aiautocommit looks for configuration files in these locations (in priority order):
+
+* .aiautocommit/ in current directory
+* $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
+* Custom path via aiautocommit_CONFIG environment variable
+
+To get started with customization:
+
+```shell
+aiautocommit dump-prompts
+```
+
+This creates a `.aiautocommit/` directory with:
+
+* `diff_prompt.txt`: Template for generating diff summaries
+* `commit_prompt.txt`: Template for generating commit messages
+* `exclusions.txt`: List of files to exclude from processing
+
+### Installing Pre-commit Hook
+
+To automatically generate commit messages during git commits:
+
+```
+aiautocommit install-pre-commit
+```
+
+### Environment Variables
+
+* `OPENAI_API_KEY`: Your OpenAI API key
+* `aiautocommit_MODEL`: AI model to use (default: gpt-4-mini)
+* `aiautocommit_CONFIG`: Custom config directory path
+* `LOG_LEVEL`: Logging verbosity
+* `aiautocommit_LOG_PATH`: Custom log file path
+
+## Privacy Disclaimer
+
+`gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.
+
+## Special Thanks
+
+[This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.
+
+## Related Projects
+
+I looked at a bunch of projects before building this one.
+
+- https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
+- https://github.com/Sett17/turboCommit - rust, inactive.
+- https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
+- https://github.com/Elhameed/aicommits - python
+- https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
+- https://github.com/ywkim/gpt-commit - lisp, inactive.
+- https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
+- https://github.com/josenerydev/gpt-commit - also python
+- https://github.com/di-sukharev/opencommit - has conventional commit structure

aiautocommit-0.6.0/aiautocommit/__init__.py

@@ -0,0 +1,368 @@
+import asyncio
+import os
+import subprocess
+import sys
+import logging
+from pathlib import Path
+import click
+
+# Config file locations in priority order
+CONFIG_PATHS = [
+    Path(".aiautocommit"),  # $PWD/.aiautocommit
+    Path(os.environ.get("XDG_CONFIG_HOME", "~/.config")).expanduser()
+    / "aiautocommit",  # XDG config dir
+    Path(os.environ.get("AIAUTOCOMMIT_CONFIG", "")),  # Custom config path
+]
+
+DIFF_PROMPT_FILE = "diff_prompt.txt"
+COMMIT_PROMPT_FILE = "commit_prompt.txt"
+EXCLUSIONS_FILE = "exclusions.txt"
+
+
+MODEL_NAME = os.environ.get("AIAUTOCOMMIT_MODEL", "gpt-4o-mini")
+DIFF_PROMPT = """
+Generate a short summary of the git diffs included using these rules:
+
+* Indicate (ex: "Size: large" on the first line) if the change is large (800+ lines changes), medium (300-800 lines changed), or small (less than 300 lines changed)
+* Exclude comments or whitespace changes from the summary
+* Do not include information about modified comments
+* Omit information about renamed variables or functions
+
+Only respond with summary content.
+
+---
+"""
+# https://cbea.ms/git-commit/
+COMMIT_MSG_PROMPT = """
+Generate a commit message from the code change summaries using these rules:
+
+* No more than 50 character summary
+* Imperative mood in the subject line
+* Conventional commit format
+* When change summaries are indicated as large, include extended commit message with markdown bullets.
+  * Use the extended commit (body) to explain what and why vs. how
+* Do not wrap in a codeblock
+* Do not include generic messages without specifics such as:
+  * "Improved comments and structured logic for clarity..."
+  * "Separated logic from the original function..."
+  * "Refactored X into Y..."
+  * "Introduced new function..."
+  * "Enhances clarity and ease of use..."
+* Don't mention details which feat: update prompt text in DIFF_PROMPT variable
+* If there is not enough information to generate a summary, return an empty string
+
+Below are the change summaries:
+
+---
+"""
+EXCLUDED_FILES = [
+    "Gemfile.lock",
+    "uv.lock",
+    "poetry.lock",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "pnpm-lock.yaml",
+    "composer.lock",
+    "cargo.lock",
+    "mix.lock",
+    "Pipfile.lock",
+    "pdm.lock",
+    "flake.lock",
+    "bun.lockb",
+]
+
+PROMPT_CUTOFF = 10_000
+
+logging.basicConfig(
+    level=os.environ.get("LOG_LEVEL", "INFO").upper(),
+    **(
+        {"filename": os.environ.get("AIAUTOCOMMIT_LOG_PATH")}
+        if os.environ.get("AIAUTOCOMMIT_LOG_PATH")
+        else {"stream": sys.stderr}
+    ),
+)
+
+
+def configure_prompts(config_dir=None):
+    global DIFF_PROMPT, COMMIT_MSG_PROMPT, EXCLUDED_FILES, CONFIG_PATHS
+
+    if config_dir:
+        CONFIG_PATHS.insert(0, Path(config_dir))
+
+    # Find first existing config dir
+    config_dir = next((path for path in CONFIG_PATHS if path and path.exists()), None)
+
+    if not config_dir:
+        logging.debug("No config directory found")
+        return
+
+    logging.debug(f"Found config directory at {config_dir}")
+
+    # Load diff prompt
+    diff_file = config_dir / DIFF_PROMPT_FILE
+    if diff_file.exists():
+        logging.debug("Loading custom diff prompt from diff.txt")
+        DIFF_PROMPT = diff_file.read_text().strip()
+
+    # Load commit prompt
+    commit_file = config_dir / COMMIT_PROMPT_FILE
+    if commit_file.exists():
+        logging.debug("Loading custom commit prompt from commit.txt")
+        COMMIT_MSG_PROMPT = commit_file.read_text().strip()
+
+    # Load exclusions
+    exclusions_file = config_dir / EXCLUSIONS_FILE
+    if exclusions_file.exists():
+        logging.debug("Loading custom exclusions from exclusions.txt")
+        EXCLUDED_FILES = [
+            line.strip()
+            for line in exclusions_file.read_text().splitlines()
+            if line.strip()
+        ]
+
+
+def get_diff(ignore_whitespace=True):
+    arguments = [
+        "git",
+        "--no-pager",
+        "diff",
+        "--staged",
+    ]
+    if ignore_whitespace:
+        arguments += [
+            "--ignore-space-change",
+            "--ignore-blank-lines",
+        ]
+
+    for file in EXCLUDED_FILES:
+        arguments += [f":(exclude){file}"]
+
+    diff_process = subprocess.run(arguments, capture_output=True, text=True)
+    diff_process.check_returncode()
+    normalized_diff = diff_process.stdout.strip()
+
+    logging.debug(f"Discovered Diff:\n{normalized_diff}")
+
+    return normalized_diff
+
+
+def parse_diff(diff):
+    file_diffs = diff.split("\ndiff")
+    file_diffs = [file_diffs[0]] + [
+        "\ndiff" + file_diff for file_diff in file_diffs[1:]
+    ]
+    chunked_file_diffs = []
+    for file_diff in file_diffs:
+        [head, *chunks] = file_diff.split("\n@@")
+        chunks = ["\n@@" + chunk for chunk in reversed(chunks)]
+        chunked_file_diffs.append((head, chunks))
+    return chunked_file_diffs
+
+
+def assemble_diffs(parsed_diffs, cutoff):
+    """
+    Create multiple well-formatted diff strings, each being shorter than cutoff
+    """
+    assembled_diffs = [""]
+
+    def add_chunk(chunk):
+        if len(assembled_diffs[-1]) + len(chunk) <= cutoff:
+            assembled_diffs[-1] += "\n" + chunk
+            return True
+        else:
+            assembled_diffs.append(chunk)
+            return False
+
+    for head, chunks in parsed_diffs:
+        if not chunks:
+            add_chunk(head)
+        else:
+            add_chunk(head + chunks.pop())
+        while chunks:
+            if not add_chunk(chunks.pop()):
+                assembled_diffs[-1] = head + assembled_diffs[-1]
+    return assembled_diffs
+
+
+def asyncopenai() -> "AsyncOpenAI":
+    from openai import AsyncOpenAI
+
+    if not hasattr(asyncopenai, "_instance"):
+        # Using a class-level attribute to store the singleton instance
+        setattr(asyncopenai, "_instance", AsyncOpenAI())
+    return getattr(asyncopenai, "_instance")
+
+
+async def complete(prompt):
+    aclient = asyncopenai()
+    completion_resp = await aclient.chat.completions.create(
+        model=MODEL_NAME,
+        messages=[{"role": "user", "content": prompt[: PROMPT_CUTOFF + 100]}],
+        # TODO this seems awfully small?
+        max_tokens=128,
+    )
+    completion = completion_resp.choices[0].message.content.strip()
+    return completion
+
+
+async def summarize_diff(diff):
+    assert diff
+
+    summarized_diff = await complete(DIFF_PROMPT + "\n\n" + diff + "\n\n")
+    logging.debug(f"Summarized Diff:\n{summarized_diff}")
+    return summarized_diff
+
+
+async def summarize_summaries(summaries):
+    assert summaries
+    return await complete(COMMIT_MSG_PROMPT + "\n\n" + summaries + "\n\n")
+
+
+async def generate_commit_message(diff):
+    if not diff:
+        logging.debug("No commit message generated")
+        return ""
+
+    assembled_diffs = assemble_diffs(parse_diff(diff), PROMPT_CUTOFF)
+
+    logging.debug(f"Summarizing {len(assembled_diffs)} diffs")
+
+    summaries = await asyncio.gather(
+        *[summarize_diff(diff) for diff in assembled_diffs]
+    )
+    return await summarize_summaries("\n".join(summaries))
+
+
+def git_commit(message):
+    # will ignore message if diff is empty
+    return subprocess.run(["git", "commit", "--message", message, "--edit"]).returncode
+
+
+@click.group(invoke_without_command=True)
+def main():
+    """
+    Generate a commit message for staged files and commit them.
+    Git will prompt you to edit the generated commit message.
+    """
+    ctx = click.get_current_context()
+    if ctx.invoked_subcommand is None:
+        ctx.invoke(commit)
+
+
+@main.command()
+@click.option(
+    "-p",
+    "--print-message",
+    is_flag=True,
+    default=False,
+    help="print commit msg to stdout instead of performing commit",
+)
+@click.option(
+    "-o",
+    "--output-file",
+    type=click.Path(writable=True),
+    help="write commit message to specified file",
+)
+@click.option(
+    "--config-dir",
+    type=click.Path(exists=True, file_okay=False, dir_okay=True),
+    help="specify custom config directory",
+)
+def commit(print_message, output_file, config_dir):
+    """
+    Generate commit message from git diff.
+    """
+
+    configure_prompts(config_dir)
+
+    try:
+        if not get_diff(ignore_whitespace=False):
+            click.echo(
+                "No changes staged. Use `git add` to stage files before invoking gpt-commit.",
+                err=True,
+            )
+            return 1
+
+        # run async so when multiple chunks exist we can get summaries concurrently
+        commit_message = asyncio.run(generate_commit_message(get_diff()))
+    except UnicodeDecodeError:
+        click.echo("gpt-commit does not support binary files", err=True)
+        commit_message = (
+            # TODO use heredoc
+            "# gpt-commit does not support binary files. "
+            "Please enter a commit message manually or unstage any binary files."
+        )
+
+    if output_file:
+        if commit_message:
+            Path(output_file).write_text(commit_message)
+            return 0
+        return 1
+    elif print_message:
+        click.echo(commit_message)
+        return 0
+    else:
+        return git_commit(commit_message)
+
+
+@main.command()
+@click.option(
+    "--overwrite",
+    is_flag=True,
+    help="Overwrite existing pre-commit hook if it exists",
+)
+def install_pre_commit(overwrite):
+    """Install pre-commit script into git hooks directory"""
+    git_result = subprocess.run(
+        ["git", "rev-parse", "--git-dir"],
+        capture_output=True,
+        text=True,
+    )
+    git_result.check_returncode()
+
+    git_dir = git_result.stdout.strip()
+    hooks_dir = Path(git_dir) / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+
+    pre_commit = hooks_dir / "prepare-commit-msg"
+
+    if not pre_commit.exists() or overwrite:
+        pre_commit_script = Path(__file__).parent / "prepare-commit-msg"
+        pre_commit.write_text(pre_commit_script.read_text())
+        pre_commit.chmod(0o755)
+        click.echo("Installed pre-commit hook")
+    else:
+        click.echo(
+            "pre-commit hook already exists. Here's the contents we would have written:"
+        )
+        click.echo(pre_commit.read_text())
+
+
+@main.command()
+def dump_prompts():
+    """Dump default prompts into .aiautocommit directory for easy customization"""
+    config_dir = Path(".aiautocommit")
+    config_dir.mkdir(exist_ok=True)
+
+    diff_prompt = config_dir / DIFF_PROMPT_FILE
+    commit_prompt = config_dir / COMMIT_PROMPT_FILE
+    exclusions = config_dir / EXCLUSIONS_FILE
+
+    if not diff_prompt.exists():
+        diff_prompt.write_text(DIFF_PROMPT)
+    if not commit_prompt.exists():
+        commit_prompt.write_text(COMMIT_MSG_PROMPT)
+    if not exclusions.exists():
+        exclusions.write_text("\n".join(EXCLUDED_FILES))
+
+    click.echo(
+        """Dumped default prompts to .aiautocommit directory:
+
+- diff_prompt.txt: Template for generating diff summaries, this is passed to commit_prompt.txt
+- commit_prompt.txt: Template for generating commit messages
+- exclusions.txt: List of file patterns to exclude from processing"""
+    )

aiautocommit-0.6.0/aiautocommit.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.1
+Name: aiautocommit
+Version: 0.6.0
+Summary: AI generated commit messages
+Author-email: Michael Bianco <mike@mikebian.co>
+Project-URL: Repository, https://github.com/iloveitaly/aiautocommit
+Keywords: git,commit,automation,ai,openai
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.7
+Requires-Dist: openai>=1.54.3
+
+[![Release Notes](https://img.shields.io/github/release/iloveitaly/aiautocommit)](https://github.com/iloveitaly/aiautocommit/releases) [![Downloads](https://static.pepy.tech/badge/aiautocommit/month)](https://pepy.tech/project/aiautocommit) [![Python Versions](https://img.shields.io/pypi/pyversions/aiautocommit)](https://pypi.org/project/aiautocommit) ![GitHub CI Status](https://github.com/iloveitaly/aiautocommit/actions/workflows/build_and_publish.yml/badge.svg) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# aiautocommit
+
+Generate intelligent commit messages using AI. aiautocommit analyzes your staged changes and creates conventional commit messages, handling both small tweaks and large changesets effectively.
+
+Yes, there are a lot of these. Main ways this is different:
+
+* Simple codebase
+* Ability to easily customize prompts on a per-repo basis
+
+## Installation
+
+```shell
+pip install aiautocommit
+```
+
+## Features
+
+* Generates conventional commit messages
+* Customizable prompts and exclusions
+* Pre-commit hook integration
+* Supports custom config directories
+
+## Getting Started
+
+Set your OpenAI API key:
+
+```
+export OPENAI_API_KEY=<YOUR API KEY>
+```
+
+Stage your changes and run aiautocommit:
+
+```
+git add .
+aiautocommit
+```
+
+## Customization
+
+### Using Config Directory
+
+aiautocommit looks for configuration files in these locations (in priority order):
+
+* .aiautocommit/ in current directory
+* $XDG_CONFIG_HOME/aiautocommit/ (defaults to ~/.config/aiautocommit/)
+* Custom path via aiautocommit_CONFIG environment variable
+
+To get started with customization:
+
+```shell
+aiautocommit dump-prompts
+```
+
+This creates a `.aiautocommit/` directory with:
+
+* `diff_prompt.txt`: Template for generating diff summaries
+* `commit_prompt.txt`: Template for generating commit messages
+* `exclusions.txt`: List of files to exclude from processing
+
+### Installing Pre-commit Hook
+
+To automatically generate commit messages during git commits:
+
+```
+aiautocommit install-pre-commit
+```
+
+### Environment Variables
+
+* `OPENAI_API_KEY`: Your OpenAI API key
+* `aiautocommit_MODEL`: AI model to use (default: gpt-4-mini)
+* `aiautocommit_CONFIG`: Custom config directory path
+* `LOG_LEVEL`: Logging verbosity
+* `aiautocommit_LOG_PATH`: Custom log file path
+
+## Privacy Disclaimer
+
+`gpt-commit` uses the [OpenAI API](https://platform.openai.com/docs) to generate commit messages. Both file names and contents from files that contain staged changes will be shared with OpenAI when using `gpt-commit`. OpenAI will process this data according to their [terms of use](https://openai.com/policies/terms-of-use) and [API data usage policies](https://openai.com/policies/api-data-usage-policies). On March 1st 2023 OpenAI pledged that by default, they would not use data submitted by customers via their API to train or improve their models, and that this data will be retained for a maximum of 30 days, after which it will be deleted.
+
+## Special Thanks
+
+[This project](https://github.com/markuswt/gpt-commit) inspired this project. It had a very simple codebase. I've taken the idea and expanded it to include a lot more features, specifically per-project prompt customization.
+
+## Related Projects
+
+I looked at a bunch of projects before building this one.
+
+- https://github.com/abi/aiautocommit - python, inactive. Many files, not simple.
+- https://github.com/Sett17/turboCommit - rust, inactive.
+- https://github.com/Nutlope/aicommits - typescript. Node is so slow and I hate working with it.
+- https://github.com/Elhameed/aicommits - python
+- https://github.com/zurawiki/gptcommit - active, rust. Too complicated and no prompt customization.
+- https://github.com/ywkim/gpt-commit - lisp, inactive.
+- https://github.com/markuswt/gpt-commit - single file, python based. No commits > 1yr. Very simple codebase.
+- https://github.com/josenerydev/gpt-commit - also python
+- https://github.com/di-sukharev/opencommit - has conventional commit structure

aiautocommit-0.6.0/aiautocommit.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+aiautocommit/__init__.py
+aiautocommit.egg-info/PKG-INFO
+aiautocommit.egg-info/SOURCES.txt
+aiautocommit.egg-info/dependency_links.txt
+aiautocommit.egg-info/entry_points.txt
+aiautocommit.egg-info/requires.txt
+aiautocommit.egg-info/top_level.txt

aiautocommit-0.6.0/aiautocommit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aiautocommit-0.6.0/aiautocommit.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aiautocommit = aiautocommit:main

aiautocommit-0.6.0/aiautocommit.egg-info/requires.txt

@@ -0,0 +1,2 @@
+click>=8.1.7
+openai>=1.54.3

aiautocommit-0.6.0/aiautocommit.egg-info/top_level.txt

@@ -0,0 +1 @@
+aiautocommit

aiautocommit-0.6.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "aiautocommit"
+version = "0.6.0"
+description = "AI generated commit messages"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["click>=8.1.7", "openai>=1.54.3"]
+authors = [{ name = "Michael Bianco", email = "mike@mikebian.co" }]
+keywords = ["git", "commit", "automation", "ai", "openai"]
+urls = { "Repository" = "https://github.com/iloveitaly/aiautocommit" }
+
+[project.scripts]
+aiautocommit = "aiautocommit:main"
+
+# https://github.com/astral-sh/uv/issues/5200
+[tool.uv]
+package = true

aiautocommit-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+