git-cai-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/.linters/.pylintrc

@@ -68,16 +68,16 @@ check-protected-access-in-special-methods=no
 [DESIGN]
 max-args=10                                # Max arguments per function
 max-attributes=7                           # Max attributes per class
-max-branches=12                            # Max branches per function
+max-branches=20                            # Max branches per function
 max-locals=30                              # Max locals per function
-max-returns=6                              # Max return statements per function
-max-statements=50                          # Max total statements per function
+max-returns=10                             # Max return statements per function
+max-statements=60                          # Max total statements per function
 max-public-methods=20                      # Max public methods per class
 min-public-methods=1                       # Min public methods per class
 max-nested-blocks=15                       # Max nesting depth
 max-bool-expr=15                           # Max boolean subexpressions in a condition
 max-parents=7                              # Max base classes per class
-max-positional-arguments=10                 # Max positional arguments per function
+max-positional-arguments=10                # Max positional arguments per function
 
 [EXCEPTIONS]
 overgeneral-exceptions=builtins.BaseException,builtins.Exception

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-cai-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Use LLM to create git commit messages
 Author-email: Thorsten Foltz <thorsten.foltz@live.com>
 License: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Version Control
 Requires-Python: >=3.10
@@ -64,6 +65,7 @@ Currently, the only supported backends are the OpenAI and Gemini APIs, but addit
 - Generates meaningful, context-aware commit messages using an LLM
 - Seamless integration with Git as a plugin/extension
 - Supports different LLM models and languages for each repository, as well as global configuration
+- Allows to squash all commits in a branch and summarizes the commit messages
 
 <h2 id="installation-section">Installation</h2>
 
@@ -89,7 +91,10 @@ Once installed, cai works like a standard Git command:
 git cai
 ```
 
-`cai` uses Git’s `diff` output as input for generating commit messages.  
+`cai` uses Git’s `diff` output to generate commit messages. The generated message is then opened in your editor, allowing you to review and edit it before confirming the commit.  
+
+In short: it behaves like `git commit`, but the commit message is pre-filled for you.
+
 To exclude specific files or directories from being included in the generated commit message, create a `.caiignore` file in the root of your repository. This file works like a `.gitignore`.  
 
 - Files listed in `.gitignore` are **always excluded**.  
@@ -133,10 +138,11 @@ Currently, the following options can be customized:
 Besides running `git cai` to generate commit messages, you can use the following options:
 
 - `-h` shows a brief help message with available commands
-- `d`, `--debug` enables debug logging to help troubleshoot issues
-- `l`, `--languages` list available languages
-- `u`, `--update` checks for updates the `cai` tool
-- `v`, `--version` displays the currently installed version
+- `-d`, `--debug` enables debug logging to help troubleshoot issues
+- `-l`, `--languages` list available languages
+- `-s`, `--squash` Squash commits on this branch and summarize them
+- `-u`, `--update` checks for updates the `cai` tool
+- `-v`, `--version` displays the currently installed version
 
 <h2 id="license-section">License</h2>
 This project is licensed under the MIT License.

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/README.md

@@ -35,6 +35,7 @@ Currently, the only supported backends are the OpenAI and Gemini APIs, but addit
 - Generates meaningful, context-aware commit messages using an LLM
 - Seamless integration with Git as a plugin/extension
 - Supports different LLM models and languages for each repository, as well as global configuration
+- Allows to squash all commits in a branch and summarizes the commit messages
 
 <h2 id="installation-section">Installation</h2>
 
@@ -60,7 +61,10 @@ Once installed, cai works like a standard Git command:
 git cai
 ```
 
-`cai` uses Git’s `diff` output as input for generating commit messages.  
+`cai` uses Git’s `diff` output to generate commit messages. The generated message is then opened in your editor, allowing you to review and edit it before confirming the commit.  
+
+In short: it behaves like `git commit`, but the commit message is pre-filled for you.
+
 To exclude specific files or directories from being included in the generated commit message, create a `.caiignore` file in the root of your repository. This file works like a `.gitignore`.  
 
 - Files listed in `.gitignore` are **always excluded**.  
@@ -104,10 +108,11 @@ Currently, the following options can be customized:
 Besides running `git cai` to generate commit messages, you can use the following options:
 
 - `-h` shows a brief help message with available commands
