gac 2.2.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "2.2.0"
+__version__ = "2.4.0"

gac/ai.py

@@ -42,6 +42,8 @@ def generate_commit_message(
     max_tokens: int = EnvDefaults.MAX_OUTPUT_TOKENS,
     max_retries: int = EnvDefaults.MAX_RETRIES,
     quiet: bool = False,
+    is_group: bool = False,
+    skip_success_message: bool = False,
 ) -> str:
     """Generate a commit message using direct API calls to AI providers.
 
@@ -116,6 +118,8 @@ def generate_commit_message(
             max_tokens=max_tokens,
             max_retries=max_retries,
             quiet=quiet,
+            is_group=is_group,
+            skip_success_message=skip_success_message,
         )
     except AIError:
         # Re-raise AIError exceptions as-is to preserve error classification
@@ -123,3 +127,25 @@ def generate_commit_message(
     except Exception as e:
         logger.error(f"Failed to generate commit message: {e}")
         raise AIError.model_error(f"Failed to generate commit message: {e}") from e
+
+
+def generate_grouped_commits(
+    model: str,
+    prompt: list[dict[str, str]],
+    temperature: float,
+    max_tokens: int,
+    max_retries: int,
+    quiet: bool = False,
+    skip_success_message: bool = False,
+) -> str:
+    """Generate grouped commits JSON response."""
+    return generate_commit_message(
+        model=model,
+        prompt=prompt,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=max_retries,
+        quiet=quiet,
+        is_group=True,
+        skip_success_message=skip_success_message,
+    )

gac/ai_utils.py

@@ -83,6 +83,8 @@ def generate_with_retries(
     max_tokens: int,
     max_retries: int,
     quiet: bool = False,
+    is_group: bool = False,
+    skip_success_message: bool = False,
 ) -> str:
     """Generate content with retry logic using direct API calls."""
     # Parse model string to determine provider and actual model
@@ -121,10 +123,11 @@ def generate_with_retries(
         raise AIError.model_error("No messages provided for AI generation")
 
     # Set up spinner
+    message_type = "commit messages" if is_group else "commit message"
     if quiet:
         spinner = None
     else:
-        spinner = Halo(text=f"Generating commit message with {provider} {model_name}...", spinner="dots")
+        spinner = Halo(text=f"Generating {message_type} with {provider} {model_name}...", spinner="dots")
         spinner.start()
 
     last_exception = None
@@ -132,7 +135,7 @@ def generate_with_retries(
 
     for attempt in range(max_retries):
         try:
-            if not quiet and attempt > 0:
+            if not quiet and not skip_success_message and attempt > 0:
                 if spinner:
                     spinner.text = f"Retry {attempt + 1}/{max_retries} with {provider} {model_name}..."
                 logger.info(f"Retry attempt {attempt + 1}/{max_retries}")
@@ -145,7 +148,10 @@ def generate_with_retries(
             content = provider_func(model=model_name, messages=messages, temperature=temperature, max_tokens=max_tokens)
 
             if spinner:
-                spinner.succeed(f"Generated commit message with {provider} {model_name}")
+                if skip_success_message:
+                    spinner.stop()  # Stop spinner without showing success/failure
+                else:
+                    spinner.succeed(f"Generated {message_type} with {provider} {model_name}")
 
             if content is not None and content.strip():
                 return content.strip()  # type: ignore[no-any-return]
@@ -160,8 +166,8 @@ def generate_with_retries(
 
             # For authentication and model errors, don't retry
             if error_type in ["authentication", "model"]:
-                if spinner:
-                    spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+                if spinner and not skip_success_message:
+                    spinner.fail(f"Failed to generate {message_type} with {provider} {model_name}")
 
                 # Create the appropriate error type based on classification
                 if error_type == "authentication":
@@ -172,23 +178,32 @@ def generate_with_retries(
             if attempt < max_retries - 1:
                 # Exponential backoff
                 wait_time = 2**attempt
-                if not quiet:
-                    logger.warning(f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}")
-
-                if spinner:
+                if not quiet and not skip_success_message:
+                    if attempt == 0:
+                        logger.warning(f"AI generation failed, retrying in {wait_time}s: {str(e)}")
+                    else:
+                        logger.warning(
+                            f"AI generation failed (attempt {attempt + 1}), retrying in {wait_time}s: {str(e)}"
+                        )
+
+                if spinner and not skip_success_message:
                     for i in range(wait_time, 0, -1):
                         spinner.text = f"Retry {attempt + 1}/{max_retries} in {i}s..."
                         time.sleep(1)
                 else:
                     time.sleep(wait_time)
             else:
-                logger.error(f"AI generation failed after {max_retries} attempts: {str(e)}")
+                num_retries = max_retries
+                retry_word = "retry" if num_retries == 1 else "retries"
+                logger.error(f"AI generation failed after {num_retries} {retry_word}: {str(e)}")
 
-    if spinner:
-        spinner.fail(f"Failed to generate commit message with {provider} {model_name}")
+    if spinner and not skip_success_message:
+        spinner.fail(f"Failed to generate {message_type} with {provider} {model_name}")
 
     # If we get here, all retries failed - use the last classified error type
-    error_message = f"Failed to generate commit message after {max_retries} attempts"
+    num_retries = max_retries
+    retry_word = "retry" if num_retries == 1 else "retries"
+    error_message = f"Failed to generate {message_type} after {num_retries} {retry_word}"
     if last_error_type == "authentication":
         raise AIError.authentication_error(error_message) from last_exception
     elif last_error_type == "rate_limit":

gac/cli.py

@@ -17,6 +17,7 @@ from gac.constants import Languages, Logging
 from gac.diff_cli import diff as diff_cli
 from gac.errors import handle_error
 from gac.init_cli import init as init_cli
+from gac.init_cli import model as model_cli
 from gac.language_cli import language as language_cli
 from gac.main import main
 from gac.utils import setup_logging
@@ -28,6 +29,7 @@ logger = logging.getLogger(__name__)
 @click.group(invoke_without_command=True, context_settings={"ignore_unknown_options": True})
 # Git workflow options
 @click.option("--add-all", "-a", is_flag=True, help="Stage all changes before committing")
+@click.option("--group", "-g", is_flag=True, help="Group changes into multiple logical commits")
 @click.option("--push", "-p", is_flag=True, help="Push changes to remote after committing")
 @click.option("--dry-run", is_flag=True, help="Dry run the commit workflow")
 @click.option("--yes", "-y", is_flag=True, help="Skip confirmation prompt")
@@ -70,6 +72,7 @@ logger = logging.getLogger(__name__)
 def cli(
     ctx: click.Context,
     add_all: bool = False,
+    group: bool = False,
     log_level: str = str(config["log_level"]),
     one_liner: bool = False,
     push: bool = False,
@@ -109,6 +112,7 @@ def cli(
         try:
             main(
                 stage_all=add_all,
+                group=group,
                 model=model,
                 hint=hint,
                 one_liner=one_liner,
@@ -131,6 +135,7 @@ def cli(
 
         ctx.obj = {
             "add_all": add_all,
+            "group": group,
             "log_level": log_level,
             "one_liner": one_liner,
             "push": push,
@@ -150,9 +155,10 @@ def cli(
 
 
 cli.add_command(config_cli)
+cli.add_command(diff_cli)
 cli.add_command(init_cli)
 cli.add_command(language_cli)
-cli.add_command(diff_cli)
+cli.add_command(model_cli)
 
 
 @click.command(context_settings=language_cli.context_settings)

gac/config.py

@@ -41,6 +41,7 @@ def load_config() -> dict[str, str | int | float | bool | None]:
         "system_prompt_path": os.getenv("GAC_SYSTEM_PROMPT_PATH"),
         "language": os.getenv("GAC_LANGUAGE"),
         "translate_prefixes": os.getenv("GAC_TRANSLATE_PREFIXES", "false").lower() in ("true", "1", "yes", "on"),
+        "rtl_confirmed": os.getenv("GAC_RTL_CONFIRMED", "false").lower() in ("true", "1", "yes", "on"),
     }
 
     return config

gac/constants.py

@@ -20,7 +20,7 @@ class EnvDefaults:
 
     MAX_RETRIES: int = 3
     TEMPERATURE: float = 1
-    MAX_OUTPUT_TOKENS: int = 1024  # includes reasoning tokens
+    MAX_OUTPUT_TOKENS: int = 4096  # includes reasoning tokens
     WARNING_LIMIT_TOKENS: int = 32768
     ALWAYS_INCLUDE_SCOPE: bool = False
     SKIP_SECRET_SCAN: bool = False

gac/git.py

@@ -14,6 +14,63 @@ from gac.utils import run_subprocess
 logger = logging.getLogger(__name__)
 
 
+def run_subprocess_with_encoding_fallback(
+    command: list[str], silent: bool = False, timeout: int = 60
+) -> subprocess.CompletedProcess:
+    """Run subprocess with encoding fallback, returning full CompletedProcess object.
+
+    This is used for cases where we need both stdout and stderr separately,
+    like pre-commit and lefthook hook execution.
+
+    Args:
+        command: List of command arguments
+        silent: If True, suppress debug logging
+        timeout: Command timeout in seconds
+
+    Returns:
+        CompletedProcess object with stdout, stderr, and returncode
+    """
+    from gac.utils import get_safe_encodings
+
+    encodings = get_safe_encodings()
+    last_exception = None
+
+    for encoding in encodings:
+        try:
+            if not silent:
+                logger.debug(f"Running command: {' '.join(command)} (encoding: {encoding})")
+
+            result = subprocess.run(
+                command,
+                capture_output=True,
+                text=True,
+                check=False,
+                timeout=timeout,
+                encoding=encoding,
+                errors="replace",
+            )
+            return result
+        except UnicodeError as e:
+            last_exception = e
+            if not silent:
+                logger.debug(f"Failed to decode with {encoding}: {e}")
+            continue
+        except subprocess.TimeoutExpired:
+            raise
+        except Exception as e:
+            if not silent:
+                logger.debug(f"Command error: {e}")
+            # Try next encoding for non-timeout errors
+            last_exception = e
+            continue
+
+    # If we get here, all encodings failed
+    if last_exception:
+        raise subprocess.CalledProcessError(1, command, "", f"Encoding error: {last_exception}") from last_exception
+    else:
+        raise subprocess.CalledProcessError(1, command, "", "All encoding attempts failed")
+
+
 def run_git_command(args: list[str], silent: bool = False, timeout: int = 30) -> str:
     """Run a git command and return the output."""
     command = ["git"] + args
@@ -50,6 +107,48 @@ def get_staged_files(file_type: str | None = None, existing_only: bool = False)
         return []
 
 
+def get_staged_status() -> str:
+    """Get formatted status of staged files only, excluding unstaged/untracked files.
+
+    Returns:
+        Formatted status string with M/A/D/R indicators
+    """
+    try:
+        output = run_git_command(["diff", "--name-status", "--staged"])
+        if not output:
+            return "No changes staged for commit."
+
+        status_map = {
+            "M": "modified",
+            "A": "new file",
+            "D": "deleted",
+            "R": "renamed",
+            "C": "copied",
+            "T": "typechange",
+        }
+
+        status_lines = ["Changes to be committed:"]
+        for line in output.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+
+            # Parse status line (e.g., "M\tfile.py" or "R100\told.py\tnew.py")
+            parts = line.split("\t")
+            if len(parts) < 2:
+                continue
+
+            change_type = parts[0][0]  # First char is the status (M, A, D, R, etc.)
+            file_path = parts[-1]  # Last part is the new/current file path
+
+            status_label = status_map.get(change_type, "modified")
+            status_lines.append(f"\t{status_label}:   {file_path}")
+
+        return "\n".join(status_lines)
+    except GitError:
+        return "No changes staged for commit."
+
+
 def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None, commit2: str | None = None) -> str:
     """Get the diff between commits or working tree.
 
