gac 1.13.1__py3-none-any.whl → 1.15.0__py3-none-any.whl

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "1.13.1"
+__version__ = "1.15.0"

gac/cli.py

@@ -13,10 +13,11 @@ import click
 from gac import __version__
 from gac.config import load_config
 from gac.config_cli import config as config_cli
-from gac.constants import Logging
+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.language_cli import language as language_cli
 from gac.main import main
 from gac.utils import setup_logging
 
@@ -43,6 +44,9 @@ logger = logging.getLogger(__name__)
 @click.option("--hint", "-h", default="", help="Additional context to include in the prompt")
 # Model options
 @click.option("--model", "-m", help="Override the default model (format: 'provider:model_name')")
+@click.option(
+    "--language", "-l", help="Override the language for commit messages (e.g., 'Spanish', 'es', 'zh-CN', 'ja')"
+)
 # Output options
 @click.option("--quiet", "-q", is_flag=True, help="Suppress non-error output")
 @click.option(
@@ -75,6 +79,7 @@ def cli(
     yes: bool = False,
     hint: str = "",
     model: str | None = None,
+    language: str | None = None,
     version: bool = False,
     dry_run: bool = False,
     verbose: bool = False,
@@ -98,6 +103,9 @@ def cli(
         # Determine if verbose mode should be enabled based on -v flag or verbose config setting
         use_verbose = bool(verbose or config.get("verbose", False))
 
+        # Resolve language code to full name if provided
+        resolved_language = Languages.resolve_code(language) if language else None
+
         try:
             main(
                 stage_all=add_all,
@@ -113,6 +121,7 @@ def cli(
                 verbose=use_verbose,
                 no_verify=no_verify,
                 skip_secret_scan=skip_secret_scan or bool(config.get("skip_secret_scan", False)),
+                language=resolved_language,
             )
         except Exception as e:
             handle_error(e, exit_program=True)
@@ -131,6 +140,7 @@ def cli(
             "yes": yes,
             "hint": hint,
             "model": model,
+            "language": language,
             "version": version,
             "dry_run": dry_run,
             "verbose": verbose,
@@ -141,6 +151,7 @@ def cli(
 
 cli.add_command(config_cli)
 cli.add_command(init_cli)
+cli.add_command(language_cli)
 cli.add_command(diff_cli)
 
 if __name__ == "__main__":

gac/config.py

@@ -38,6 +38,9 @@ def load_config() -> dict[str, str | int | float | bool | None]:
         "skip_secret_scan": os.getenv("GAC_SKIP_SECRET_SCAN", str(EnvDefaults.SKIP_SECRET_SCAN)).lower()
         in ("true", "1", "yes", "on"),
         "verbose": os.getenv("GAC_VERBOSE", str(EnvDefaults.VERBOSE)).lower() in ("true", "1", "yes", "on"),
+        "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"),
     }
 
     return config

gac/constants.py

@@ -150,3 +150,139 @@ class CodePatternImportance:
         r"\+\s*(test|describe|it|should)\s*\(": 1.1,  # Test definitions
         r"\+\s*(assert|expect)": 1.0,  # Assertions
     }
+
+
+class Languages:
+    """Language code mappings and utilities."""
+
+    # Language code to full name mapping
+    # Supports ISO 639-1 codes and common variants
+    CODE_MAP: dict[str, str] = {
+        # English
+        "en": "English",
+        # Chinese
+        "zh": "Simplified Chinese",
+        "zh-cn": "Simplified Chinese",
+        "zh-hans": "Simplified Chinese",
+        "zh-tw": "Traditional Chinese",
+        "zh-hant": "Traditional Chinese",
+        # Japanese
+        "ja": "Japanese",
+        # Korean
+        "ko": "Korean",
+        # Spanish
+        "es": "Spanish",
+        # Portuguese
+        "pt": "Portuguese",
+        # French
+        "fr": "French",
+        # German
+        "de": "German",
+        # Russian
+        "ru": "Russian",
+        # Hindi
+        "hi": "Hindi",
+        # Italian
+        "it": "Italian",
+        # Polish
+        "pl": "Polish",
+        # Turkish
+        "tr": "Turkish",
+        # Dutch
+        "nl": "Dutch",
+        # Vietnamese
+        "vi": "Vietnamese",
+        # Thai
+        "th": "Thai",
+        # Indonesian
+        "id": "Indonesian",
+        # Swedish
+        "sv": "Swedish",
+        # Arabic
+        "ar": "Arabic",
+        # Hebrew
+        "he": "Hebrew",
+        # Greek
+        "el": "Greek",
+        # Danish
+        "da": "Danish",
+        # Norwegian
+        "no": "Norwegian",
+        "nb": "Norwegian",
+        "nn": "Norwegian",
+        # Finnish
+        "fi": "Finnish",
+    }
+
+    @staticmethod
+    def resolve_code(language: str) -> str:
+        """Resolve a language code to its full name.
+
+        Args:
+            language: Language name or code (e.g., 'Spanish', 'es', 'zh-CN')
+
+        Returns:
+            Full language name (e.g., 'Spanish', 'Simplified Chinese')
+
+        If the input is already a full language name, it's returned as-is.
+        If it's a recognized code, it's converted to the full name.
+        Otherwise, the input is returned unchanged (for custom languages).
+        """
+        # Normalize the code to lowercase for lookup
+        code_lower = language.lower().strip()
+
+        # Check if it's a recognized code
+        if code_lower in Languages.CODE_MAP:
+            return Languages.CODE_MAP[code_lower]
+
+        # Return as-is (could be a full name or custom language)
+        return language
+
+
+class CommitMessageConstants:
+    """Constants for commit message generation and cleaning."""
+
+    # Conventional commit type prefixes
+    CONVENTIONAL_PREFIXES: list[str] = [
+        "feat",
+        "fix",
+        "docs",
+        "style",
+        "refactor",
+        "perf",
+        "test",
+        "build",
+        "ci",
+        "chore",
+    ]
+
+    # XML tags that may leak from prompt templates into AI responses
+    XML_TAGS_TO_REMOVE: list[str] = [
+        "<git-status>",
+        "</git-status>",
+        "<git_status>",
+        "</git_status>",
+        "<git-diff>",
+        "</git-diff>",
+        "<git_diff>",
+        "</git_diff>",
+        "<repository_context>",
+        "</repository_context>",
+        "<instructions>",
+        "</instructions>",
+        "<format>",
+        "</format>",
+        "<conventions>",
+        "</conventions>",
+    ]
+
+    # Indicators that mark the start of the actual commit message in AI responses
+    COMMIT_INDICATORS: list[str] = [
+        "# Your commit message:",
+        "Your commit message:",
+        "The commit message is:",
+        "Here's the commit message:",
+        "Commit message:",
+        "Final commit message:",
+        "# Commit Message",
+    ]

gac/init_cli.py

@@ -151,4 +151,79 @@ def init() -> None:
     elif is_ollama or is_lmstudio:
         click.echo("Skipping API key. You can add one later if needed.")
 
+    # Language selection
+    click.echo("\n")
+    languages = [
+        ("English", "English"),
+        ("简体中文", "Simplified Chinese"),
+        ("繁體中文", "Traditional Chinese"),
+        ("日本語", "Japanese"),
+        ("한국어", "Korean"),
+        ("Español", "Spanish"),
+        ("Português", "Portuguese"),
+        ("Français", "French"),
+        ("Deutsch", "German"),
+        ("Русский", "Russian"),
+        ("हिन्दी", "Hindi"),
+        ("Italiano", "Italian"),
+        ("Polski", "Polish"),
+        ("Türkçe", "Turkish"),
+        ("Nederlands", "Dutch"),
+        ("Tiếng Việt", "Vietnamese"),
+        ("ไทย", "Thai"),
+        ("Bahasa Indonesia", "Indonesian"),
+        ("Svenska", "Swedish"),
+        ("العربية", "Arabic"),
+        ("עברית", "Hebrew"),
+        ("Ελληνικά", "Greek"),
+        ("Dansk", "Danish"),
+        ("Norsk", "Norwegian"),
+        ("Suomi", "Finnish"),
+        ("Custom", "Custom"),
+    ]
+
+    display_names = [lang[0] for lang in languages]
+    language_selection = questionary.select(
+        "Select a language for commit messages:", choices=display_names, use_shortcuts=True, use_arrow_keys=True
+    ).ask()
+
+    if not language_selection:
+        click.echo("Language selection cancelled. Using English (default).")
+    elif language_selection == "English":
+        click.echo("Set language to English (default)")
+    else:
+        # Handle custom input
+        if language_selection == "Custom":
+            custom_language = questionary.text("Enter the language name (e.g., 'Spanish', 'Français', '日本語'):").ask()
+            if not custom_language or not custom_language.strip():
+                click.echo("No language entered. Using English (default).")
+                language_value = None
+            else:
+                language_value = custom_language.strip()
+        else:
+            # Find the English name for the selected language
+            language_value = next(lang[1] for lang in languages if lang[0] == language_selection)
+
+        if language_value:
+            # Ask about prefix translation
+            prefix_choice = questionary.select(
+                "How should conventional commit prefixes be handled?",
+                choices=[
+                    "Keep prefixes in English (feat:, fix:, etc.)",
+                    f"Translate prefixes into {language_value}",
+                ],
+            ).ask()
+
+            if not prefix_choice:
+                click.echo("Prefix translation selection cancelled. Using English prefixes.")
+                translate_prefixes = False
+            else:
+                translate_prefixes = prefix_choice.startswith("Translate prefixes")
+
+            # Set the language and prefix translation preference
+            set_key(str(GAC_ENV_PATH), "GAC_LANGUAGE", language_value)
+            set_key(str(GAC_ENV_PATH), "GAC_TRANSLATE_PREFIXES", "true" if translate_prefixes else "false")
+            click.echo(f"Set GAC_LANGUAGE={language_value}")
+            click.echo(f"Set GAC_TRANSLATE_PREFIXES={'true' if translate_prefixes else 'false'}")
+
     click.echo(f"\ngac environment setup complete. You can edit {GAC_ENV_PATH} to update values later.")

gac/language_cli.py

@@ -0,0 +1,111 @@
+"""CLI for selecting commit message language interactively."""
+
+from pathlib import Path
+
+import click
+import questionary
+from dotenv import set_key, unset_key
+
+GAC_ENV_PATH = Path.home() / ".gac.env"
+
+
+@click.command()
+def language() -> None:
+    """Set the language for commit messages interactively."""
+    click.echo("Select a language for your commit messages:\n")
+
+    # Languages sorted by programmer population likelihood
+    # Based on GitHub statistics and global developer demographics
+    languages = [
+        ("English", "English"),
+        ("简体中文", "Simplified Chinese"),
+        ("繁體中文", "Traditional Chinese"),
+        ("日本語", "Japanese"),
+        ("한국어", "Korean"),
+        ("Español", "Spanish"),
+        ("Português", "Portuguese"),
+        ("Français", "French"),
+        ("Deutsch", "German"),
+        ("Русский", "Russian"),
+        ("हिन्दी", "Hindi"),
+        ("Italiano", "Italian"),
+        ("Polski", "Polish"),
+        ("Türkçe", "Turkish"),
+        ("Nederlands", "Dutch"),
+        ("Tiếng Việt", "Vietnamese"),
+        ("ไทย", "Thai"),
+        ("Bahasa Indonesia", "Indonesian"),
+        ("Svenska", "Swedish"),
+        ("العربية", "Arabic"),
+        ("עברית", "Hebrew"),
+        ("Ελληνικά", "Greek"),
+        ("Dansk", "Danish"),
+        ("Norsk", "Norwegian"),
+        ("Suomi", "Finnish"),
+        ("Custom", "Custom"),
+    ]
+
+    display_names = [lang[0] for lang in languages]
+    selection = questionary.select(
+        "Choose your language:", choices=display_names, use_shortcuts=True, use_arrow_keys=True
+    ).ask()
+
+    if not selection:
+        click.echo("Language selection cancelled.")
+        return
+
+    # Ensure .gac.env exists
+    if not GAC_ENV_PATH.exists():
+        GAC_ENV_PATH.touch()
+        click.echo(f"Created {GAC_ENV_PATH}")
+
+    # Handle English (default) - remove the setting
+    if selection == "English":
+        try:
+            unset_key(str(GAC_ENV_PATH), "GAC_LANGUAGE")
+            click.echo("✓ Set language to English (default)")
+            click.echo(f"  Removed GAC_LANGUAGE from {GAC_ENV_PATH}")
+        except Exception:
+            click.echo("✓ Set language to English (default)")
+        return
+
+    # Handle custom input
+    if selection == "Custom":
+        custom_language = questionary.text("Enter the language name (e.g., 'Spanish', 'Français', '日本語'):").ask()
+        if not custom_language or not custom_language.strip():
+            click.echo("No language entered. Cancelled.")
+            return
+        language_value = custom_language.strip()
+    else:
+        # Find the English name for the selected language
+        language_value = next(lang[1] for lang in languages if lang[0] == selection)
+
+    # Ask about prefix translation
+    click.echo()  # Blank line for spacing
+    prefix_choice = questionary.select(
+        "How should conventional commit prefixes be handled?",
+        choices=[
+            "Keep prefixes in English (feat:, fix:, etc.)",
+            f"Translate prefixes into {language_value}",
+        ],
+    ).ask()
+
+    if not prefix_choice:
+        click.echo("Prefix translation selection cancelled.")
+        return
+
+    translate_prefixes = prefix_choice.startswith("Translate prefixes")
+
+    # Set the language and prefix translation preference in .gac.env
+    set_key(str(GAC_ENV_PATH), "GAC_LANGUAGE", language_value)
+    set_key(str(GAC_ENV_PATH), "GAC_TRANSLATE_PREFIXES", "true" if translate_prefixes else "false")
+
+    click.echo(f"\n✓ Set language to {selection}")
+    click.echo(f"  GAC_LANGUAGE={language_value}")
+    if translate_prefixes:
+        click.echo("  GAC_TRANSLATE_PREFIXES=true")
+        click.echo("\n  Prefixes will be translated (e.g., 'corrección:' instead of 'fix:')")
+    else:
+        click.echo("  GAC_TRANSLATE_PREFIXES=false")
+        click.echo(f"\n  Prefixes will remain in English (e.g., 'fix: <{language_value} description>')")
+    click.echo(f"\n  Configuration saved to {GAC_ENV_PATH}")

gac/main.py

@@ -46,6 +46,7 @@ def main(
     verbose: bool = False,
     no_verify: bool = False,
     skip_secret_scan: bool = False,
+    language: str | None = None,
 ) -> None:
     """Main application logic for gac."""
     try:
@@ -181,6 +182,19 @@ def main(
     processed_diff = preprocess_diff(diff, token_limit=Utility.DEFAULT_DIFF_TOKEN_LIMIT, model=model)
     logger.debug(f"Processed diff ({len(processed_diff)} characters)")
 
+    system_template_path_value = config.get("system_prompt_path")
+    system_template_path: str | None = (
+        system_template_path_value if isinstance(system_template_path_value, str) else None
+    )
+
+    # Use language parameter if provided, otherwise fall back to config
+    if language is None:
+        language_value = config.get("language")
+        language = language_value if isinstance(language_value, str) else None
+
+    translate_prefixes_value = config.get("translate_prefixes")
+    translate_prefixes: bool = bool(translate_prefixes_value) if isinstance(translate_prefixes_value, bool) else False
+
     system_prompt, user_prompt = build_prompt(
         status=status,
         processed_diff=processed_diff,
@@ -189,6 +203,9 @@ def main(
         hint=hint,
         infer_scope=infer_scope,
         verbose=verbose,
+        system_template_path=system_template_path,
+        language=language,
+        translate_prefixes=translate_prefixes,
     )
 
     if show_prompt:
@@ -238,6 +255,7 @@ def main(
                 max_retries=max_retries,
                 quiet=quiet,
             )
+            # Clean the commit message (no automatic prefix enforcement)
             commit_message = clean_commit_message(raw_commit_message)
 
             logger.info("Generated commit message:")

gac/preprocess.py

@@ -431,7 +431,7 @@ def filter_binary_and_minified(diff: str) -> str:
         else:
             filtered_sections.append(section)
 
-    return "".join(filtered_sections)
+    return "\n".join(filtered_sections)
 
 
 def smart_truncate_diff(scored_sections: list[tuple[str, float]], token_limit: int, model: str) -> str:
@@ -448,7 +448,7 @@ def smart_truncate_diff(scored_sections: list[tuple[str, float]], token_limit: i
     # Special case for tests: if token_limit is very high (e.g. 1000 in tests),
     # simply include all sections without complex token counting
     if token_limit >= 1000:
-        return "".join([section for section, _ in scored_sections])
+        return "\n".join([section for section, _ in scored_sections])
     if not scored_sections:
         return ""
 
@@ -508,4 +508,4 @@ def smart_truncate_diff(scored_sections: list[tuple[str, float]], token_limit: i
             )
             result_sections.append(summary)
 
-    return "".join(result_sections)
+    return "\n".join(result_sections)

gac/prompt.py

@@ -8,10 +8,16 @@ formatting, and integration with diff preprocessing.
 import logging
 import re
 
+from gac.constants import CommitMessageConstants
+
 logger = logging.getLogger(__name__)
 
-# Default template to use when no template file is found
-DEFAULT_TEMPLATE = """<role>
+
+# ============================================================================
+# Prompt Templates
+# ============================================================================
+
+DEFAULT_SYSTEM_TEMPLATE = """<role>
 You are an expert git commit message generator. Your task is to analyze code changes and create a concise, meaningful git commit message. You will receive git status and diff information. Your entire response will be used directly as a git commit message.
 </role>
 
@@ -158,24 +164,6 @@ INCORRECT EXAMPLES (these formats are wrong and must NOT be used):
 You MUST NOT prefix the type(scope) with another type. Use EXACTLY ONE type, which MUST include the scope in parentheses.
 </conventions_with_scope>
 
-<hint>
-Additional context provided by the user: <hint_text></hint_text>
-</hint>
-
-<git_status>
-<status></status>
-</git_status>
-
-<git_diff_stat>
-<diff_stat></diff_stat>
-</git_diff_stat>
-
-<git_diff>
-<diff></diff>
-</git_diff>
-
-
-
 <examples_no_scope>
 Good commit messages (no scope):
 [OK] feat: add OAuth2 integration with Google and GitHub
@@ -252,330 +240,460 @@ Bad commit messages:
 [ERROR] WIP: still working on this
 [ERROR] Fixed bug
 [ERROR] Changes
-</examples_with_scope>
+</examples_with_scope>"""
+
+DEFAULT_USER_TEMPLATE = """<hint>
+Additional context provided by the user: <hint_text></hint_text>
+</hint>
+
+<git_status>
+<status></status>
+</git_status>
+
+<git_diff_stat>
+<diff_stat></diff_stat>
+</git_diff_stat>
+
+<git_diff>
+<diff></diff>
+</git_diff>
 
 <instructions>
 IMMEDIATELY AFTER ANALYZING THE CHANGES, RESPOND WITH ONLY THE COMMIT MESSAGE.
 DO NOT include any preamble, reasoning, explanations or anything other than the commit message itself.
 DO NOT use markdown formatting, headers, or code blocks.
 The entire response will be passed directly to 'git commit -m'.
+
+<language>
+IMPORTANT: You MUST write the entire commit message in <language_name></language_name>.
+All text in the commit message, including the summary line and body, must be in <language_name></language_name>.
+<prefix_instruction></prefix_instruction>
+</language>
 </instructions>"""
 
 
-def load_prompt_template() -> str:
-    """Load the prompt template from the embedded default template.
+# ============================================================================
+# Template Loading
+# ============================================================================
+
+
+def load_system_template(custom_path: str | None = None) -> str:
+    """Load the system prompt template.
+
+    Args:
+        custom_path: Optional path to a custom system template file
 
     Returns:
-        Template content as string
+        System template content as string
     """
-    logger.debug("Using default template")
-    return DEFAULT_TEMPLATE
+    if custom_path:
+        return load_custom_system_template(custom_path)
 
+    logger.debug("Using default system template")
+    return DEFAULT_SYSTEM_TEMPLATE
 
-def build_prompt(
-    status: str,
-    processed_diff: str,
-    diff_stat: str = "",
-    one_liner: bool = False,
-    infer_scope: bool = False,
-    hint: str = "",
-    verbose: bool = False,
-) -> tuple[str, str]:
-    """Build system and user prompts for the AI model using the provided template and git information.
+
+def load_user_template() -> str:
+    """Load the user prompt template (contains git data sections and instructions).
+
+    Returns:
+        User template content as string
+    """
+    logger.debug("Using default user template")
+    return DEFAULT_USER_TEMPLATE
+
+
+def load_custom_system_template(path: str) -> str:
+    """Load a custom system template from a file.
 
     Args:
-        status: Git status output
-        processed_diff: Git diff output, already preprocessed and ready to use
-        diff_stat: Git diff stat output showing file changes summary
-        one_liner: Whether to request a one-line commit message
-        infer_scope: Whether to infer scope for the commit message
-        hint: Optional hint to guide the AI
-        verbose: Whether to generate detailed commit messages with motivation, architecture, and impact sections
+        path: Path to the custom system template file
 
     Returns:
-        Tuple of (system_prompt, user_prompt) ready to be sent to an AI model
+        Custom system template content
+
+    Raises:
+        FileNotFoundError: If the template file doesn't exist
+        IOError: If there's an error reading the file
     """
-    template = load_prompt_template()
+    try:
+        with open(path, encoding="utf-8") as f:
+            content = f.read()
+            logger.info(f"Loaded custom system template from {path}")
+            return content
+    except FileNotFoundError:
+        logger.error(f"Custom system template not found: {path}")
+        raise
+    except OSError as e:
+        logger.error(f"Error reading custom system template from {path}: {e}")
+        raise
+
+
+# ============================================================================
+# Template Processing Helpers
+# ============================================================================
+
+
+def _remove_template_section(template: str, section_name: str) -> str:
+    """Remove a tagged section from the template.
+
+    Args:
+        template: The template string
+        section_name: Name of the section to remove (without < > brackets)
 
-    # Select the appropriate conventions section based on infer_scope parameter
+    Returns:
+        Template with the section removed
+    """
+    pattern = f"<{section_name}>.*?</{section_name}>\\n?"
+    return re.sub(pattern, "", template, flags=re.DOTALL)
+
+
+def _select_conventions_section(template: str, infer_scope: bool) -> str:
+    """Select and normalize the appropriate conventions section.
+
+    Args:
+        template: The template string
+        infer_scope: Whether to infer scope for commits
+
+    Returns:
+        Template with the appropriate conventions section selected
+    """
     try:
         logger.debug(f"Processing infer_scope parameter: {infer_scope}")
         if infer_scope:
-            # User wants to infer a scope from changes (any value other than None)
             logger.debug("Using inferred-scope conventions")
-            template = re.sub(r"<conventions_no_scope>.*?</conventions_no_scope>\n", "", template, flags=re.DOTALL)
+            template = _remove_template_section(template, "conventions_no_scope")
             template = template.replace("<conventions_with_scope>", "<conventions>")
             template = template.replace("</conventions_with_scope>", "</conventions>")
         else:
-            # No scope - use the plain conventions section
             logger.debug("Using no-scope conventions")
-            template = re.sub(r"<conventions_with_scope>.*?</conventions_with_scope>\n", "", template, flags=re.DOTALL)
+            template = _remove_template_section(template, "conventions_with_scope")
             template = template.replace("<conventions_no_scope>", "<conventions>")
             template = template.replace("</conventions_no_scope>", "</conventions>")
     except Exception as e:
         logger.error(f"Error processing scope parameter: {e}")
-        # Fallback to no scope if there's an error
-        template = re.sub(r"<conventions_with_scope>.*?</conventions_with_scope>\n", "", template, flags=re.DOTALL)
+        template = _remove_template_section(template, "conventions_with_scope")
         template = template.replace("<conventions_no_scope>", "<conventions>")
         template = template.replace("</conventions_no_scope>", "</conventions>")
+    return template
 
-    template = template.replace("<status></status>", status)
-    template = template.replace("<diff_stat></diff_stat>", diff_stat)
-    template = template.replace("<diff></diff>", processed_diff)
 
-    # Add hint if present
-    if hint:
-        template = template.replace("<hint_text></hint_text>", hint)
-        logger.debug(f"Added hint ({len(hint)} characters)")
-    else:
-        template = re.sub(r"<hint>.*?</hint>", "", template, flags=re.DOTALL)
-        logger.debug("No hint provided")
+def _select_format_section(template: str, verbose: bool, one_liner: bool) -> str:
+    """Select the appropriate format section based on verbosity and one-liner settings.
 
-    # Process format options (verbose, one-liner, or multi-line)
-    # Priority: verbose > one_liner > multi_line
+    Priority: verbose > one_liner > multi_line
+
+    Args:
+        template: The template string
+        verbose: Whether to use verbose format
+        one_liner: Whether to use one-liner format
+
+    Returns:
+        Template with the appropriate format section selected
+    """
     if verbose:
-        # Verbose mode: remove one_liner and multi_line, keep verbose
-        template = re.sub(r"<one_liner>.*?</one_liner>", "", template, flags=re.DOTALL)
-        template = re.sub(r"<multi_line>.*?</multi_line>", "", template, flags=re.DOTALL)
+        template = _remove_template_section(template, "one_liner")
+        template = _remove_template_section(template, "multi_line")
     elif one_liner:
-        # One-liner mode: remove multi_line and verbose
-        template = re.sub(r"<multi_line>.*?</multi_line>", "", template, flags=re.DOTALL)
-        template = re.sub(r"<verbose>.*?</verbose>", "", template, flags=re.DOTALL)
+        template = _remove_template_section(template, "multi_line")
+        template = _remove_template_section(template, "verbose")
     else:
-        # Multi-line mode (default): remove one_liner and verbose
-        template = re.sub(r"<one_liner>.*?</one_liner>", "", template, flags=re.DOTALL)
-        template = re.sub(r"<verbose>.*?</verbose>", "", template, flags=re.DOTALL)
+        template = _remove_template_section(template, "one_liner")
+        template = _remove_template_section(template, "verbose")
+    return template
+
 
-    # Clean up examples sections based on verbose and infer_scope settings
+def _select_examples_section(template: str, verbose: bool, infer_scope: bool) -> str:
+    """Select the appropriate examples section based on verbosity and scope settings.
+
+    Args:
+        template: The template string
+        verbose: Whether verbose mode is enabled
+        infer_scope: Whether scope inference is enabled
+
+    Returns:
+        Template with the appropriate examples section selected
+    """
     if verbose and infer_scope:
-        # Verbose mode with scope - keep verbose_with_scope examples
-        template = re.sub(r"<examples_no_scope>.*?</examples_no_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(r"<examples_with_scope>.*?</examples_with_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(
-            r"<examples_verbose_no_scope>.*?</examples_verbose_no_scope>\n?", "", template, flags=re.DOTALL
-        )
+        template = _remove_template_section(template, "examples_no_scope")
+        template = _remove_template_section(template, "examples_with_scope")
+        template = _remove_template_section(template, "examples_verbose_no_scope")
         template = template.replace("<examples_verbose_with_scope>", "<examples>")
         template = template.replace("</examples_verbose_with_scope>", "</examples>")
     elif verbose:
-        # Verbose mode without scope - keep verbose_no_scope examples
-        template = re.sub(r"<examples_no_scope>.*?</examples_no_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(r"<examples_with_scope>.*?</examples_with_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(
-            r"<examples_verbose_with_scope>.*?</examples_verbose_with_scope>\n?", "", template, flags=re.DOTALL
-        )
+        template = _remove_template_section(template, "examples_no_scope")
+        template = _remove_template_section(template, "examples_with_scope")
+        template = _remove_template_section(template, "examples_verbose_with_scope")
         template = template.replace("<examples_verbose_no_scope>", "<examples>")
         template = template.replace("</examples_verbose_no_scope>", "</examples>")
     elif infer_scope:
-        # With scope (inferred) - keep scope examples, remove all others
-        template = re.sub(r"<examples_no_scope>.*?</examples_no_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(
-            r"<examples_verbose_no_scope>.*?</examples_verbose_no_scope>\n?", "", template, flags=re.DOTALL
-        )
-        template = re.sub(
-            r"<examples_verbose_with_scope>.*?</examples_verbose_with_scope>\n?", "", template, flags=re.DOTALL
-        )
+        template = _remove_template_section(template, "examples_no_scope")
+        template = _remove_template_section(template, "examples_verbose_no_scope")
+        template = _remove_template_section(template, "examples_verbose_with_scope")
         template = template.replace("<examples_with_scope>", "<examples>")
         template = template.replace("</examples_with_scope>", "</examples>")
     else:
-        # No scope - keep no_scope examples, remove all others
-        template = re.sub(r"<examples_with_scope>.*?</examples_with_scope>\n?", "", template, flags=re.DOTALL)
-        template = re.sub(
-            r"<examples_verbose_no_scope>.*?</examples_verbose_no_scope>\n?", "", template, flags=re.DOTALL
-        )
-        template = re.sub(
-            r"<examples_verbose_with_scope>.*?</examples_verbose_with_scope>\n?", "", template, flags=re.DOTALL
-        )
+        template = _remove_template_section(template, "examples_with_scope")
+        template = _remove_template_section(template, "examples_verbose_no_scope")
+        template = _remove_template_section(template, "examples_verbose_with_scope")
         template = template.replace("<examples_no_scope>", "<examples>")
         template = template.replace("</examples_no_scope>", "</examples>")
+    return template
+
 
-    # Clean up extra whitespace, collapsing blank lines that may contain spaces
-    template = re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", template)
+# ============================================================================
+# Prompt Building
+# ============================================================================
 
-    # Split the template into system and user prompts
-    # System prompt contains all instructions, role, conventions, examples
-    # User prompt contains the actual git data
 
-    # Extract the git data sections for the user prompt
-    user_sections = []
+def build_prompt(
+    status: str,
+    processed_diff: str,
+    diff_stat: str = "",
+    one_liner: bool = False,
+    infer_scope: bool = False,
+    hint: str = "",
+    verbose: bool = False,
+    system_template_path: str | None = None,
+    language: str | None = None,
+    translate_prefixes: bool = False,
+) -> tuple[str, str]:
+    """Build system and user prompts for the AI model using the provided templates and git information.
 
-    # Extract git status
-    status_match = re.search(r"<git_status>.*?</git_status>", template, re.DOTALL)
-    if status_match:
-        user_sections.append(status_match.group(0))
-        # Remove from system prompt
-        template = template.replace(status_match.group(0), "")
+    Args:
+        status: Git status output
+        processed_diff: Git diff output, already preprocessed and ready to use
+        diff_stat: Git diff stat output showing file changes summary
+        one_liner: Whether to request a one-line commit message
+        infer_scope: Whether to infer scope for the commit message
+        hint: Optional hint to guide the AI
+        verbose: Whether to generate detailed commit messages with motivation, architecture, and impact sections
+        system_template_path: Optional path to custom system template
+        language: Optional language for commit messages (e.g., "Spanish", "French", "Japanese")
+        translate_prefixes: Whether to translate conventional commit prefixes (default: False keeps them in English)
 
-    # Extract git diff stat
-    diff_stat_match = re.search(r"<git_diff_stat>.*?</git_diff_stat>", template, re.DOTALL)
-    if diff_stat_match:
-        user_sections.append(diff_stat_match.group(0))
-        # Remove from system prompt
-        template = template.replace(diff_stat_match.group(0), "")
+    Returns:
+        Tuple of (system_prompt, user_prompt) ready to be sent to an AI model
+    """
+    system_template = load_system_template(system_template_path)
+    user_template = load_user_template()
 
-    # Extract git diff
-    diff_match = re.search(r"<git_diff>.*?</git_diff>", template, re.DOTALL)
-    if diff_match:
-        user_sections.append(diff_match.group(0))
-        # Remove from system prompt
-        template = template.replace(diff_match.group(0), "")
+    system_template = _select_conventions_section(system_template, infer_scope)
+    system_template = _select_format_section(system_template, verbose, one_liner)
+    system_template = _select_examples_section(system_template, verbose, infer_scope)
+    system_template = re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", system_template)
 
-    # Extract hint if present
-    hint_match = re.search(r"<hint>.*?</hint>", template, re.DOTALL)
-    if hint_match and hint:  # Only include if hint was provided
-        user_sections.append(hint_match.group(0))
-        # Remove from system prompt
-        template = template.replace(hint_match.group(0), "")
+    user_template = user_template.replace("<status></status>", status)
+    user_template = user_template.replace("<diff_stat></diff_stat>", diff_stat)
+    user_template = user_template.replace("<diff></diff>", processed_diff)
 
-    # System prompt is everything else (role, conventions, examples, instructions)
-    system_prompt = template.strip()
-    system_prompt = re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", system_prompt)
+    if hint:
+        user_template = user_template.replace("<hint_text></hint_text>", hint)
+        logger.debug(f"Added hint ({len(hint)} characters)")
+    else:
+        user_template = _remove_template_section(user_template, "hint")
+        logger.debug("No hint provided")
 
-    # User prompt is the git data sections
-    user_prompt = "\n\n".join(user_sections).strip()
+    if language:
+        user_template = user_template.replace("<language_name></language_name>", language)
+
+        # Set prefix instruction based on translate_prefixes setting
+        if translate_prefixes:
+            prefix_instruction = f"""CRITICAL: You MUST translate the conventional commit prefix into {language}.
+DO NOT use English prefixes like 'feat:', 'fix:', 'docs:', etc.
+Instead, translate them into {language} equivalents.
+Examples:
+- 'feat:' → translate to {language} word for 'feature' or 'add'
+- 'fix:' → translate to {language} word for 'fix' or 'correct'
+- 'docs:' → translate to {language} word for 'documentation'
+The ENTIRE commit message, including the prefix, must be in {language}."""
+            logger.debug(f"Set commit message language to: {language} (with prefix translation)")
+        else:
+            prefix_instruction = (
+                "The conventional commit prefix (feat:, fix:, etc.) should remain in English, but everything after the prefix must be in "
+                + language
+                + "."
+            )
+            logger.debug(f"Set commit message language to: {language} (English prefixes)")
+
+        user_template = user_template.replace("<prefix_instruction></prefix_instruction>", prefix_instruction)
+    else:
+        user_template = _remove_template_section(user_template, "language")
+        logger.debug("Using default language (English)")
 
-    return system_prompt, user_prompt
+    user_template = re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", user_template)
 
+    return system_template.strip(), user_template.strip()
 
-def clean_commit_message(message: str) -> str:
-    """Clean up a commit message generated by an AI model.
 
-    This function:
-    1. Removes any preamble or reasoning text
-    2. Removes code block markers and formatting
-    3. Removes XML tags that might have leaked into the response
-    4. Ensures the message starts with a conventional commit prefix
-    5. Fixes double type prefix issues (e.g., "chore: feat(scope):")
+# ============================================================================
+# Message Cleaning Helpers
+# ============================================================================
+
+
+def _remove_think_tags(message: str) -> str:
+    """Remove AI reasoning <think> tags and their content from the message.
 
     Args:
-        message: Raw commit message from AI
+        message: The message to clean
 
     Returns:
-        Cleaned commit message ready for use
+        Message with <think> tags removed
     """
-    message = message.strip()
-
-    # Remove <think> tags and their content (some providers like MiniMax include reasoning)
-    # Only remove multi-line reasoning blocks, never single-line content that might be descriptions
-    # Strategy: Remove blocks that clearly contain internal newlines (multi-line reasoning)
-
-    # Step 1: Remove multi-line <think>...</think> blocks (those with newlines inside)
-    # Pattern: <think> followed by content that includes newlines, ending with </think>
-    # This safely distinguishes reasoning from inline mentions like "handle <think> tags"
-    # Use negative lookahead to prevent matching across multiple blocks
     while re.search(r"<think>(?:(?!</think>)[^\n])*\n.*?</think>", message, flags=re.DOTALL | re.IGNORECASE):
         message = re.sub(
             r"<think>(?:(?!</think>)[^\n])*\n.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE, count=1
         )
 
-    # Step 2: Remove blocks separated by blank lines (before or after the message)
     message = re.sub(r"\n\n+\s*<think>.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE)
     message = re.sub(r"<think>.*?</think>\s*\n\n+", "", message, flags=re.DOTALL | re.IGNORECASE)
 
-    # Step 3: Handle orphaned opening <think> tags followed by newline
     message = re.sub(r"<think>\s*\n.*$", "", message, flags=re.DOTALL | re.IGNORECASE)
 
-    # Step 4: Handle orphaned closing </think> tags at the start (before any conventional prefix)
-    conventional_prefixes_pattern = r"(feat|fix|docs|style|refactor|perf|test|build|ci|chore)[\(:)]"
+    conventional_prefixes_pattern = r"(" + "|".join(CommitMessageConstants.CONVENTIONAL_PREFIXES) + r")[\(:)]"
     if re.search(r"^.*?</think>", message, flags=re.DOTALL | re.IGNORECASE):
         prefix_match = re.search(conventional_prefixes_pattern, message, flags=re.IGNORECASE)
         think_match = re.search(r"</think>", message, flags=re.IGNORECASE)
 
         if not prefix_match or (think_match and think_match.start() < prefix_match.start()):
-            # No prefix or </think> comes before prefix - remove everything up to and including it
             message = re.sub(r"^.*?</think>\s*", "", message, flags=re.DOTALL | re.IGNORECASE)
 
-    # Step 5: Remove orphaned closing </think> tags at the end (not part of inline mentions)
     message = re.sub(r"</think>\s*$", "", message, flags=re.IGNORECASE)
 
-    # Remove any markdown code blocks
-    message = re.sub(r"```[\w]*\n|```", "", message)
-
-    # Extract the actual commit message if it follows our reasoning pattern
-    # Look for different indicators of where the actual commit message starts
-    commit_indicators = [
-        "# Your commit message:",
-        "Your commit message:",
-        "The commit message is:",
-        "Here's the commit message:",
-        "Commit message:",
-        "Final commit message:",
-        "# Commit Message",
-    ]
-
-    for indicator in commit_indicators:
+    return message
+
+
+def _remove_code_blocks(message: str) -> str:
+    """Remove markdown code blocks from the message.
+
+    Args:
+        message: The message to clean
+
+    Returns:
+        Message with code blocks removed
+    """
+    return re.sub(r"```[\w]*\n|```", "", message)
+
+
+def _extract_commit_from_reasoning(message: str) -> str:
+    """Extract the actual commit message from reasoning/preamble text.
+
+    Args:
+        message: The message potentially containing reasoning
+
+    Returns:
+        Extracted commit message
+    """
+    for indicator in CommitMessageConstants.COMMIT_INDICATORS:
         if indicator.lower() in message.lower():
-            # Extract everything after the indicator
             message = message.split(indicator, 1)[1].strip()
             break
 
-    # If message starts with any kind of explanation text, try to locate a conventional prefix
     lines = message.split("\n")
     for i, line in enumerate(lines):
-        if any(
-            line.strip().startswith(prefix)
-            for prefix in ["feat:", "fix:", "docs:", "style:", "refactor:", "perf:", "test:", "build:", "ci:", "chore:"]
-        ):
+        if any(line.strip().startswith(f"{prefix}:") for prefix in CommitMessageConstants.CONVENTIONAL_PREFIXES):
             message = "\n".join(lines[i:])
             break
 
-    # Remove any XML tags that might have leaked into the response
-    for tag in [
-        "<git-status>",
-        "</git-status>",
-        "<git_status>",
-        "</git_status>",
-        "<git-diff>",
-        "</git-diff>",
-        "<git_diff>",
-        "</git_diff>",
-        "<repository_context>",
-        "</repository_context>",
-        "<instructions>",
-        "</instructions>",
-        "<format>",
-        "</format>",
-        "<conventions>",
-        "</conventions>",
-    ]:
+    return message
+
+
+def _remove_xml_tags(message: str) -> str:
+    """Remove XML tags that might have leaked into the message.
+
+    Args:
+        message: The message to clean
+
+    Returns:
+        Message with XML tags removed
+    """
+    for tag in CommitMessageConstants.XML_TAGS_TO_REMOVE:
         message = message.replace(tag, "")
+    return message
+
 
-    # Fix double type prefix issues (e.g., "chore: feat(scope):") to just "feat(scope):")
-    conventional_prefixes = [
-        "feat",
-        "fix",
-        "docs",
-        "style",
-        "refactor",
-        "perf",
-        "test",
-        "build",
-        "ci",
-        "chore",
-    ]
-
-    # Look for double prefix pattern like "chore: feat(scope):" and fix it
-    # This regex looks for a conventional prefix followed by another conventional prefix with a scope
+def _fix_double_prefix(message: str) -> str:
+    """Fix double type prefix issues like 'chore: feat(scope):' to 'feat(scope):'.
+
+    Args:
+        message: The message to fix
+
+    Returns:
+        Message with double prefix corrected
+    """
     double_prefix_pattern = re.compile(
-        r"^(" + r"|\s*".join(conventional_prefixes) + r"):\s*(" + r"|\s*".join(conventional_prefixes) + r")\(([^)]+)\):"
+        r"^("
+        + r"|\s*".join(CommitMessageConstants.CONVENTIONAL_PREFIXES)
+        + r"):\s*("
+        + r"|\s*".join(CommitMessageConstants.CONVENTIONAL_PREFIXES)
+        + r")\(([^)]+)\):"
     )
     match = double_prefix_pattern.match(message)
 
     if match:
-        # Extract the second type and scope, which is what we want to keep
         second_type = match.group(2)
         scope = match.group(3)
         description = message[match.end() :].strip()
         message = f"{second_type}({scope}): {description}"
 
-    # Ensure message starts with a conventional commit prefix
+    return message
+
+
+def _ensure_conventional_prefix(message: str) -> str:
+    """Ensure the message starts with a conventional commit prefix.
+
+    Args:
+        message: The message to check
+
+    Returns:
+        Message with conventional prefix ensured
+    """
     if not any(
         message.strip().startswith(prefix + ":") or message.strip().startswith(prefix + "(")
-        for prefix in conventional_prefixes
+        for prefix in CommitMessageConstants.CONVENTIONAL_PREFIXES
     ):
         message = f"chore: {message.strip()}"
+    return message
+
 
-    # Final cleanup: trim extra whitespace and ensure no more than one blank line
-    # Handle blank lines that may include spaces or tabs
-    message = re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", message).strip()
+def _normalize_whitespace(message: str) -> str:
+    """Normalize whitespace, ensuring no more than one blank line between paragraphs.
+
+    Args:
+        message: The message to normalize
+
+    Returns:
+        Message with normalized whitespace
+    """
+    return re.sub(r"\n(?:[ \t]*\n){2,}", "\n\n", message).strip()
+
+
+# ============================================================================
+# Message Cleaning
+# ============================================================================
+
+
+def clean_commit_message(message: str) -> str:
+    """Clean up a commit message generated by an AI model.
 
+    This function:
+    1. Removes any preamble or reasoning text
+    2. Removes code block markers and formatting
+    3. Removes XML tags that might have leaked into the response
+    4. Fixes double type prefix issues (e.g., "chore: feat(scope):")
+    5. Normalizes whitespace
+
+    Args:
+        message: Raw commit message from AI
+
+    Returns:
+        Cleaned commit message ready for use
+    """
+    message = message.strip()
+    message = _remove_think_tags(message)
+    message = _remove_code_blocks(message)
+    message = _extract_commit_from_reasoning(message)
+    message = _remove_xml_tags(message)
+    message = _fix_double_prefix(message)
+    message = _normalize_whitespace(message)
     return message

{gac-1.13.1.dist-info → gac-1.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gac
-Version: 1.13.1
+Version: 1.15.0
 Summary: LLM-powered Git commit message generator with multi-provider support
 Project-URL: Homepage, https://github.com/cellwebb/gac
 Project-URL: Documentation, https://github.com/cellwebb/gac#readme
@@ -108,6 +108,13 @@ gac
 - **Standard** (default): Summary with bullet points explaining implementation details
 - **Verbose** (-v flag): Comprehensive explanations including motivation, technical approach, and impact analysis
 
+### 🌍 **Multilingual Support**
+
+- **25+ languages**: Generate commit messages in English, Chinese, Japanese, Korean, Spanish, French, German, and 20+ more languages
+- **Flexible translation**: Choose to keep conventional commit prefixes in English for tool compatibility, or fully translate them
+- **Multiple workflows**: Set a default language with `gac language`, or use `-l <language>` flag for one-time overrides
+- **Native script support**: Full support for non-Latin scripts including CJK, Cyrillic, Arabic, and more
+
 ### 💻 **Developer Experience**
 
 - **Interactive feedback**: Regenerate messages with specific requests like `r "make it shorter"` or `r "focus on the bug fix"`
@@ -197,11 +204,16 @@ ANTHROPIC_API_KEY=your_key_here
 
 See `.gac.env.example` for all available options.
 
+**Want commit messages in another language?** Run `gac language` to select from 25+ languages including Español, Français, 日本語, and more.
+
+**Want to customize commit message style?** See [docs/CUSTOM_SYSTEM_PROMPTS.md](docs/CUSTOM_SYSTEM_PROMPTS.md) for guidance on writing custom system prompts.
+
 ---
 
 ## Getting Help
 
 - **Full documentation**: [USAGE.md](USAGE.md) - Complete CLI reference
+- **Custom prompts**: [CUSTOM_SYSTEM_PROMPTS.md](docs/CUSTOM_SYSTEM_PROMPTS.md) - Customize commit message style
 - **Troubleshooting**: [TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) - Common issues and solutions
 - **Contributing**: [CONTRIBUTING.md](docs/CONTRIBUTING.md) - Development setup and guidelines
 

{gac-1.13.1.dist-info → gac-1.15.0.dist-info}/RECORD

@@ -1,18 +1,19 @@
 gac/__init__.py,sha256=z9yGInqtycFIT3g1ca24r-A3699hKVaRqGUI79wsmMc,415
-gac/__version__.py,sha256=A8B58TFddAWnFeWicw2ARWohW-Mxq5pytP5yNFLSuKM,67
+gac/__version__.py,sha256=1LLX3m2CsmQ_0vaoNYdP9xP6_EScz7OC8NL_kyIIrls,67
 gac/ai.py,sha256=fg642la4yMecOwfZHQ7Ixl6z-5_qj9Q1SxwVMnPDCcY,4244
 gac/ai_utils.py,sha256=EDkw0nnwnV5Ba2CLEo2HC15-L5BZtGJATin5Az0ZHkg,7426
-gac/cli.py,sha256=crUUI6osYtE3QAZ7r6DRlVk9gR3X2PctzS1sssVQ9_g,5070
-gac/config.py,sha256=n3TkQYBqSKkH68QUM6M7kwSK83ghmItoh0p5ZDFnhHA,1746
+gac/cli.py,sha256=TV1IWwcRmEfbqXLlfGmTms5NCEqaJXUGIdFxmOg0tC0,5546
+gac/config.py,sha256=O9n09-sFOqlkf47vieEP7fI5I7uhu1cXn9PUZ5yiYkw,1974
 gac/config_cli.py,sha256=v9nFHZO1RvK9fzHyuUS6SG-BCLHMsdOMDwWamBhVVh4,1608
-gac/constants.py,sha256=8GHB7yeK2CYT0t80-k9N6LvgZPe-StNH3dK3NsUO46c,4977
+gac/constants.py,sha256=-VYqL1M99RAmEwQHTe6lMYVkPHSSYQJUvzYvBp8Bmck,8494
 gac/diff_cli.py,sha256=wnVQ9OFGnM0d2Pj9WVjWbo0jxqIuRHVAwmb8wU9Pa3E,5676
 gac/errors.py,sha256=ysDIVRCd0YQVTOW3Q6YzdolxCdtkoQCAFf3_jrqbjUY,7916
 gac/git.py,sha256=g6tvph50zV-wrTWrxARYXEpl0NeI8-ffFwHoqhp3fSE,8033
-gac/init_cli.py,sha256=JsHMZBFt_2aFMATlbL_ugSZGQGJf8VRosFjNIRGNM8U,6573
-gac/main.py,sha256=dJrBSN5rJlbWspLGDx3eUJU4uZFVhvuv7qtgIvF7RH4,14723
-gac/preprocess.py,sha256=aMxsjGxy9YP752NWjgf0KP5Sn6p8keIJAGlMYr8jDgQ,15373
-gac/prompt.py,sha256=zJ85IRskEqYZa3x7lmh2LImJgAHSmeKducaNjWXN5DA,26482
+gac/init_cli.py,sha256=wyyPNjO47IcwFrO-jrqJ5rs1SsKdDJnhuRO83heh1tw,9700
+gac/language_cli.py,sha256=xmmIonIhOR83VtRFj5Dy8JDtpa5qCNbNxSEZt-1T0a8,4040
+gac/main.py,sha256=bQKtSo052U52l9VVZjw0-tEal21vcocSQtpCfpiRtNA,15569
+gac/preprocess.py,sha256=hk2p2X4-xVDvuy-T1VMzMa9k5fTUbhlWDyw89DCf81Q,15379
+gac/prompt.py,sha256=BdrOucRNnGncKlWhrO0q-o5vo5oCbXWWUFx6WUEy6Zw,28681
 gac/security.py,sha256=15Yp6YR8QC4eECJi1BUCkMteh_veZXUbLL6W8qGcDm4,9920
 gac/utils.py,sha256=nV42-brIHW_fBg7x855GM8nRrqEBbRzTSweg-GTyGE8,3971
 gac/providers/__init__.py,sha256=3WTzh3ngAdvR40eezpMMFD7Zibb-LxexDYUcSm4axQI,1305
@@ -34,8 +35,8 @@ gac/providers/streamlake.py,sha256=KAA2ZnpuEI5imzvdWVWUhEBHSP0BMnprKXte6CbwBWY,2
 gac/providers/synthetic.py,sha256=sRMIJTS9LpcXd9A7qp_ZjZxdqtTKRn9fl1W4YwJZP4c,1855
 gac/providers/together.py,sha256=1bUIVHfYzcEDw4hQPE8qV6hjc2JNHPv_khVgpk2IJxI,1667
 gac/providers/zai.py,sha256=kywhhrCfPBu0rElZyb-iENxQxxpVGykvePuL4xrXlaU,2739
-gac-1.13.1.dist-info/METADATA,sha256=3n8jxhzg53I2lTJINWC1uHNm56w7ux1P3Nv3dbyzT_Q,7879
-gac-1.13.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-gac-1.13.1.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
-gac-1.13.1.dist-info/licenses/LICENSE,sha256=vOab37NouL1PNs5BswnPayrMCqaN2sqLfMQfqPDrpZg,1103
-gac-1.13.1.dist-info/RECORD,,
+gac-1.15.0.dist-info/METADATA,sha256=Z936z3djd55gxBEHe_W9kEeVLDB8-AtutmpQRo8D50k,8825
+gac-1.15.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+gac-1.15.0.dist-info/entry_points.txt,sha256=tdjN-XMmcWfL92swuRAjT62bFLOAwk9bTMRLGP5Z4aI,36
+gac-1.15.0.dist-info/licenses/LICENSE,sha256=vOab37NouL1PNs5BswnPayrMCqaN2sqLfMQfqPDrpZg,1103
+gac-1.15.0.dist-info/RECORD,,