-- `d`, `--debug` enables debug logging to help troubleshoot issues
-- `l`, `--languages` list available languages
-- `u`, `--update` checks for updates the `cai` tool
-- `v`, `--version` displays the currently installed version
+- `-d`, `--debug` enables debug logging to help troubleshoot issues
+- `-l`, `--languages` list available languages
+- `-s`, `--squash` Squash commits on this branch and summarize them
+- `-u`, `--update` checks for updates the `cai` tool
+- `-v`, `--version` displays the currently installed version
 
 <h2 id="license-section">License</h2>
 This project is licensed under the MIT License.

git_cai_cli-0.3.0/archlinux/.SRCINFO

@@ -0,0 +1,21 @@
+pkgbase = git-cai-cli
+	pkgdesc = Use LLM to create git commit messages.
+	pkgver = 0.2.0
+	pkgrel = 1
+	url = https://github.com/thorstenfoltz/cai
+	arch = any
+	license = MIT
+	makedepends = python-build
+	makedepends = python-installer
+	makedepends = python-setuptools
+	makedepends = python-wheel
+	depends = python
+	depends = python-yaml
+	depends = python-openai
+	depends = python-google-genai
+	depends = python-requests
+	depends = python-typer
+	source = https://files.pythonhosted.org/packages/bf/df/cc0dce84bc5aea242012f15782abcc58e60e99113e91602011c33d3a8d91/git_cai_cli-0.2.0.tar.gz
+	sha256sums = 83a6fba3f0ac729c8cf2453abba96b37c60ff7ea8d309704c613258544687635
+
+pkgname = git-cai-cli

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/archlinux/PKGBUILD

@@ -1,15 +1,15 @@
 # Maintainer: Thorsten Foltz <thorsten.foltz@live.com>
 pkgname=git-cai-cli
-pkgver=0.1.1
+pkgver=0.2.1
 pkgrel=1
 pkgdesc="Use LLM to create git commit messages."
 arch=('any')
 url="https://github.com/thorstenfoltz/cai"
 license=('MIT')
-depends=('python' 'python-yaml' 'python-openai' 'python-google-genai')
+depends=('python' 'python-yaml' 'python-openai' 'python-google-genai' 'python-requests' 'python-typer')
 makedepends=(python-build python-installer python-setuptools python-wheel)
-source=("https://files.pythonhosted.org/packages/e6/c3/99bb2d87c16628017468c9ae6dd18ee2e63644109150bee0450a9f22b83f/git_cai_cli-0.1.1.tar.gz")
-sha256sums=('36fb55223ad430b7d3dc6bf60fd4e04f6ac567acee5546d5aa8c2df781061461')
+source=("https://files.pythonhosted.org/packages/2d/f4/90663c50a4fe47d5b5b17c7d9bda3bdf6ac620d8bcae390b9eb449dc962c/git_cai_cli-0.2.1.tar.gz")
+sha256sums=('3803b4eff03763cd41deddf59d3d039a540c6492aaaf38aa1cd3959254609d3e')
 
 build() {
     cd "${srcdir}/git_cai_cli-${pkgver}"

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/pyproject.toml

@@ -23,6 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Version Control",
 ]

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli/cli.py