@@ -90,20 +189,20 @@ def get_diff(staged: bool = True, color: bool = True, commit1: str | None = None
 
 def get_repo_root() -> str:
     """Get absolute path of repository root."""
-    result = subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "--show-toplevel"])
+    return result
 
 
 def get_current_branch() -> str:
     """Get name of current git branch."""
-    result = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "--abbrev-ref", "HEAD"])
+    return result
 
 
 def get_commit_hash() -> str:
     """Get SHA-1 hash of current commit."""
-    result = subprocess.check_output(["git", "rev-parse", "HEAD"])
-    return result.decode().strip()
+    result = run_git_command(["rev-parse", "HEAD"])
+    return result
 
 
 def run_pre_commit_hooks() -> bool:
@@ -128,7 +227,7 @@ def run_pre_commit_hooks() -> bool:
         # Run pre-commit hooks on staged files
         logger.info("Running pre-commit hooks...")
         # Run pre-commit and capture both stdout and stderr
-        result = subprocess.run(["pre-commit", "run"], capture_output=True, text=True, check=False)
+        result = run_subprocess_with_encoding_fallback(["pre-commit", "run"])
 
         if result.returncode == 0:
             # All hooks passed
@@ -178,7 +277,7 @@ def run_lefthook_hooks() -> bool:
         # Run lefthook hooks on staged files
         logger.info("Running Lefthook hooks...")
         # Run lefthook and capture both stdout and stderr
-        result = subprocess.run(["lefthook", "run", "pre-commit"], capture_output=True, text=True, check=False)
+        result = run_subprocess_with_encoding_fallback(["lefthook", "run", "pre-commit"])
 
         if result.returncode == 0:
             # All hooks passed