gptcomet 0.0.2__py3-none-any.whl

gptcomet/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.0.2"
+
+from gptcomet.cli import cli
+
+if __name__ == "__main__":
+    cli()

gptcomet/_types.py

@@ -0,0 +1,24 @@
+import typing as t
+
+import tomlkit
+
+# Config class types
+CacheKeys = t.Literal["default_config", "config"]
+
+
+class CacheType(t.TypedDict):
+    default_config: t.Optional[tomlkit.TOMLDocument]
+    config: t.Optional[tomlkit.TOMLDocument]
+
+
+class CompleteParams(t.TypedDict):
+    api_base: str
+    api_key: str
+    model: str
+    retries: int
+    messages: t.Union[list[dict], None, list]
+    max_tokens: t.Optional[int]
+    temperature: t.Optional[float]
+    top_p: t.Optional[float]
+    frequency_penalty: t.Optional[float]
+    extra_headers: t.Optional[dict]

gptcomet/cli.py

@@ -0,0 +1,300 @@
+import logging
+import sys
+
+import click
+from click import Context
+from git import InvalidGitRepositoryError, NoSuchPathError
+
+import gptcomet
+from gptcomet.config_manager import ConfigManager
+from gptcomet.exceptions import ConfigKeyError, GitNoStagedChanges, KeyNotFound
+from gptcomet.hook import AICommitHook
+from gptcomet.message_generator import MessageGenerator
+from gptcomet.utils import common_options
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(
+    format="%(asctime)s [%(levelname)s] %(filename)s::%(funcName)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    level=logging.WARNING,
+)
+
+
+@click.group(
+    name="gptcomet",
+    help="AI-Powered Git Commit Message Generator",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.pass_context
+@common_options
+@click.version_option(
+    gptcomet.__version__,
+    "--version",
+    "-v",
+    prog_name="gptcomet",
+    message="%(prog)s: %(version)s",
+)
+def cli(ctx: Context, debug, local):
+    """GPTComet CLI"""
+    if debug:
+        logger.setLevel(logging.DEBUG)
+    else:
+        logger.setLevel(logging.INFO)
+    logger.debug(f"Running with debug={debug}, local={local}")
+
+    ctx.obj["debug"] = debug
+    ctx.obj["local"] = local
+    ctx.obj["config_manager"] = None
+
+
+config: click.Group  # type hints for IDE
+
+@cli.group(name="config")
+@click.pass_context
+@common_options
+def config(ctx, debug, local):
+    """Manage gptcomet configuration."""
+    logger.debug(f"Config manage, local={local}")
+    if not ctx.obj["config_manager"]:
+        ctx.obj["config_manager"] = ConfigManager(ctx.obj["local"])
+
+
+@config.command("set", help="Set a configuration value.")
+@click.argument("key")
+@click.argument("value")
+@click.pass_context
+@common_options
+def config_set(ctx: Context, key, value, debug, local):
+    """Set a configuration value."""
+    try:
+        ctx.obj["config_manager"].set(key, value)
+        click.echo(
+            f"[GPTComet] Set {click.style(key, fg='green')} to {click.style(value, fg='green')}."
+        )
+    except ConfigKeyError as e:
+        click.echo(f"[GPTComet] Error: {e!s}")
+
+
+@config.command("get")
+@click.argument("key")
+@click.pass_context
+@common_options
+def config_get(ctx, key, debug, local):
+    """Get a configuration value."""
+    try:
+        value = ctx.obj["config_manager"].get(key)
+        click.echo(f"{key}: {value}")
+    except ValueError as e:
+        click.echo(f"Error: {e!s}")
+    except ConfigKeyError as e:
+        click.echo(str(e))
+
+
+@config.command("list")
+@click.pass_context
+@common_options
+def config_list(ctx: Context, debug, local):
+    """List all configuration values."""
+    click.echo(
+        click.style("Current configuration:\n", fg="green") + ctx.obj["config_manager"].list()
+    )
+
+
+@config.command("reset")
+@click.pass_context
+@common_options
+def reset(ctx: Context, debug, local):
+    """Reset configuration to default values."""
+    ctx.obj["config_manager"].reset()
+    click.echo("Configuration reset to default values")
+
+
+@config.command(name="keys")
+@click.pass_context
+@common_options
+def config_keys(ctx, debug, local):
+    cfg_manager: ConfigManager = ctx.obj["config_manager"]
+    keys = cfg_manager.list_keys()
+    click.echo(click.style("Supported keys:\n", fg="green") + keys)
+
+
+@config.command("path")
+@click.pass_context
+@common_options
+def config_path(ctx: Context, debug, local):
+    """Get the path to the configuration file."""
+    click.echo(
+        click.style("Current configuration path:\n", fg="green")
+        + ctx.obj["config_manager"].current_config_path.as_posix()
+    )
+
+
+hook: click.Group  # type hints for IDE
+
+
+@cli.group("hook", help="Manage GPTComet prepare-commit-msg hook.")
+@common_options
+@click.pass_context
+def hook(ctx: click.Context, debug, local):
+    pass
+
+
+@hook.command("install", help="Install GPTComet prepare-commit-msg hook to current repository.")
+@click.option(
+    "--force/--no-force",
+    "-f/-nf",
+    default=False,
+    help="Force installation or not.",
+    show_default=True,
+)
+@common_options
+@click.pass_context
+def install_hook(ctx, debug, local, force=False):
+    """Install GPTComet prepare-commit-msg hook."""
+    try:
+        comet_hook = AICommitHook()
+        if comet_hook.is_hook_installed() and not force:
+            click.echo(
+                "GPTComet prepare-commit-msg hook is already installed, use --force to force installation."
+            )
+            return
+        comet_hook.install_hook()
+        click.echo("GPTComet prepare-commit-msg hook has been installed successfully.")
+    except InvalidGitRepositoryError as e:
+        click.echo(f"Error: {e!s}")
+    except Exception as e:
+        click.echo(f"An error occurred while installing the hook: {e!s}")
+
+
+@hook.command("uninstall", help="Uninstall GPTComet prepare-commit-msg hook from current repository.")
+@common_options
+@click.pass_context
+def uninstall_hook(ctx: click.Context, debug, local, **kwargs):
+    """Uninstall GPTComet prepare-commit-msg hook."""
+    try:
+        comet_hook = AICommitHook()
+        comet_hook.uninstall_hook()
+    except (InvalidGitRepositoryError, NoSuchPathError) as e:
+        click.echo(f"Error: {e!s}")
+    except Exception as e:
+        click.echo(f"An error occurred while uninstalling the hook: {e!s}")
+
+
+@hook.command("status")
+def hook_status():
+    """Check if GPTComet prepare-commit-msg hook is installed."""
+    try:
+        comet_hook = AICommitHook()
+        if comet_hook.is_hook_installed():
+            click.echo("GPTComet prepare-commit-msg hook is installed.")
+        else:
+            click.echo(
+                f"GPTComet prepare-commit-msg hook is {click.style('not', fg='yellow')} installed."
+            )
+    except InvalidGitRepositoryError as e:
+        click.echo(f"Error: {e!s}")
+    except Exception as e:
+        click.echo(f"An error occurred while checking the hook status: {e!s}")
+
+
+generate: click.Group  # type hints for IDE
+
+
+@cli.group("generate", help="Generate a commit message based on `git diff --staged`.")
+@click.pass_context
+@common_options
+def generate(ctx: click.Context, debug, local):
+    ctx.obj["config_manager"] = ConfigManager(ctx.obj["local"])
+
+
+@generate.command("commit")
+# @click.option("--rich", is_flag=True, default=False, help="Generate rich commit message")
+@common_options
+@click.pass_context
+def generate_commit(ctx: click.Context, debug, local, rich=False, **kwargs):
+    """Generate a commit message based on git diff"""
+    click.echo(
+        click.style(
+            "🤖 Hang tight! I'm having a chat with the AI to craft your commit message...",
+            fg="green",
+        )
+    )
+    config_manager = ctx.obj["config_manager"]
+    message_generator = MessageGenerator(config_manager)
+    retry = True
+    commit_msg = None
+    while retry:
+        try:
+            commit_msg = message_generator.generate_commit_message(rich)
+        except KeyNotFound as e:
+            click.echo(f"Error: {e!s}, please check your configuration.")
+            raise click.Abort() from None
+        except GitNoStagedChanges as e:
+            click.echo(str(e))
+            raise click.Abort() from None
+
+        if commit_msg is None:
+            click.echo(click.style("No commit message generated.", fg="magenta"))
+            return
+
+        click.echo(click.style("Generated commit message:", fg="green"))
+        click.echo(commit_msg)
+
+        if sys.stdin.isatty():
+            # Interactive mode will ask for confirmation
+            char = click.prompt(
+                click.style(
+                    "Do you want to use this commit message? y: yes, n: no, r: retry.", fg="green"
+                ),
+                default="y",
+                type=click.Choice(["y", "n", "r"]),
+            )
+        else:
+            click.echo(
+                click.style(
+                    "Non-interactive mode detected, using the generated commit message directly.",
+                    fg="yellow",
+                )
+            )
+            char = "y"
+
+        if char == "n":
+            click.echo(click.style("Commit message discarded.", fg="yellow"))
+            return
+        elif char == "y":
+            retry = False
+        logger.debug(f"Input: {char}")
+        if char == "n":
+            click.echo(click.style("Commit message discarded.", fg="yellow"))
+            return
+        elif char == "y":
+            retry = False
+
+    message_generator.repo.index.commit(commit_msg)
+    click.echo(click.style("Commit message saved.", fg="green"))
+
+
+@click.command()
+@click.pass_context
+def generate_prmsg(ctx: click.Context, debug, local):
+    """Generate a pull request message based on changes compared to master"""
+    config_manager = ctx.obj["config_manager"]
+    message_generator = MessageGenerator(config_manager)
+
+    pr_msg = message_generator.generate_pr_message()
+
+    click.echo("Generated pull request message:")
+    click.echo(pr_msg)
+
+    if click.confirm("Do you want to use this pull request message?"):
+        # Here you could integrate with your Git hosting platform's API
+        # to create a pull request with this message
+        click.echo(
+            "Pull request message saved. You can now use it to create a PR on your Git hosting platform."
+        )
+    else:
+        click.echo("Pull request message discarded.")
+
+
+if __name__ == "__main__":
+    cli()

gptcomet/config_manager.py

@@ -0,0 +1,296 @@
+import logging
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import click
+import tomlkit as toml
+from tomlkit import TOMLDocument, boolean, float_, integer, string
+from tomlkit.items import Item
+
+from gptcomet._types import CacheType
+from gptcomet.exceptions import KeyNotFound
+from gptcomet.support_keys import SUPPORT_KEYS
+from gptcomet.utils import is_float
+
+logger = logging.getLogger(__name__)
+
+
+class ConfigManager:
+    __slots__ = (
+        "local",
+        "global_config_file",
+        "default_config_file",
+        "current_config_path",
+        "_cache",
+        "_valid_keys"
+    )
+    local: bool
+    global_config_file: Path
+    default_config_file: Path
+    config: TOMLDocument
+    current_config_path: Path
+    _cache: CacheType
+    _valid_keys: set[str]
+
+    def __init__(self, local: bool = False):
+        self.local: bool = local
+        self.global_config_file: Path = Path.home() / ".local" / "gptcomet" / "gptcomet.toml"
+        self.default_config_file: Path = Path(__file__).parent / "gptcomet.toml"
+        # runtime config file
+        self.current_config_path = self.get_config_file()
+
+        self._cache: CacheType = {"config": None, "default_config": None}
+        self._valid_keys: set[str] = set(SUPPORT_KEYS.splitlines())
+
+    @property
+    def config(self):
+        """
+        Returns the configuration stored in the cache.
+
+        If the configuration is not already loaded, it is loaded by calling the
+        `load_config` method and stored in the cache.
+
+        Returns:
+            The configuration stored in the cache.
+        """
+        if "config" not in self._cache or self._cache["config"] is None:
+            self._cache["config"] = self.load_config()
+        return self._cache["config"]
+
+    @property
+    def default_config(self) -> toml.TOMLDocument:
+        """
+        Returns the default configuration stored in the cache.
+
+        If the default configuration is not already loaded, it is loaded by calling the
+        `load_default_config` method and stored in the cache.
+
+        Returns:
+            The default configuration stored in the cache.
+        """
+        if "default_config" not in self._cache or self._cache["default_config"] is None:
+            self._cache["default_config"] = self.load_default_config()
+        return self._cache["default_config"]
+
+    def get_config_file(self) -> Path:
+        """
+        Retrieves the path to the configuration file.
+
+        If local is True, checks if the current directory is a git repository
+        and returns the path to .git/gptcomet.toml if it is, otherwise returns
+        the global configuration file path.
+
+        Returns:
+            Path: The path to the configuration file.
+        """
+        config_path = self.global_config_file
+        if self.local:
+            cwd = Path.cwd()
+            if not (cwd / ".git").exists():
+                click.echo(f"[{click.style('GPTComet', fg='green')}] Not a git repository. Using global config.")
+            else:
+                config_path = cwd / ".git" / "gptcomet.toml"
+        # click.echo(f"[GPTComet] Using config file: {config_path}")
+        return config_path
+
+    def ensure_config_file(self):
+        """
+        Ensures that the configuration file exists by creating it with default values if it does not already exist.
+        """
+        config_file = self.current_config_path
+        if not config_file.exists():
+            config_file.parent.mkdir(parents=True, exist_ok=True)
+            with open(self.default_config_file) as default, open(config_file, "w") as target:
+                target.write(default.read())
+            click.echo(f"[{click.style('GPTComet', fg='green')}] Created default config file at {config_file}")
+
+    def load_config(self) -> toml.TOMLDocument:
+        """
+        Load the configuration from the current configuration file.
+
+        Returns:
+            toml.TOMLDocument: The configuration loaded from the current configuration file.
+
+        """
+        self.ensure_config_file()
+        with open(self.current_config_path) as f:
+            return toml.load(f)
+
+    def load_default_config(self) -> toml.TOMLDocument:
+        """
+        Load the default configuration from the default configuration file.
+
+        Returns:
+            toml.TOMLDocument: The default configuration loaded from the file.
+        """
+        with open(self.default_config_file) as f:
+            return toml.load(f)
+
+    def save_config(self):
+        """
+        Saves the current configuration to a file.
+        Returns:
+            None
+        """
+        with self.current_config_path.open("w") as f:
+            f.write(self.config.as_string())
+
+    def is_valid_key(self, key: str) -> bool:
+        """
+        Check if the given key is a valid key in the current configuration.
+
+        Args:
+            key (str): The key to be checked.
+
+        Returns:
+            bool: True if the key is valid, False otherwise.
+        """
+        return key in self._valid_keys
+
+    def get_nested_value(self, doc: Union[dict, toml.TOMLDocument], keys: Union[str, list[str]]) -> Any:
+        """
+        Get the nested value from a dictionary or TOML document using a list of keys.
+
+        Args:
+            doc (Union[dict, toml.TOMLDocument]): The dictionary or TOML document to retrieve the nested value from.
+            keys (Union[str, List[str]]): The list of keys to navigate through the document.
+
+        Returns:
+            Any: The nested value if found, None otherwise.
+        """
+        if isinstance(keys, str):
+            keys = keys.split(".")
+        for key in keys:
+            if isinstance(doc, dict):
+                doc = doc.get(key)
+            else:
+                raise KeyNotFound(key)
+        return doc
+
+    def set_nested_value(self, doc: TOMLDocument, keys: Union[str, list[str]], value: Any):
+        """
+        Set a nested value in a dictionary using a list of keys.
+
+        Args:
+            doc (TOMLDocument): The dictionary to modify.
+            keys (Union[str, List[str]]): The list of keys to navigate through the dictionary.
+            value (Any): The value to set at the end of the nested keys.
+
+        It navigates through the dictionary using the keys and sets the value at the end of the nested keys.
+        If any key in the path does not exist, it creates a new dictionary at that key.
+
+        Example:
+            >>> config = ConfigManager()
+            >>> d = {'a': {'b': {'c': 1}}}
+            >>> config.set_nested_value(doc, ['a', 'b', 'c'], 2)
+            >>> doc
+            {'a': {'b': {'c': 2}}}
+
+        Note:
+            This function modifies the input dictionary `d` in-place.
+        """
+        if isinstance(keys, str):
+            keys = keys.split(".")
+        for key in keys[:-1]:
+            doc = doc.setdefault(key, {})
+        doc[keys[-1]] = value
+
+    def set(self, key: str, value: str):
+        """
+        Set the value of a configuration key.
+
+        Args:
+            key (str): The key to set the value for.
+            value (str): The value to set.
+
+        Raises:
+            ConfigKeyError: If the key is not supported.
+
+        This method sets the value of a configuration key in the `config` attribute of the `ConfigManager` object.
+        It first checks if the key is valid using the `is_valid_key` method. If the key is not valid, it raises a
+        `ConfigKeyError` with the invalid key.
+
+        Note:
+            This method modifies the toml `config` attribute in-place.
+        """
+        toml_value: Item = self.convert2toml_value(value)
+        self.set_nested_value(self.config, key, toml_value)
+        self.save_config()
+
+    def get(self, key: str, default: Optional[Any] = None) -> Any:
+        """
+        Retrieves the value associated with the given key from the configuration.
+
+        Args:
+            key (str): The key to retrieve the value for.
+            default (Optional[str]): The default value to return if the key is not found.
+
+        Returns:
+            Any: The value associated with the given key.
+
+        Raises:
+            KeyNotSupportError: If the key is not supported.
+            ConfigKeyError: If the key does not exist in the configuration.
+
+        Note:
+            This method assumes that the `config` attribute of the `ConfigManager` object is a nested dictionary
+            structure with keys separated by dots.
+        """
+        try:
+            return self.get_nested_value(self.config, key)
+        except KeyNotFound:
+            return default
+
+    def list(self) -> str:
+        """
+        Reads the contents of the current configuration file and returns them as a string.
+
+        Returns:
+            str: The contents of the current configuration file.
+
+        Raises:
+            FileNotFoundError: If the current configuration file does not exist.
+        Note:
+            This method assumes that `self.current_config_path` is a valid file path.
+
+        """
+        with self.current_config_path.open() as f:
+            return f.read()
+
+    def reset(self):
+        """
+        Resets the current configuration to its default state.
+        """
+        with open(self.default_config_file) as default, open(self.current_config_path, "w") as target:
+            content = default.read()
+            target.write(content)
+        self._cache["config"] = toml.loads(content)
+
+    def list_keys(self) -> str:
+        """
+        Returns a list of supported keys.
+        Returns:
+            str: A list of supported keys.
+        """
+        return SUPPORT_KEYS
+
+    def convert2toml_value(self, value: str) -> Item:
+        """
+        Converts a string value to a TOML-compatible value.
+
+        Args:
+            value (str): The string value to be converted.
+
+        Returns:
+            Item: The converted TOML value or the original string value.
+        """
+        if value.lower() in ("true", "false"):
+            return boolean(value.lower())
+        elif value.isnumeric():
+            return integer(value)
+        elif value.lower() in ("none", "null"):
+            return string(value, literal=True)
+        elif is_float(value):
+            return float_(value)
+        else:
+            return string(value)

gptcomet/const.py

@@ -0,0 +1,37 @@
+DEFAULT_API_BASE = "https://api.openai.com/v1"
+DEFAULT_MODEL = "gpt-3.5-turbo"
+DEFAULT_RETRIES = 2
+
+SUPPORTED_LANG = ["en", "zh"]
+
+SHORT_PREPARE_COMMIT_MSG = """\
+#!/bin/sh
+# GPTComet pre-commit hook
+
+# Run GPTComet commit
+gptcomet generate commit
+
+# If GPTComet commit was successful, exit with 0
+if [ $? -eq 0 ]; then
+    exit 0
+else
+    echo "GPTComet commit failed. Please review your changes and try again."
+    exit 1
+fi
+"""
+
+RICH_PREPARE_COMMIT_MSG = """\
+#!/bin/sh
+# GPTComet pre-commit hook
+
+# Run GPTComet commit
+gptcomet generate commit --rich
+
+# If GPTComet commit was successful, exit with 0
+if [ $? -eq 0 ]; then
+    exit 0
+else
+    echo "GPTComet commit failed. Please review your changes and try again."
+    exit 1
+fi
+"""