@@ -3,13 +3,16 @@ Main function
 """
 
 import logging
-import subprocess
 import sys
 from pathlib import Path
 
 import typer
 from git_cai_cli.core.config import get_default_config, load_config, load_token
-from git_cai_cli.core.gitutils import find_git_root, git_diff_excluding
+from git_cai_cli.core.gitutils import (
+    commit_with_edit_template,
+    find_git_root,
+    git_diff_excluding,
+)
 from git_cai_cli.core.llm import CommitMessageGenerator
 from git_cai_cli.core.options import CliManager
 
@@ -63,7 +66,7 @@ def main() -> None:
     commit_message = generator.generate(diff)
 
     # Open git commit editor with the generated message
-    subprocess.run(["git", "commit", "--edit", "-m", commit_message], check=True)
+    commit_with_edit_template(commit_message)
 
 
 @app.command()
@@ -75,6 +78,13 @@ def run(
     language: bool = typer.Option(
         False, "--languages", "-l", help="List supported languages", is_eager=True
     ),
+    squash: bool = typer.Option(
+        False,
+        "--squash",
+        "-s",
+        help="Squash commits on this branch and summarize them",
+        is_eager=True,
+    ),
     update: bool = typer.Option(
         False, "--update", "-u", help="Check for updates", is_eager=True
     ),
@@ -90,10 +100,13 @@ def run(
         raise typer.Exit()
 
     if enable_debug:
-        typer.echo(manager.enable_debug())
+        manager.enable_debug()
 
     if language:
         typer.echo(manager.print_available_languages())
+
+    if squash:
+        manager.squash_branch()
         raise typer.Exit()
 
     if update:

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli/core/config.py

@@ -157,7 +157,7 @@ def get_default_config() -> str:
         raise KeyError(f"'default' key not found in {config_path}")
 
     default_value = config["default"]
-    log.info("Default config value: %s", default_value)
+    log.info("Using provider: %s", default_value)
     return default_value
 
 

git_cai_cli-0.3.0/src/git_cai_cli/core/gitutils.py

@@ -0,0 +1,156 @@
+"""
+Check git repo and run git diff
+"""
+
+import hashlib
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Callable
+
+log = logging.getLogger(__name__)
+
+
+def find_git_root(
+    run_cmd: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+) -> Path | None:
+    """Returns the root directory of the current Git repository, or None if not in a Git repo."""
+    try:
+        result = run_cmd(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except subprocess.CalledProcessError:
+        return None
+
+
+def git_diff_excluding(
+    repo_root: Path,
+    run_cmd: Callable[..., subprocess.CompletedProcess] = subprocess.run,
+    exit_func: Callable[[int], None] = sys.exit,
+) -> str:
+    """Run `git diff` excluding files listed in .caiignore."""
+    ignore_file = repo_root / ".caiignore"
+
+    exclude_files: list[str] = []
+    if ignore_file.exists():
+        with open(ignore_file, "r", encoding="utf-8") as f:
+            exclude_files = [
+                line.strip()
+                for line in f
+                if line.strip() and not line.strip().startswith("#")
+            ]
+        if not exclude_files:
+            log.info("%s is empty. No files excluded.", ignore_file)
+
+    cmd = ["git", "diff", "--cached", "--", "."]
+    cmd.extend(f":!{pattern}" for pattern in exclude_files)
+
+    result = run_cmd(cmd, capture_output=True, text=True, check=True)
+    if result.returncode != 0:
+        log.error("git diff failed: %s", result.stderr.strip())
+        exit_func(1)
+
+    return result.stdout
+
+
+def _has_upstream() -> bool:
+    try:
+        subprocess.check_output(
+            ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+def get_git_editor() -> str:
+    """Return the editor git would use (GIT_EDITOR, core.editor, VISUAL, EDITOR, fallback)."""
+    # Ask git for its editor; falls back if git returns nothing or error
+    try:
+        p = subprocess.run(
+            ["git", "var", "GIT_EDITOR"], capture_output=True, text=True, check=True
+        )
+        editor = p.stdout.strip()
+        if editor:
+            return editor
+    except subprocess.CalledProcessError:
+        pass
+
+    # fallback lookup similar to git's precedence
+    for env in ("GIT_EDITOR", "VISUAL", "EDITOR"):
+        val = os.environ.get(env)
+        if val:
+            return val
+
+    return shutil.which("vi") or shutil.which("nano") or "vi"
+
+
+def sha256_of_file(path: Path) -> str:
+    """Compute SHA256 hash of a file."""
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        while True:
+            chunk = f.read(8192)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def commit_with_edit_template(commit_message: str) -> int:
+    """Open git commit editor with a pre-filled commit message template."""
+    # create temp file with initial message
+    with tempfile.NamedTemporaryFile("w", delete=False, encoding="utf-8") as tf:
+        tf.write(commit_message)
+        tf.flush()
+        tf_name = Path(tf.name)
+
+    try:
+        original_hash = sha256_of_file(tf_name)
+
+        editor = get_git_editor()
+        parts = shlex.split(editor)
+        if not shutil.which(parts[0]):
+            log.error(
+                "Editor %r not found in PATH; please set GIT_EDITOR properly.", parts[0]
+            )
+            return 1
+        rc = subprocess.run(parts + [str(tf_name)], check=False).returncode
+
+        if rc != 0:
+            log.error("Editor exited with non-zero status -> aborting commit.")
+            return rc or 1
+
+        new_hash = sha256_of_file(tf_name)
+
+        # If the file was not changed, treat as "user didn't save" and abort.
+        if new_hash == original_hash:
+            log.warning("Aborting commit: commit message not saved.")
+            return 1
+
+        # file changed (or saved). Run git commit using the file as message.
+        try:
+            subprocess.run(["git", "commit", "-F", str(tf_name)], check=True)
+            return 0
+        except subprocess.CalledProcessError as e:
+            log.error("git commit failed with exit code %d", e.returncode)
+            return e.returncode or 1
+
+    finally:
+        try:
+            os.remove(tf_name)
+        except OSError as e:
+            log.warning(
+                "Failed to remove temporary commit message file %s: %r", tf_name, e
+            )

git_cai_cli-0.3.0/src/git_cai_cli/core/llm.py

@@ -0,0 +1,152 @@
+"""
+Use LLMs to generate git commit messages from diffs or multiple commits.
+"""
+
+import logging
+from typing import Any, Dict, Optional, Type
+
+from git_cai_cli.core.languages import LANGUAGE_MAP
+from google import genai  # type: ignore[reportUnknownImport]
+from google.genai import types  # type: ignore[reportUnknownImport]
+from openai import OpenAI
+
+log = logging.getLogger(__name__)
+
+
+class CommitMessageGenerator:
+    """
+    Generates git commit messages from diffs or from multiple commit messages.
+    """
+
+    def __init__(self, token: str, config: Dict[str, Any], default_model: str):
+        self.token = token
+        self.config = config
+        self.default_model = default_model
+
+    def generate(self, git_diff: str) -> str:
+        """
+        Generate a commit message from a diff.
+        """
+        language_name = self._language_name(self.config["language"], LANGUAGE_MAP)
+        prompt = self._system_prompt(language_name=language_name)
+        return self._dispatch_generate(content=git_diff, system_prompt=prompt)
+
+    def summarize_commit_history(self, commit_messages: str) -> str:
+        """
+        Summarize multiple commit messages into one high-level commit message.
+        """
+        language_name = self._language_name(self.config["language"], LANGUAGE_MAP)
+        prompt = self._summary_prompt(language_name=language_name)
+        return self._dispatch_generate(content=commit_messages, system_prompt=prompt)
+
+    # ---------------------------
+    # PROMPTS
+    # ---------------------------
+
+    def _system_prompt(self, language_name: str) -> str:
+        """
+        Prompt used when generating commit messages from diffs.
+        """
+        return (
+            "You are an expert software engineer assistant. "
+            "Your task is to generate a concise, professional git commit message. "
+            f"summarizing the provided git diff changes in {language_name}. "
+            "Keep the message clear and focused on what was changed and why. "
+            "Always include a headline, followed by a bullet-point list of changes. "
+            "If you detect sensitive information, mention it at the top, but still generate the message."
+        )
+
+    def _summary_prompt(self, language_name: str) -> str:
+        """
+        Prompt used when summarizing multiple commit messages into a single commit.
+        """
+        return (
+            "You are an expert software engineer assistant. "
+            "Your task is to summarize multiple existing commit messages* "
+            "into a single clean git commit message. "
+            f"Write the final message in {language_name}. "
+            "Do not list each commit individually. "
+            "Instead, infer the main purpose and overall change. "
+            "Format:\n"
+            "1. One short, clear headline.\n"
+            "2. A concise bullet list describing the main themes of the work."
+        )
+
+    # ---------------------------
+    # DISPATCH
+    # ---------------------------
+
+    def _dispatch_generate(self, content: str, system_prompt: str) -> str:
+        """
+        Route to correct model (openai or gemini) with the right prompt.
+        """
+        model_dispatch = {
+            "openai": self.generate_openai,
+            "gemini": self.generate_gemini,
+        }
+
+        if self.default_model not in model_dispatch:
+            raise ValueError(f"Unknown model type: '{self.default_model}'")
+
+        return model_dispatch[self.default_model](
+            content, system_prompt_override=system_prompt
+        )
+
+    # ---------------------------
+    # MODEL CALLS
+    # ---------------------------
+
+    def generate_openai(
+        self,
+        content: str,
+        openai_cls: Type[Any] = OpenAI,
+        system_prompt_override: Optional[str] = None,
+    ) -> str:
+        """
+        Shared OpenAI call for commit generation or commit history summarization.
+        """
+        client = openai_cls(api_key=self.token)
+        model = self.config["openai"]["model"]
+        temperature = self.config["openai"]["temperature"]
+
+        messages = [
+            {"role": "system", "content": system_prompt_override},
+            {"role": "user", "content": content},
+        ]
+
+        completion = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            temperature=temperature,
+        )
+        return completion.choices[0].message.content.strip()
+
+    def generate_gemini(
+        self,
+        content: str,
+        genai_cls: Type[Any] = genai.Client,
+        system_prompt_override: Optional[str] = None,
+    ) -> str:
+        """
+        Shared Gemini call for commit generation or commit history summarization.
+        """
+        client = genai_cls(api_key=self.token)
+        model = self.config["gemini"]["model"]
+        temperature = self.config["gemini"]["temperature"]
+
+        response = client.models.generate_content(
+            model=model,
+            contents=content,
+            config=types.GenerateContentConfig(
+                system_instruction=system_prompt_override,
+                temperature=temperature,
+            ),
+        )
+        return response.text
+
+    # ---------------------------
+    # LANGUAGE HELPER
+    # ---------------------------
+
+    def _language_name(self, lang_code: str, allowed_languages: dict[str, str]) -> str:
+        return allowed_languages.get(lang_code, "English")

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli/core/options.py

@@ -10,6 +10,7 @@ from pathlib import Path
 
 import requests
 from git_cai_cli.core.languages import LANGUAGE_MAP
+from git_cai_cli.core.squash import squash_branch
 
 log = logging.getLogger(__name__)
 
@@ -62,6 +63,7 @@ Flags:
   -h                Show this help message
   -d, --debug       Enable debug logging
   -l, --languages   List supported languages
+  -s, --squash      Squash commits on this branch and summarize them
   -u, --update      Check for updates
   -v, --version     Show installed version
 
@@ -70,7 +72,7 @@ Configuration:
 
 Examples:
   git add .
-  git cai        Generates commit message
+  git cai           Generates commit message
 
 """
 
