git-copilot-commit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

git_copilot_commit/cli.py

@@ -19,11 +19,9 @@ from .git import GitRepository, GitError, GitStatus, NotAGitRepositoryError
 from .split_commits import (
     PatchUnit,
     SplitCommitPlan,
-    SplitCommitLimitExceededError,
     SplitPlanningError,
     build_split_plan_prompt,
     build_status_for_patch_units,
-    evaluate_auto_split,
     extract_patch_units,
     group_patch_units,
     parse_split_plan_response,
@@ -37,7 +35,6 @@ app = typer.Typer(help=__doc__, add_completion=False)
 
 COMMIT_MESSAGE_PROMPT_FILENAME = "commit-message-generator-prompt.md"
 SPLIT_COMMIT_PLANNER_PROMPT_FILENAME = "split-commit-planner-prompt.md"
-DEFAULT_AUTO_MAX_COMMITS = 10
 SPLIT_DIFF_ARGS = [
     "--binary",
     "--full-index",
@@ -75,7 +72,7 @@ SplitOption = Annotated[
         "--split",
         help=(
             "Split staged hunks into multiple commits automatically. Pass "
-            "`--split=N` to prefer up to N commits."
+            "`--split=N` to express a preference for N commits."
         ),
     ),
 ]
@@ -128,11 +125,7 @@ def preprocess_cli_args(args: Sequence[str]) -> list[str]:
             index += 1
             continue
 
-        if (
-            in_commit_command
-            and arg == "--split"
-            and index + 1 < len(args)
-        ):
+        if in_commit_command and arg == "--split" and index + 1 < len(args):
             split_value = args[index + 1].strip().lower()
             if split_value == "auto":
                 processed_args.append("--split")
@@ -352,21 +345,6 @@ def generate_commit_message_for_status(
     )
 
 
-def generate_commit_message(
-    repo: GitRepository,
-    model: str | None = None,
-    context: str = "",
-    http_client_config: github_copilot.HttpClientConfig | None = None,
-) -> str:
-    """Generate a conventional commit message using the repository's staged diff."""
-    return generate_commit_message_for_status(
-        repo.get_status(),
-        model=model,
-        context=context,
-        http_client_config=http_client_config,
-    )
-
-
 def commit_with_retry_no_verify(
     repo: GitRepository,
     message: str,
@@ -471,7 +449,6 @@ def request_split_commit_plan(
     status: GitStatus,
     patch_units: tuple[PatchUnit, ...],
     *,
-    max_commits: int,
     preferred_commits: int | None = None,
     model: str | None = None,
     context: str = "",
@@ -482,7 +459,6 @@ def request_split_commit_plan(
         planner_prompt = build_split_plan_prompt(
             status,
             patch_units,
-            max_commits=max_commits,
             preferred_commits=preferred_commits,
             context=context,
         )
@@ -499,7 +475,6 @@ def request_split_commit_plan(
         return parse_split_plan_response(
             response,
             patch_units,
-            max_commits=max_commits,
         )
     except github_copilot.CopilotError as exc:
         print_copilot_error("Could not generate a split commit plan", exc)
@@ -541,25 +516,31 @@ def request_split_commit_messages(
         raise typer.Exit(1)
 
 
-def resolve_split_commit_limit(
-    exc: SplitCommitLimitExceededError, *, yes: bool = False
+def confirm_split_commit_count(
+    plan: SplitCommitPlan,
+    *,
+    preferred_commits: int,
+    yes: bool = False,
 ) -> SplitCommitPlan:
-    """Ask whether to proceed when the planner exceeds the configured limit."""
+    """Ask whether to proceed when the planner exceeds the preferred count."""
+    actual_commits = len(plan.commits)
+    if actual_commits <= preferred_commits:
+        return plan
+
     console.print(
-        f"[yellow]Split planning produced {exc.actual_commits} commits, exceeding the automatic review limit of {exc.max_commits}.[/yellow]"
+        "[yellow]Split planning produced "
+        f"{actual_commits} commits, exceeding the preferred count of "
+        f"{preferred_commits}.[/yellow]"
     )
 
     if yes:
-        console.print(
-            "[red]Cannot ask whether to proceed because --yes was used. Re-run without --yes to review the larger plan.[/red]"
-        )
-        raise typer.Exit(1)
+        return plan
 
     if Confirm.ask(
-        f"Proceed with [bold]{exc.actual_commits} commits[/] anyway?",
+        f"Proceed with [bold]{actual_commits} commits[/] anyway?",
         default=False,
     ):
-        return exc.plan
+        return plan
 
     console.print("Split commit plan cancelled.")
     raise typer.Exit()
@@ -747,44 +728,24 @@ def handle_split_commit_flow(
         return
 
     if preferred_commits is None:
-        should_split, reason = evaluate_auto_split(patch_units)
-        if not should_split:
-            console.print(
-                "[yellow]Auto split not triggered: "
-                f"{reason}. Creating a single commit. Use [bold]--split N[/] to suggest an upper bound.[/yellow]"
-            )
-            handle_single_commit_flow(
-                repo,
-                status,
-                model=model,
-                yes=yes,
-                context=context,
-                http_client_config=http_client_config,
-            )
-            return
-
-        console.print(f"[yellow]Auto split triggered: {reason}.[/yellow]")
+        console.print(
+            "[yellow]Planning split commits from the staged patch units.[/yellow]"
+        )
     else:
         console.print(
-            f"[yellow]Planning up to {preferred_commits} commits from the staged patch units.[/yellow]"
+            "[yellow]Planning split commits with a preference for "
+            f"{preferred_commits} commits.[/yellow]"
         )
 
     try:
         split_plan = request_split_commit_plan(
             status,
             patch_units,
-            max_commits=(
-                DEFAULT_AUTO_MAX_COMMITS
-                if preferred_commits is None
-                else preferred_commits
-            ),
             preferred_commits=preferred_commits,
             model=model,
             context=context,
             http_client_config=http_client_config,
         )
-    except SplitCommitLimitExceededError as exc:
-        split_plan = resolve_split_commit_limit(exc, yes=yes)
     except SplitPlanningError as exc:
         console.print(
             "[yellow]Split planning returned an invalid plan; falling back to a single commit.[/yellow]"
@@ -800,6 +761,13 @@ def handle_split_commit_flow(
         )
         return
 
+    if preferred_commits is not None:
+        split_plan = confirm_split_commit_count(
+            split_plan,
+            preferred_commits=preferred_commits,
+            yes=yes,
+        )
+
     prepared_commits = request_split_commit_messages(
         split_plan,
         patch_units,

git_copilot_commit/git.py

@@ -121,16 +121,31 @@ class GitRepository:
         Raises:
             NotAGitRepositoryError: If the path is not a git repository.
         """
-        self.repo_path = repo_path or Path.cwd()
+        self.cwd = (repo_path or Path.cwd()).resolve()
         self.timeout = timeout
-        self._validate_git_repo()
+        self.repo_path = self._resolve_repo_root()
 
-    def _validate_git_repo(self) -> None:
-        """Ensure we're in a git repository."""
+    def _resolve_repo_root(self) -> Path:
+        """Resolve and cache the repository top-level path."""
         try:
-            self._run_git_command(["rev-parse", "--git-dir"])
-        except GitCommandError:
-            raise NotAGitRepositoryError(f"{self.repo_path} is not a git repository")
+            result = subprocess.run(
+                ["git", "rev-parse", "--show-toplevel"],
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                check=True,
+            )
+        except subprocess.CalledProcessError:
+            raise NotAGitRepositoryError(f"{self.cwd} is not a git repository")
+        except subprocess.TimeoutExpired:
+            raise GitCommandError("Git command timed out: git rev-parse --show-toplevel")
+
+        repo_root = result.stdout.strip()
+        if not repo_root:
+            raise NotAGitRepositoryError(f"{self.cwd} is not a git repository")
+
+        return Path(repo_root)
 
     def _run_git_command(
         self,
@@ -188,6 +203,21 @@ class GitRepository:
         merged_env.update(env)
         return merged_env
 
+    def _normalize_paths(self, paths: list[str]) -> list[str]:
+        """Normalize user paths relative to the repository root."""
+        normalized_paths: list[str] = []
+        for path in paths:
+            path_obj = Path(path)
+            if path_obj.is_absolute():
+                normalized_paths.append(str(path_obj))
+                continue
+
+            normalized_paths.append(
+                os.path.relpath(self.cwd / path_obj, start=self.repo_path)
+            )
+
+        return normalized_paths
+
     def get_status(self, env: Mapping[str, str] | None = None) -> GitStatus:
         """
         Get comprehensive git status information.
@@ -263,16 +293,16 @@ class GitRepository:
         Stage files for commit.
 
         Args:
-          paths: List of file paths to stage. If None, stages all files (git add .).
+          paths: List of file paths to stage. If None, stages all files.
         """
         if paths is None:
-            self._run_git_command(["add", "."])
+            self._run_git_command(["add", "--all"])
         else:
-            self._run_git_command(["add"] + paths)
+            self._run_git_command(["add"] + self._normalize_paths(paths))
 
     def stage_modified(self) -> None:
-        """Stage all modified files (git add -u)."""
-        self._run_git_command(["add", "-u"])
+        """Stage all modified tracked files."""
+        self._run_git_command(["add", "--update"])
 
     def unstage_files(self, paths: list[str] | None = None) -> None:
         """
@@ -284,7 +314,7 @@ class GitRepository:
         if paths is None:
             self._run_git_command(["reset", "HEAD"])
         else:
-            self._run_git_command(["reset", "HEAD"] + paths)
+            self._run_git_command(["reset", "HEAD"] + self._normalize_paths(paths))
 
     def create_alternate_index(self, from_ref: str = "HEAD") -> AlternateGitIndex:
         """Create a temporary git index initialized from the provided ref."""

git_copilot_commit/github_copilot.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import base64
 import json
-import os
+import random
 import re
 import secrets
 import time
@@ -24,6 +24,7 @@ from .settings import Settings
 APP_NAME = "github-copilot-commit"
 CLI_AUTH_COMMAND = "git-copilot-commit authenticate"
 DEFAULT_GITHUB_DOMAIN = "github.com"
+CREDENTIALS_FILENAME = "copilot-auth.json"
 USER_AGENT = "GitHubCopilotChat/0.35.0"
 EDITOR_VERSION = "vscode/1.107.0"
 EDITOR_PLUGIN_VERSION = "copilot-chat/0.35.0"
@@ -33,6 +34,11 @@ CLIENT_ID = base64.b64decode("SXYxLmI1MDdhMDhjODdlY2ZlOTg=").decode()
 INITIAL_POLL_INTERVAL_MULTIPLIER = 1.2
 SLOW_DOWN_POLL_INTERVAL_MULTIPLIER = 1.4
 DEFAULT_MODEL_ID = "gpt-5.3-codex"
+HTTP_RETRY_ATTEMPTS = 3
+HTTP_RETRY_BASE_DELAY_SECONDS = 0.5
+HTTP_RETRY_MAX_DELAY_SECONDS = 4.0
+HTTP_RETRY_MAX_JITTER_SECONDS = 0.25
+HTTP_RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
 DEFAULT_MODEL_PREFERENCES = (
     "gpt-5.3-codex",
     "gpt-5.4",
@@ -267,15 +273,8 @@ class CopilotConfig:
         return cls(default_model=default_model)
 
 
-def xdg_data_home() -> Path:
-    value = os.environ.get("XDG_DATA_HOME")
-    if value:
-        return Path(value).expanduser()
-    return Path.home() / ".local" / "share"
-
-
 def credentials_path() -> Path:
-    return xdg_data_home() / APP_NAME / "copilot-auth.json"
+    return Settings().state_dir / CREDENTIALS_FILENAME
 
 
 def config_path() -> Path:
@@ -365,7 +364,9 @@ def _maybe_enable_native_tls(native_tls: bool) -> None:
     _NATIVE_TLS_ENABLED = True
 
 
-def make_http_client(http_client_config: HttpClientConfig | None = None) -> httpx.Client:
+def make_http_client(
+    http_client_config: HttpClientConfig | None = None,
+) -> httpx.Client:
     config = http_client_config or HttpClientConfig()
     _maybe_enable_native_tls(config.use_native_tls)
 
@@ -376,6 +377,34 @@ def make_http_client(http_client_config: HttpClientConfig | None = None) -> http
     )
 
 
+def truncate_response_detail(detail: str) -> str:
+    detail = detail.strip()
+    if len(detail) > 400:
+        return f"{detail[:397]}..."
+    return detail
+
+
+def should_retry_status_code(status_code: int) -> bool:
+    return status_code in HTTP_RETRYABLE_STATUS_CODES
+
+
+def compute_retry_delay_seconds(attempt: int, retry_after: str | None = None) -> float:
+    if retry_after is not None:
+        try:
+            delay = float(retry_after.strip())
+        except ValueError:
+            delay = -1.0
+        else:
+            if delay >= 0:
+                return delay
+
+    backoff = min(
+        HTTP_RETRY_MAX_DELAY_SECONDS,
+        HTTP_RETRY_BASE_DELAY_SECONDS * (2**attempt),
+    )
+    return backoff + random.uniform(0.0, HTTP_RETRY_MAX_JITTER_SECONDS)
+
+
 def request_json(
     client: httpx.Client,
     method: str,
@@ -385,31 +414,48 @@ def request_json(
     data: dict[str, str] | None = None,
     json_body: Any | None = None,
 ) -> Any:
-    try:
-        response = client.request(
-            method,
-            url,
-            headers=headers,
-            data=data,
-            json=json_body,
-        )
-    except httpx.HTTPError as exc:
-        raise CopilotError(f"Request failed for {url}: {exc}") from exc
+    for attempt in range(HTTP_RETRY_ATTEMPTS):
+        try:
+            response = client.request(
+                method,
+                url,
+                headers=headers,
+                data=data,
+                json=json_body,
+            )
+        except httpx.TransportError as exc:
+            if attempt < HTTP_RETRY_ATTEMPTS - 1:
+                time.sleep(compute_retry_delay_seconds(attempt))
+                continue
+            raise CopilotError(f"Request failed for {url}: {exc}") from exc
+        except httpx.HTTPError as exc:
+            raise CopilotError(f"Request failed for {url}: {exc}") from exc
+
+        if response.is_error:
+            detail = truncate_response_detail(response.text)
+            error = CopilotHttpError(
+                response.status_code, response.reason_phrase, detail
+            )
+            if (
+                should_retry_status_code(response.status_code)
+                and attempt < HTTP_RETRY_ATTEMPTS - 1
+            ):
+                time.sleep(
+                    compute_retry_delay_seconds(
+                        attempt, response.headers.get("retry-after")
+                    )
+                )
+                continue
+            raise error
 
-    if response.is_error:
-        detail = response.text.strip()
-        if len(detail) > 400:
-            detail = f"{detail[:397]}..."
-        raise CopilotHttpError(response.status_code, response.reason_phrase, detail)
+        break
 
     content_type = response.headers.get("content-type", "")
     if "application/json" not in content_type:
         try:
             return response.json()
         except ValueError as exc:
-            detail = response.text.strip()
-            if len(detail) > 400:
-                detail = f"{detail[:397]}..."
+            detail = truncate_response_detail(response.text)
             raise CopilotError(
                 f"Expected JSON from {url}, got {content_type or 'unknown content type'}: {detail}"
             ) from exc
@@ -1020,118 +1066,141 @@ def responses_completion(
         "store": False,
     }
 
-    text_parts: list[str] = []
-    final_response: dict[str, Any] | None = None
+    for attempt in range(HTTP_RETRY_ATTEMPTS):
+        text_parts: list[str] = []
+        final_response: dict[str, Any] | None = None
 
-    try:
-        with client.stream(
-            "POST",
-            url,
-            headers=copilot_request_headers(
-                credentials.copilot_token,
-                intent="conversation-edits",
-                accept="text/event-stream",
-            ),
-            json=request_body,
-        ) as response:
-            if response.is_error:
-                detail = response.read().decode("utf-8", errors="replace").strip()
-                if len(detail) > 400:
-                    detail = f"{detail[:397]}..."
-                raise CopilotHttpError(
-                    response.status_code, response.reason_phrase, detail
-                )
+        try:
+            with client.stream(
+                "POST",
+                url,
+                headers=copilot_request_headers(
+                    credentials.copilot_token,
+                    intent="conversation-edits",
+                    accept="text/event-stream",
+                ),
+                json=request_body,
+            ) as response:
+                if response.is_error:
+                    detail = truncate_response_detail(
+                        response.read().decode("utf-8", errors="replace")
+                    )
+                    error = CopilotHttpError(
+                        response.status_code, response.reason_phrase, detail
+                    )
+                    if (
+                        should_retry_status_code(response.status_code)
+                        and attempt < HTTP_RETRY_ATTEMPTS - 1
+                    ):
+                        time.sleep(
+                            compute_retry_delay_seconds(
+                                attempt, response.headers.get("retry-after")
+                            )
+                        )
+                        continue
+                    raise error
+
+                content_type = response.headers.get("content-type", "")
+                if "text/event-stream" not in content_type:
+                    body = response.read()
+                    try:
+                        payload = json.loads(body)
+                    except ValueError as exc:
+                        detail = truncate_response_detail(
+                            body.decode("utf-8", errors="replace")
+                        )
+                        raise CopilotError(
+                            f"Expected an SSE stream from {url}, got {content_type or 'unknown content type'}: {detail}"
+                        ) from exc
+                    return extract_response_text(payload)
+
+                for event in iter_sse_events(response, url):
+                    if not isinstance(event, dict):
+                        continue
+
+                    event_type = event.get("type")
+                    if event_type == "response.output_text.delta":
+                        delta = event.get("delta")
+                        if isinstance(delta, str) and delta:
+                            text_parts.append(delta)
+                        continue
+
+                    if event_type == "response.output_text.done" and not text_parts:
+                        text = event.get("text")
+                        if isinstance(text, str) and text.strip():
+                            text_parts.append(text)
+                        continue
+
+                    if event_type == "error":
+                        error = event.get("error")
+                        if isinstance(error, dict):
+                            message = error.get("message")
+                            code = error.get("code")
+                            if isinstance(message, str) and message.strip():
+                                prefix = (
+                                    f"{code}: "
+                                    if isinstance(code, str) and code
+                                    else ""
+                                )
+                                raise CopilotError(
+                                    f"Responses stream error: {prefix}{message.strip()}"
+                                )
+                        raise CopilotError("Responses stream returned an error event.")
+
+                    if event_type in {
+                        "response.completed",
+                        "response.failed",
+                        "response.incomplete",
+                    }:
+                        response_payload = event.get("response")
+                        if isinstance(response_payload, dict):
+                            final_response = response_payload
+        except httpx.TransportError as exc:
+            if attempt < HTTP_RETRY_ATTEMPTS - 1:
+                time.sleep(compute_retry_delay_seconds(attempt))
+                continue
+            raise CopilotError(f"Request failed for {url}: {exc}") from exc
+        except httpx.HTTPError as exc:
+            raise CopilotError(f"Request failed for {url}: {exc}") from exc
+
+        text = "".join(text_parts).strip()
+        if final_response is None:
+            if text:
+                return text
+            raise CopilotError(
+                "Responses stream ended without a terminal response event."
+            )
 
-            content_type = response.headers.get("content-type", "")
-            if "text/event-stream" not in content_type:
-                body = response.read()
-                try:
-                    payload = json.loads(body)
-                except ValueError as exc:
-                    detail = body.decode("utf-8", errors="replace").strip()
-                    if len(detail) > 400:
-                        detail = f"{detail[:397]}..."
+        status = final_response.get("status")
+        if status == "failed":
+            error = final_response.get("error")
+            if isinstance(error, dict):
+                message = error.get("message")
+                code = error.get("code")
+                if isinstance(message, str) and message.strip():
+                    prefix = f"{code}: " if isinstance(code, str) and code else ""
                     raise CopilotError(
-                        f"Expected an SSE stream from {url}, got {content_type or 'unknown content type'}: {detail}"
-                    ) from exc
-                return extract_response_text(payload)
-
-            for event in iter_sse_events(response, url):
-                if not isinstance(event, dict):
-                    continue
-
-                event_type = event.get("type")
-                if event_type == "response.output_text.delta":
-                    delta = event.get("delta")
-                    if isinstance(delta, str) and delta:
-                        text_parts.append(delta)
-                    continue
-
-                if event_type == "response.output_text.done" and not text_parts:
-                    text = event.get("text")
-                    if isinstance(text, str) and text.strip():
-                        text_parts.append(text)
-                    continue
-
-                if event_type == "error":
-                    error = event.get("error")
-                    if isinstance(error, dict):
-                        message = error.get("message")
-                        code = error.get("code")
-                        if isinstance(message, str) and message.strip():
-                            prefix = (
-                                f"{code}: " if isinstance(code, str) and code else ""
-                            )
-                            raise CopilotError(
-                                f"Responses stream error: {prefix}{message.strip()}"
-                            )
-                    raise CopilotError("Responses stream returned an error event.")
-
-                if event_type in {
-                    "response.completed",
-                    "response.failed",
-                    "response.incomplete",
-                }:
-                    response_payload = event.get("response")
-                    if isinstance(response_payload, dict):
-                        final_response = response_payload
-    except httpx.HTTPError as exc:
-        raise CopilotError(f"Request failed for {url}: {exc}") from exc
-
-    text = "".join(text_parts).strip()
-    if final_response is None:
+                        f"Responses API request failed: {prefix}{message.strip()}"
+                    )
+            raise CopilotError("Responses API request failed.")
+
+        if status == "incomplete":
+            details = final_response.get("incomplete_details")
+            reason = "unknown"
+            if isinstance(details, dict):
+                raw_reason = details.get("reason")
+                if isinstance(raw_reason, str) and raw_reason.strip():
+                    reason = raw_reason.strip()
+            if text:
+                return f"{text}\n\n[Response incomplete: {reason}]"
+            raise CopilotError(f"Responses API response was incomplete: {reason}.")
+
         if text:
             return text
-        raise CopilotError("Responses stream ended without a terminal response event.")
-
-    status = final_response.get("status")
-    if status == "failed":
-        error = final_response.get("error")
-        if isinstance(error, dict):
-            message = error.get("message")
-            code = error.get("code")
-            if isinstance(message, str) and message.strip():
-                prefix = f"{code}: " if isinstance(code, str) and code else ""
-                raise CopilotError(
-                    f"Responses API request failed: {prefix}{message.strip()}"
-                )
-        raise CopilotError("Responses API request failed.")
-
-    if status == "incomplete":
-        details = final_response.get("incomplete_details")
-        reason = "unknown"
-        if isinstance(details, dict):
-            raw_reason = details.get("reason")
-            if isinstance(raw_reason, str) and raw_reason.strip():
-                reason = raw_reason.strip()
-        if text:
-            return f"{text}\n\n[Response incomplete: {reason}]"
-        raise CopilotError(f"Responses API response was incomplete: {reason}.")
 
-    if text:
-        return text
+        return extract_response_text(final_response)
 
-    return extract_response_text(final_response)
+    raise AssertionError("Responses completion exhausted retries unexpectedly.")
 
 
 def complete_text_prompt(
@@ -1375,7 +1444,9 @@ def login(
 
     if existing and not force:
         raise CopilotError(
-            f"Cached credentials already exist at {credentials_path()}. Re-run with --force to replace them."
+            "Cached credentials already exist at "
+            f"{credentials_path()}. "
+            "Re-run with --force to replace them."
         )
 
     domain = normalized_domain or DEFAULT_GITHUB_DOMAIN

git_copilot_commit/prompts/split-commit-planner-prompt.md

@@ -7,7 +7,6 @@ small number of coherent commits.
 
 - Produce commit groupings that keep related changes together.
 - Separate clearly unrelated changes when the staged units support it.
-- Prefer fewer commits when the relationship is ambiguous.
 
 ## Rules
 

git_copilot_commit/settings.py

@@ -3,6 +3,7 @@ Settings management using platformdirs for cross-platform directory paths.
 """
 
 import json
+import warnings
 from typing import Any
 
 from platformdirs import (
@@ -50,10 +51,15 @@ class Settings:
     def _save_config(self) -> None:
         """Save configuration to file."""
         try:
-            with open(self.config_file, "w") as f:
+            with open(self.config_file, "w", encoding="utf-8") as f:
                 json.dump(self._config, f, indent=2)
-        except IOError:
-            pass  # Silently fail if we can't write
+                f.write("\n")
+        except OSError as exc:
+            warnings.warn(
+                f"Could not save config to {self.config_file}: {exc}",
+                RuntimeWarning,
+                stacklevel=2,
+            )
 
     def get(self, key: str, default: Any = None) -> Any:
         """Get a configuration value."""

git_copilot_commit/split_commits.py

@@ -8,26 +8,12 @@ from typing import Any, Iterable, Sequence, cast
 from .git import GitFile, GitStatus
 
 DIFF_HEADER_PREFIX = "diff --git "
-AUTO_SPLIT_UNIT_THRESHOLD = 3
-AUTO_SPLIT_PATH_THRESHOLD = 4
 
 
 class SplitPlanningError(ValueError):
     """Raised when a split-commit plan cannot be built or validated."""
 
 
-class SplitCommitLimitExceededError(SplitPlanningError):
-    """Raised when the planner returns a valid plan above the configured limit."""
-
-    def __init__(self, plan: "SplitCommitPlan", max_commits: int) -> None:
-        self.plan = plan
-        self.max_commits = max_commits
-        self.actual_commits = len(plan.commits)
-        super().__init__(
-            f"Planner returned {self.actual_commits} commits, exceeding the max of {max_commits}."
-        )
-
-
 @dataclass(frozen=True, slots=True)
 class FilePatch:
     """Structured representation of a single file-level diff patch."""
@@ -69,33 +55,6 @@ class SplitCommitPlan:
     commits: tuple[SplitPlanCommit, ...]
 
 
-def evaluate_auto_split(patch_units: Sequence[PatchUnit]) -> tuple[bool, str]:
-    """Return whether automatic split planning should run for the patch set."""
-    if len(patch_units) < 2:
-        return False, "fewer than two independent patch units were found"
-
-    kinds = {unit.kind for unit in patch_units}
-    staged_statuses = {unit.staged_status for unit in patch_units}
-    paths = {unit.path for unit in patch_units}
-
-    if len(patch_units) >= AUTO_SPLIT_UNIT_THRESHOLD:
-        return True, f"found {len(patch_units)} independent patch units"
-
-    if len(kinds) >= 2:
-        return True, f"found mixed change kinds ({', '.join(sorted(kinds))})"
-
-    if len(staged_statuses) >= 2:
-        return True, (
-            "found mixed staged change types "
-            f"({', '.join(sorted(staged_statuses))})"
-        )
-
-    if len(paths) >= AUTO_SPLIT_PATH_THRESHOLD:
-        return True, f"found changes across {len(paths)} files"
-
-    return False, f"found only {len(patch_units)} similar patch units"
-
-
 def extract_patch_units(diff_text: str) -> list[PatchUnit]:
     """Convert a staged diff into patch units suitable for split planning."""
     units: list[PatchUnit] = []
@@ -212,13 +171,14 @@ def build_split_plan_prompt(
     status: GitStatus,
     patch_units: Sequence[PatchUnit],
     *,
-    max_commits: int,
     preferred_commits: int | None = None,
     context: str = "",
 ) -> str:
     """Build the user prompt used to request a split-commit plan."""
     if not patch_units:
-        raise SplitPlanningError("Cannot plan split commits without staged patch units.")
+        raise SplitPlanningError(
+            "Cannot plan split commits without staged patch units."
+        )
 
     prompt_parts = []
     if context.strip():
@@ -226,7 +186,6 @@ def build_split_plan_prompt(
 
     if preferred_commits is not None:
         prompt_parts.append(f"Preferred commits: {preferred_commits}")
-    prompt_parts.append(f"Maximum commits: {max_commits}")
 
     prompt_parts.extend(
         [
@@ -256,8 +215,6 @@ def build_split_plan_prompt(
 def parse_split_plan_response(
     response_text: str,
     patch_units: Sequence[PatchUnit],
-    *,
-    max_commits: int,
 ) -> SplitCommitPlan:
     """Parse and validate the planner model's JSON response."""
     payload = parse_json_payload(response_text)
@@ -269,7 +226,9 @@ def parse_split_plan_response(
         commits_data = payload
 
     if not isinstance(commits_data, list) or not commits_data:
-        raise SplitPlanningError("Planner response did not include a non-empty commits list.")
+        raise SplitPlanningError(
+            "Planner response did not include a non-empty commits list."
+        )
 
     units_by_id = {unit.id: unit for unit in patch_units}
     expected_ids = set(units_by_id)
@@ -305,7 +264,9 @@ def parse_split_plan_response(
             seen_in_commit.add(unit_id)
             unit_ids.append(unit_id)
 
-        ordered_unit_ids = tuple(sorted(unit_ids, key=lambda unit_id: units_by_id[unit_id].order))
+        ordered_unit_ids = tuple(
+            sorted(unit_ids, key=lambda unit_id: units_by_id[unit_id].order)
+        )
         validated_commits.append(SplitPlanCommit(unit_ids=ordered_unit_ids))
         assigned_ids.extend(unit_ids)
 
@@ -326,8 +287,6 @@ def parse_split_plan_response(
         )
 
     plan = SplitCommitPlan(commits=tuple(validated_commits))
-    if len(plan.commits) > max_commits:
-        raise SplitCommitLimitExceededError(plan, max_commits)
 
     return plan
 
@@ -354,7 +313,9 @@ def build_status_for_patch_units(patch_units: Sequence[PatchUnit]) -> GitStatus:
         if file_key in seen_paths:
             continue
         seen_paths.add(file_key)
-        files.append(GitFile(path=unit.path, status=" ", staged_status=unit.staged_status))
+        files.append(
+            GitFile(path=unit.path, status=" ", staged_status=unit.staged_status)
+        )
 
     return GitStatus(
         files=files,
@@ -397,7 +358,9 @@ def parse_diff_paths(diff_header_line: str) -> tuple[str, str]:
     try:
         parts = shlex.split(diff_header_line)
     except ValueError as exc:
-        raise SplitPlanningError(f"Could not parse diff header: {diff_header_line}") from exc
+        raise SplitPlanningError(
+            f"Could not parse diff header: {diff_header_line}"
+        ) from exc
 
     if len(parts) < 4:
         raise SplitPlanningError(f"Unexpected diff header: {diff_header_line}")
@@ -419,10 +382,16 @@ def classify_file_patch(
     hunks: Sequence[str],
 ) -> tuple[str, str]:
     """Infer the staged status and planning kind for a file patch."""
-    if any(line.startswith("GIT binary patch") or line.startswith("Binary files ") for line in lines):
+    if any(
+        line.startswith("GIT binary patch") or line.startswith("Binary files ")
+        for line in lines
+    ):
         return "M", "binary"
 
-    if any(line.startswith("rename from ") or line.startswith("rename to ") for line in lines):
+    if any(
+        line.startswith("rename from ") or line.startswith("rename to ")
+        for line in lines
+    ):
         return "R", "rename"
 
     if any(line.startswith("new file mode ") for line in lines):
@@ -431,7 +400,9 @@ def classify_file_patch(
     if any(line.startswith("deleted file mode ") for line in lines):
         return "D", "deleted_file"
 
-    if any(line.startswith("old mode ") or line.startswith("new mode ") for line in lines):
+    if any(
+        line.startswith("old mode ") or line.startswith("new mode ") for line in lines
+    ):
         return "M", "mode_change"
 
     if old_path == "/dev/null":

{git_copilot_commit-0.5.0.dist-info → git_copilot_commit-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: git-copilot-commit
-Version: 0.5.0
+Version: 0.5.2
 Summary: Automatically generate and commit changes using GitHub Copilot
 Author-email: Dheepak Krishnamurthy <1813121+kdheepak@users.noreply.github.com>
 License-File: LICENSE
@@ -14,6 +14,10 @@ Description-Content-Type: text/markdown
 
 # `git-copilot-commit`
 
+[![CI](https://img.shields.io/github/actions/workflow/status/kdheepak/git-copilot-commit/ci.yml?branch=main&label=CI)](https://github.com/kdheepak/git-copilot-commit/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/git-copilot-commit)](https://pypi.org/project/git-copilot-commit/)
+[![License](https://img.shields.io/github/license/kdheepak/git-copilot-commit)](https://github.com/kdheepak/git-copilot-commit/blob/main/LICENSE)
+
 AI-powered Git commit assistant that generates conventional commit messages using GitHub Copilot.
 
 ![Screenshot of git-copilot-commit in action](https://github.com/user-attachments/assets/6a6d70a6-6060-44e6-8cf4-a6532e9e9142)
@@ -21,13 +25,13 @@ AI-powered Git commit assistant that generates conventional commit messages usin
 ## Features
 
 - Generates commit messages based on your staged changes
-- Supports multiple AI models: GPT-4, Claude, Gemini, and more
+- Supports multiple LLM models: GPT-4, Claude, Gemini, and more
 - Allows editing of generated messages before committing
 - Follows the [Conventional Commits](https://www.conventionalcommits.org/) standard
 
 ## Installation
 
-### Install the tool using [`uv`] (recommended)
+### Install the tool using [`uv`]
 
 Install [`uv`]:
 
@@ -39,14 +43,15 @@ curl -LsSf https://astral.sh/uv/install.sh | sh
 powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 ```
 
-You can install and run the latest version of tool directly every time by invoking this one command:
+You can run the latest version of tool directly every time by invoking this one command:
 
 ```bash
-# Install latest version into temporary environment and run --help
+# Every invocation installs latest version into temporary environment and runs --help
 uvx git-copilot-commit --help
 ```
 
-Alternatively, you can install into a global isolated environment and run `git-copilot-commit`:
+Alternatively, you can install the tool once into a global isolated environment 
+and run `git-copilot-commit` to invoke it:
 
 ```bash
 # Install into global isolated environment
@@ -58,14 +63,6 @@ git-copilot-commit --help
 
 [`uv`]: https://github.com/astral-sh/uv
 
-### Install with `pipx`
-
-If you prefer to use `pipx`:
-
-```bash
-pipx install git-copilot-commit
-```
-
 ## Prerequisites
 
 - Active GitHub Copilot subscription
@@ -100,17 +97,26 @@ pipx install git-copilot-commit
 
 ```bash
 $ uvx git-copilot-commit commit --help
-Usage: git-copilot-commit commit [OPTIONS]
 
-  Automatically commit changes in the current git repository.
-
-Options:
-  -a, --all         Stage all files before committing
-  --split           Split staged hunks into multiple commits. Use
-                    `--split=N` to prefer up to N commits.
-  -m, --model TEXT  Model to use for generating commit message
-  -y, --yes         Automatically accept the generated commit message
-  --help            Show this message and exit.
+ Usage: git-copilot-commit commit [OPTIONS]
+
+ Generate commit message based on changes in the current git repository and commit them.
+
+╭─ Options ────────────────────────────────────────────────────────────────────────────────────────────────╮
+│ --all         -a                               Stage all files before committing                         │
+│ --split                                        Split staged hunks into multiple commits automatically.   │
+│                                                Pass `--split=N` to express a preference for N commits.   │
+│ --model       -m                     MODEL_ID  Model to use for generating commit message                │
+│ --yes         -y                               Automatically accept the generated commit message         │
+│ --context     -c                     TEXT      Optional user-provided context to guide commit message    │
+│ --ca-bundle                          PATH      Path to a custom CA bundle (PEM)                          │
+│ --insecure                                     Disable SSL certificate verification.                     │
+│ --native-tls      --no-native-tls              Use the OS's native certificate store via 'truststore'    │
+│                                                for httpx instead of the Python bundle. Ignored if        │
+│                                                --ca-bundle or --insecure is used.                        │
+│                                                [default: no-native-tls]                                  │
+│ --help                                         Show this message and exit.                               │
+╰──────────────────────────────────────────────────────────────────────────────────────────────────────────╯
 ```
 
 ## Examples
@@ -139,7 +145,7 @@ Split staged hunks into separate commits:
 uvx git-copilot-commit commit --split
 ```
 
-Prefer up to two commits:
+Prefer two commits:
 
 ```bash
 uvx git-copilot-commit commit --split 2
@@ -194,3 +200,6 @@ git ai-commit --all --yes --model claude-3.5-sonnet
 > ```bash
 > git config --global diff.context 3
 > ```
+>
+> This may be useful because this tool sends the diffs with surrounding context 
+> to the LLM for generating a commit message

git_copilot_commit-0.5.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+git_copilot_commit/__init__.py,sha256=v3x5oBkxwKJEZLv62QqSmP3iqNKLtZgrWZfH8eFzlQg,60
+git_copilot_commit/cli.py,sha256=CyiGMEehjLc-J3OveVxXUK7mzPWpiwQgkSSB3IhSzoc,29910
+git_copilot_commit/git.py,sha256=vNuh2j8TGmocLio4XgPpbXIktlgczNdEt2Fg1c40wuk,14962
+git_copilot_commit/github_copilot.py,sha256=0CF8bnawxW6Bn5g7R7mbceFG4SCcMiueMOp4x8Vtqs8,49657
+git_copilot_commit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+git_copilot_commit/settings.py,sha256=WrM10_J3F7QBfOVmPDWpNZrNHhmZSeN-9FqQZxgdWvQ,3730
+git_copilot_commit/split_commits.py,sha256=sGk5xfAvTeRcnW4XQvvyNVgYGsAFNntkk-JuVXb8Y6Y,14851
+git_copilot_commit/version.py,sha256=AieHOUX52g6N67HL0iLWtDKrgOYyulxwHWViu26Jrd4,105
+git_copilot_commit/prompts/commit-message-generator-prompt.md,sha256=EHAS6w15vLQ-kgT1N7nPG2nWqdeTmlHje_kN9yZIoZQ,2378
+git_copilot_commit/prompts/split-commit-planner-prompt.md,sha256=ABKuVVyrkHsb3QV6qyS--W5yvKBoZhtq8xJEb3OZQvI,1088
+git_copilot_commit-0.5.2.dist-info/METADATA,sha256=wc5CFa1ed8A4vbY3B01AsmsHia4jIoEU-5j2-OnaZEA,6649
+git_copilot_commit-0.5.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+git_copilot_commit-0.5.2.dist-info/entry_points.txt,sha256=-D4bQqiuSPwQJG2zx--vJbZD1iqB5coUfoJ_gmC3rSg,66
+git_copilot_commit-0.5.2.dist-info/licenses/LICENSE,sha256=14lNZAoKJPI1U7eGpletjN_PFm1JwP1vT_0jFKY6eWg,1065
+git_copilot_commit-0.5.2.dist-info/RECORD,,

git_copilot_commit-0.5.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-git_copilot_commit/__init__.py,sha256=v3x5oBkxwKJEZLv62QqSmP3iqNKLtZgrWZfH8eFzlQg,60
-git_copilot_commit/cli.py,sha256=FlzcgE-FNO8Mu2v0z-BXAs8f2WC-y4uKSior0zPmhMs,31204
-git_copilot_commit/git.py,sha256=GtLkE177Dm3l-zvsslSrAyqshxPeeSEidniwhTmCbyw,13845
-git_copilot_commit/github_copilot.py,sha256=D6BWqjX-hLHqw7vbfIO2p3rSeWbI5peAzqDyfKB9l2g,46822
-git_copilot_commit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-git_copilot_commit/settings.py,sha256=hDesxrMptuceIVeuwGeLe74WwbWHmTLCKo0h4CDWY-I,3537
-git_copilot_commit/split_commits.py,sha256=tq--WYaOz6VVSP6y1r-HQ9q0pDLP7tRpNaxwqsGyvdQ,16434
-git_copilot_commit/version.py,sha256=AieHOUX52g6N67HL0iLWtDKrgOYyulxwHWViu26Jrd4,105
-git_copilot_commit/prompts/commit-message-generator-prompt.md,sha256=EHAS6w15vLQ-kgT1N7nPG2nWqdeTmlHje_kN9yZIoZQ,2378
-git_copilot_commit/prompts/split-commit-planner-prompt.md,sha256=YS9XgXoHs-utyGvvpHxnTAReCRAlOyRHkYxtpDw88pY,1147
-git_copilot_commit-0.5.0.dist-info/METADATA,sha256=6Pjb8mroHvY9HwzkgwmXa1HPBpGabUvunL3UOfxkBTk,4399
-git_copilot_commit-0.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-git_copilot_commit-0.5.0.dist-info/entry_points.txt,sha256=-D4bQqiuSPwQJG2zx--vJbZD1iqB5coUfoJ_gmC3rSg,66
-git_copilot_commit-0.5.0.dist-info/licenses/LICENSE,sha256=14lNZAoKJPI1U7eGpletjN_PFm1JwP1vT_0jFKY6eWg,1065
-git_copilot_commit-0.5.0.dist-info/RECORD,,