@@ -159,7 +161,7 @@ Examples:
             log.error("Error during update: %s", update_error)
             print("❌ An error occurred while updating. Check logs for details.")
 
-    def enable_debug(self):
+    def enable_debug(self) -> None:
         """
         Enable verbose/debug logging.
         """
@@ -173,6 +175,15 @@ Examples:
         Intended to be used in CLI commands.
         """
         lines = ["\nAvailable languages:"]
-        for code, name in sorted(self.allowed_languages.items()):
-            lines.append(f"  - {code} → {name}")
+        # Sort by the name (value)
+        for code, name in sorted(
+            self.allowed_languages.items(), key=lambda item: item[1]
+        ):
+            lines.append(f"  - {name} → {code}")
         return "\n".join(lines)
+
+    def squash_branch(self) -> None:
+        """
+        Squash commits on the current branch and summarize them.
+        """
+        return squash_branch()

git_cai_cli-0.3.0/src/git_cai_cli/core/squash.py

@@ -0,0 +1,181 @@
+"""
+Squash all commits in the current branch into a single commit with an LLM-generated message.
+"""
+
+import logging
+import shlex
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from git_cai_cli.core.config import get_default_config, load_config, load_token
+from git_cai_cli.core.gitutils import (
+    _has_upstream,
+    commit_with_edit_template,
+    find_git_root,
+    get_git_editor,
+    git_diff_excluding,
+    sha256_of_file,
+)
+from git_cai_cli.core.llm import CommitMessageGenerator
+
+log = logging.getLogger(__name__)
+
+
+def _get_branch_base() -> str:
+    """
+    Determine commit where the branch diverged
+    """
+    # Try remote default branch (origin/main, origin/master, etc.)
+    try:
+        ref = subprocess.check_output(
+            ["git", "symbolic-ref", "refs/remotes/origin/HEAD"], text=True
+        ).strip()
+        default_branch = ref.replace("refs/remotes/", "")
+        log.info("Using default branch for base detection: %s", default_branch)
+        base = subprocess.check_output(
+            ["git", "merge-base", "--fork-point", default_branch, "HEAD"], text=True
+        ).strip()
+        return base
+    except subprocess.CalledProcessError as e:
+        log.info(
+            "Unable to determine default branch. Falling back to initial commit..."
+        )
+        log.debug("Default branch detection failed: %r", e)
+
+    # Fallback to repo root commit
+    try:
+        base = subprocess.check_output(
+            ["git", "rev-list", "--max-parents=0", "HEAD"], text=True
+        ).strip()
+        log.info("Using repository root commit as base: %s", base)
+        return base
+
+    except subprocess.CalledProcessError as e:
+        # This case is extremely rare and would be truly unexpected.
+        log.debug("Failed to determine repository root commit: %r", e)
+        raise
+
+
+def squash_branch() -> None:
+    """
+    Squash all commits in the current branch into a single commit with an LLM-generated message.
+    """
+    repo_root = find_git_root()
+    if not repo_root:
+        log.error("Not inside a Git repository.")
+        return
+
+    staged = subprocess.check_output(
+        ["git", "diff", "--cached", "--name-only"], text=True
+    ).strip()
+    unstaged = subprocess.check_output(
+        ["git", "diff", "--name-only"], text=True
+    ).strip()
+
+    config = load_config()
+    default_model = get_default_config()
+    token = load_token(default_model)
+    if not token:
+        log.error("Missing %s token in ~/.config/cai/tokens.yml", default_model)
+        sys.exit(1)
+    generator = CommitMessageGenerator(token, config, default_model)
+
+    # 1) Working tree handling
+    if staged:
+        log.info("Staged changes detected — committing them first before squashing...")
+        diff = git_diff_excluding(repo_root)
+
+        if not diff.strip():
+            log.error("Staged changes detected, but diff is empty. Aborting.")
+            return
+
+        msg = generator.generate(diff)
+
+        result = commit_with_edit_template(msg)
+        if result != 0:
+            log.info("Commit aborted — squash cancelled.")
+            return
+
+    else:
+        if unstaged:
+            log.error(
+                "Unstaged changes present. Please stage or discard them before squashing."
+            )
+            return
+        log.info("Working tree clean — proceeding to squash history.")
+
+    # 2) Determine branch base
+    merge_base = _get_branch_base()
+
+    # 3) Summarize commit history
+    commit_log = subprocess.check_output(
+        ["git", "--no-pager", "log", f"{merge_base}..HEAD", "--pretty=format:%B"],
+        text=True,
+    ).strip()
+
+    if not commit_log:
+        log.info("Nothing to squash — branch contains only one commit.")
+        return
+
+    log.info("Summarizing commit history using LLM...")
+    summary_message = generator.summarize_commit_history(commit_log)
+
+    # 4) Let user edit the summary without making a commit yet
+    log.info(
+        "Opening editor for final squash commit message. Save = continue, exit w/o save = cancel..."
+    )
+
+    # write to temp file
+    with tempfile.NamedTemporaryFile("w", delete=False, encoding="utf-8") as tf:
+        tf.write(summary_message)
+        tf.flush()
+        tf_name = Path(tf.name)
+
+    original_hash = sha256_of_file(tf_name)
+
+    editor = get_git_editor()
+    parts = shlex.split(editor)
+    if not shutil.which(parts[0]):
+        # This editor command requires shell interpretation
+        rc = subprocess.run(
+            f'{editor} "{tf_name}"', shell=True, check=False  # nosemgrep
+        ).returncode  # nosec # nosemgrep
+    else:
+        rc = subprocess.run(parts + [str(tf_name)], check=False).returncode
+
+    if rc != 0:
+        log.info("Editor exited non-zero — squash cancelled.")
+        tf_name.unlink(missing_ok=True)
+        return
+
+    new_hash = sha256_of_file(tf_name)
+
+    if new_hash == original_hash:
+        log.info("Squash cancelled (user did not save message).")
+        tf_name.unlink(missing_ok=True)
+        return
+
+    # User saved → read message into final_message
+    final_message = tf_name.read_text(encoding="utf-8").strip()
+    tf_name.unlink(missing_ok=True)
+
+    # 5) Perform squash
+    subprocess.run(["git", "reset", "--soft", merge_base], check=True)
+    subprocess.run(["git", "commit", "-m", final_message], check=True)
+
+    log.info("🎉 Branch successfully squashed into one commit. ✅")
+
+    if _has_upstream():
+        log.warning(
+            "Your branch has a remote upstream.\n"
+            "Since squashing rewrites commit history, your next push will require:\n\n"
+            "    git push --force-with-lease\n\n"
+            "This is a safe force-push that prevents overwriting others' commits."
+        )
+    else:
+        log.info(
+            "No upstream branch detected. Normal `git push` will work as expected."
+        )

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-cai-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: Use LLM to create git commit messages
 Author-email: Thorsten Foltz <thorsten.foltz@live.com>
 License: MIT
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Version Control
 Requires-Python: >=3.10
@@ -64,6 +65,7 @@ Currently, the only supported backends are the OpenAI and Gemini APIs, but addit
 - Generates meaningful, context-aware commit messages using an LLM
 - Seamless integration with Git as a plugin/extension
 - Supports different LLM models and languages for each repository, as well as global configuration
+- Allows to squash all commits in a branch and summarizes the commit messages
 
 <h2 id="installation-section">Installation</h2>
 
@@ -89,7 +91,10 @@ Once installed, cai works like a standard Git command:
 git cai
 ```
 
-`cai` uses Git’s `diff` output as input for generating commit messages.  
+`cai` uses Git’s `diff` output to generate commit messages. The generated message is then opened in your editor, allowing you to review and edit it before confirming the commit.  
+
+In short: it behaves like `git commit`, but the commit message is pre-filled for you.
+
 To exclude specific files or directories from being included in the generated commit message, create a `.caiignore` file in the root of your repository. This file works like a `.gitignore`.  
 
 - Files listed in `.gitignore` are **always excluded**.  
@@ -133,10 +138,11 @@ Currently, the following options can be customized:
 Besides running `git cai` to generate commit messages, you can use the following options:
 
 - `-h` shows a brief help message with available commands
-- `d`, `--debug` enables debug logging to help troubleshoot issues
-- `l`, `--languages` list available languages
-- `u`, `--update` checks for updates the `cai` tool
-- `v`, `--version` displays the currently installed version
+- `-d`, `--debug` enables debug logging to help troubleshoot issues
+- `-l`, `--languages` list available languages
+- `-s`, `--squash` Squash commits on this branch and summarize them
+- `-u`, `--update` checks for updates the `cai` tool
+- `-v`, `--version` displays the currently installed version
 
 <h2 id="license-section">License</h2>
 This project is licensed under the MIT License.

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ uv.lock
 .linters/check_git_branch_name.sh
 .linters/lychee.toml
 .linters/pyrightconfig.json
+archlinux/.SRCINFO
 archlinux/PKGBUILD
 src/git_cai_cli/__init__.py
 src/git_cai_cli/cli.py
@@ -35,4 +36,5 @@ src/git_cai_cli/core/gitutils.py
 src/git_cai_cli/core/languages.py
 src/git_cai_cli/core/llm.py
 src/git_cai_cli/core/options.py
-src/tests/test_core/test_config.py
+src/git_cai_cli/core/squash.py
+tests/test_core/test_config.py

{git_cai_cli-0.2.0 → git_cai_cli-0.3.0}/src/git_cai_cli.egg-info/top_level.txt

@@ -1,2 +1 @@
 git_cai_cli
-tests

git_cai_cli-0.2.0/src/git_cai_cli/core/gitutils.py

@@ -1,57 +0,0 @@
-"""
-Check git repo and run git diff
-"""
-
-import logging
-import subprocess
-import sys
-from pathlib import Path
-from typing import Callable
-
-log = logging.getLogger(__name__)
-
-
-def find_git_root(
-    run_cmd: Callable[..., subprocess.CompletedProcess] = subprocess.run,
-) -> Path | None:
-    """Returns the root directory of the current Git repository, or None if not in a Git repo."""
-    try:
-        result = run_cmd(
-            ["git", "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        return Path(result.stdout.strip())
-    except subprocess.CalledProcessError:
-        return None
-
-
-def git_diff_excluding(
-    repo_root: Path,
-    run_cmd: Callable[..., subprocess.CompletedProcess] = subprocess.run,
-    exit_func: Callable[[int], None] = sys.exit,
-) -> str:
-    """Run `git diff` excluding files listed in .caiignore."""
-    ignore_file = repo_root / ".caiignore"
-
-    exclude_files: list[str] = []
-    if ignore_file.exists():
-        with open(ignore_file, "r", encoding="utf-8") as f:
-            exclude_files = [
-                line.strip()
-                for line in f
-                if line.strip() and not line.strip().startswith("#")
-            ]
-        if not exclude_files:
-            log.info("%s is empty. No files excluded.", ignore_file)
-
-    cmd = ["git", "diff", "--cached", "--", "."]
-    cmd.extend(f":!{pattern}" for pattern in exclude_files)
-
-    result = run_cmd(cmd, capture_output=True, text=True, check=True)
-    if result.returncode != 0:
-        log.error("git diff failed: %s", result.stderr.strip())
-        exit_func(1)
-
-    return result.stdout

git_cai_cli-0.2.0/src/git_cai_cli/core/llm.py

@@ -1,112 +0,0 @@
-"""
-Settings and connection of LLM
-"""
-
-import logging
-from typing import Any, Dict, Type
-
-from git_cai_cli.core.languages import LANGUAGE_MAP
-from google import genai  # type: ignore[reportUnknownImport]
-from google.genai import types  # type: ignore[reportUnknownImport]
-from openai import OpenAI
-
-log = logging.getLogger(__name__)
-
-
-class CommitMessageGenerator:
-    """
-    Generates git commit messages from a git diff using LLMs.
-    """
-
-    def __init__(self, token: str, config: Dict[str, Any], default_model: str):
-        self.token = token
-        self.config = config
-        self.default_model = default_model
-
-    def generate(self, git_diff: str) -> str:
-        """
-        Generate a commit message using the default model.
-        """
-        model_dispatch = {
-            "openai": self.generate_openai,
-            "gemini": self.generate_gemini,
-        }
-
-        try:
-            log.debug("Generating commit message using model '%s'", self.default_model)
-            return model_dispatch[self.default_model](git_diff)
-        except KeyError as e:
-            log.error("Unknown default model: '%s'", self.default_model)
-            raise ValueError(f"Unknown default model: '{self.default_model}'") from e
-
-    def _system_prompt(self, language_name: str) -> str:
-        """
-        Shared system prompt for both OpenAI and Gemini.
-        """
-        return (
-            "You are an expert software engineer assistant. "
-            "Your task is to generate a concise, professional git commit message. "
-            f"Summarizing the provided git diff changes in {language_name}. "
-            "Keep the message clear and focused on what was changed and why. "
-            "Always include a headline, followed by a bullet-point list of changes. "
-            "Should you observe any sensitive information in the diff, print 'SENSITIVE INFORMATION DETECTED' "
-            "and show what was detected, the file where and the line number. "
-            "But even if you see sensitive information, still generate the commit message. "
-        )
-
-    def generate_openai(self, git_diff: str, openai_cls: Type[Any] = OpenAI) -> str:
-        """
-        Generate a commit message using OpenAI's API.
-        """
-        client = openai_cls(api_key=self.token)
-        model = self.config["openai"]["model"]
-        temperature = self.config["openai"]["temperature"]
-        language = self.config["language"]
-        language_name = self._language_name(language, LANGUAGE_MAP)
-
-        system_prompt = self._system_prompt(language_name)
-
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {
-                "role": "user",
-                "content": f"Generate a commit message for:\n\n{git_diff}",
-            },
-        ]
-
-        completion = client.chat.completions.create(
-            model=model,
-            messages=messages,
-            temperature=temperature,
-        )
-        return completion.choices[0].message.content.strip()
-
-    def generate_gemini(
-        self, git_diff: str, genai_cls: Type[Any] = genai.Client
-    ) -> str:
-        """
-        Generate a commit message using Gemini's API.
-        """
-        client = genai_cls(api_key=self.token)
-        model = self.config["gemini"]["model"]
-        temperature = self.config["gemini"]["temperature"]
-        language = self.config["language"]
-        language_name = self._language_name(language, LANGUAGE_MAP)
-        system_prompt = self._system_prompt(language_name)
-        messages = git_diff
-        response = client.models.generate_content(
-            model=model,
-            contents=messages,
-            config=types.GenerateContentConfig(
-                system_instruction=system_prompt,
-                temperature=temperature,
-            ),
-        )
-        return response.text
-
-    def _language_name(self, lang_code: str, allowed_languages: dict[str, str]) -> str:
-        """
-        Convert ISO 639-1 code to human-readable language name.
-        Defaults to English if not found.
-        """
-        return allowed_languages.get(lang_code, "English")