gac 2.3.0__py3-none-any.whl → 2.7.0__py3-none-any.whl

gac/__version__.py

@@ -1,3 +1,3 @@
 """Version information for gac package."""
 
-__version__ = "2.3.0"
+__version__ = "2.7.0"

gac/ai.py

@@ -13,6 +13,7 @@ from gac.providers import (
     call_anthropic_api,
     call_cerebras_api,
     call_chutes_api,
+    call_claude_code_api,
     call_custom_anthropic_api,
     call_custom_openai_api,
     call_deepseek_api,
@@ -48,7 +49,7 @@ def generate_commit_message(
     """Generate a commit message using direct API calls to AI providers.
 
     Args:
-        model: The model to use in provider:model_name format (e.g., 'anthropic:claude-3-5-haiku-latest')
+        model: The model to use in provider:model_name format (e.g., 'anthropic:claude-haiku-4-5')
         prompt: Either a string prompt (for backward compatibility) or tuple of (system_prompt, user_prompt)
         temperature: Controls randomness (0.0-1.0), lower values are more deterministic
         max_tokens: Maximum tokens in the response
@@ -62,7 +63,7 @@ def generate_commit_message(
         AIError: If generation fails after max_retries attempts
 
     Example:
-        >>> model = "anthropic:claude-3-5-haiku-latest"
+        >>> model = "anthropic:claude-haiku-4-5"
         >>> system_prompt, user_prompt = build_prompt("On branch main", "diff --git a/README.md b/README.md")
         >>> generate_commit_message(model, (system_prompt, user_prompt))
         'docs: Update README with installation instructions'
@@ -88,6 +89,7 @@ def generate_commit_message(
     provider_funcs = {
         "anthropic": call_anthropic_api,
         "cerebras": call_cerebras_api,
+        "claude-code": call_claude_code_api,
         "chutes": call_chutes_api,
         "custom-anthropic": call_custom_anthropic_api,
         "custom-openai": call_custom_openai_api,

gac/ai_utils.py

@@ -98,6 +98,7 @@ def generate_with_retries(
         "anthropic",
         "cerebras",
         "chutes",
+        "claude-code",
         "deepseek",
         "fireworks",
         "gemini",

gac/auth_cli.py

@@ -0,0 +1,69 @@
+"""CLI for authenticating Claude Code OAuth tokens.
+
+Provides a command to authenticate and re-authenticate Claude Code subscriptions.
+"""
+
+import logging
+
+import click
+
+from gac.oauth.claude_code import authenticate_and_save, load_stored_token
+from gac.utils import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--quiet",
+    "-q",
+    is_flag=True,
+    help="Suppress non-error output",
+)
+@click.option(
+    "--log-level",
+    default="INFO",
+    type=click.Choice(["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"], case_sensitive=False),
+    help="Set log level (default: INFO)",
+)
+def auth(quiet: bool = False, log_level: str = "INFO") -> None:
+    """Authenticate Claude Code OAuth token.
+
+    This command allows you to authenticate or re-authenticate your
+    Claude Code OAuth token when it expires or you want to refresh it.
+    It opens a browser window for the OAuth flow and saves the token
+    to ~/.gac.env.
+
+    The token is used by the Claude Code provider to access your
+    Claude Code subscription instead of requiring an Anthropic API key.
+    """
+    # Setup logging
+    if quiet:
+        effective_log_level = "ERROR"
+    else:
+        effective_log_level = log_level
+    setup_logging(effective_log_level)
+
+    # Check if there's an existing token
+    existing_token = load_stored_token()
+    if existing_token and not quiet:
+        click.echo("✓ Found existing Claude Code access token.")
+        click.echo()
+
+    if not quiet:
+        click.echo("🔐 Starting Claude Code OAuth authentication...")
+        click.echo("   Your browser will open automatically")
+        click.echo("   (Waiting up to 3 minutes for callback)")
+        click.echo()
+
+    # Perform OAuth authentication
+    success = authenticate_and_save(quiet=quiet)
+
+    if success:
+        if not quiet:
+            click.echo("✅ Claude Code authentication completed successfully!")
+            click.echo("   Your new token has been saved and is ready to use.")
+    else:
+        click.echo("❌ Claude Code authentication failed.")
+        click.echo("   Please try again or check your network connection.")
+        raise click.ClickException("Claude Code authentication failed")

gac/cli.py

@@ -11,12 +11,14 @@ import sys
 import click
 
 from gac import __version__
+from gac.auth_cli import auth as auth_cli
 from gac.config import load_config
 from gac.config_cli import config as config_cli
 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
@@ -65,6 +67,12 @@ logger = logging.getLogger(__name__)
 # Advanced options
 @click.option("--no-verify", is_flag=True, help="Skip pre-commit and lefthook hooks when committing")
 @click.option("--skip-secret-scan", is_flag=True, help="Skip security scan for secrets in staged changes")
+@click.option(
+    "--hook-timeout",
+    type=int,
+    default=0,
+    help="Timeout for pre-commit and lefthook hooks in seconds (0 to use configuration)",
+)
 # Other options
 @click.option("--version", is_flag=True, help="Show the version of the Git Auto Commit (gac) tool")
 @click.pass_context
@@ -87,6 +95,7 @@ def cli(
     verbose: bool = False,
     no_verify: bool = False,
     skip_secret_scan: bool = False,
+    hook_timeout: int = 0,
 ) -> None:
     """Git Auto Commit - Generate commit messages with AI."""
     if ctx.invoked_subcommand is None:
@@ -125,6 +134,7 @@ def cli(
                 no_verify=no_verify,
                 skip_secret_scan=skip_secret_scan or bool(config.get("skip_secret_scan", False)),
                 language=resolved_language,
+                hook_timeout=hook_timeout if hook_timeout > 0 else int(config.get("hook_timeout", 120) or 120),
             )
         except Exception as e:
             handle_error(e, exit_program=True)
@@ -150,13 +160,16 @@ def cli(
             "verbose": verbose,
             "no_verify": no_verify,
             "skip_secret_scan": skip_secret_scan,
+            "hook_timeout": hook_timeout,
         }
 
 
+cli.add_command(auth_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,8 @@ 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"),
+        "hook_timeout": int(os.getenv("GAC_HOOK_TIMEOUT", EnvDefaults.HOOK_TIMEOUT)),
     }
 
     return config

gac/constants.py

@@ -25,6 +25,7 @@ class EnvDefaults:
     ALWAYS_INCLUDE_SCOPE: bool = False
     SKIP_SECRET_SCAN: bool = False
     VERBOSE: bool = False
+    HOOK_TIMEOUT: int = 120  # Timeout for pre-commit and lefthook hooks in seconds
 
 
 class Logging:

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: Exception | None = 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
@@ -132,23 +189,23 @@ 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:
+def run_pre_commit_hooks(hook_timeout: int = 120) -> bool:
     """Run pre-commit hooks if they exist.
 
     Returns:
@@ -168,9 +225,9 @@ def run_pre_commit_hooks() -> bool:
             return True
 
         # Run pre-commit hooks on staged files
-        logger.info("Running pre-commit hooks...")
+        logger.info(f"Running pre-commit hooks with {hook_timeout}s timeout...")
         # 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"], timeout=hook_timeout)
 
         if result.returncode == 0:
             # All hooks passed
@@ -195,7 +252,7 @@ def run_pre_commit_hooks() -> bool:
         return True
 
 
-def run_lefthook_hooks() -> bool:
+def run_lefthook_hooks(hook_timeout: int = 120) -> bool:
     """Run Lefthook hooks if they exist.
 
     Returns:
@@ -218,9 +275,9 @@ def run_lefthook_hooks() -> bool:
             return True
 
         # Run lefthook hooks on staged files
-        logger.info("Running Lefthook hooks...")
+        logger.info(f"Running Lefthook hooks with {hook_timeout}s timeout...")
         # 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"], timeout=hook_timeout)
 
         if result.returncode == 0:
             # All hooks passed

gac/init_cli.py

@@ -1,16 +1,58 @@
 """CLI for initializing gac configuration interactively."""
 
+import os
 from pathlib import Path
 
 import click
 import questionary
-from dotenv import dotenv_values, set_key
+from dotenv import dotenv_values, load_dotenv, set_key
 
 from gac.constants import Languages
 
 GAC_ENV_PATH = Path.home() / ".gac.env"
 
 
+def _should_show_rtl_warning_for_init() -> bool:
+    """Check if RTL warning should be shown based on init's GAC_ENV_PATH.
+
+    Returns:
+        True if warning should be shown, False if user previously confirmed
+    """
+    if GAC_ENV_PATH.exists():
+        load_dotenv(GAC_ENV_PATH)
+        rtl_confirmed = os.getenv("GAC_RTL_CONFIRMED", "false").lower() in ("true", "1", "yes", "on")
+        return not rtl_confirmed
+    return True  # Show warning if no config exists
+
+
+def _show_rtl_warning_for_init(language_name: str) -> bool:
+    """Show RTL language warning for init command and save preference to GAC_ENV_PATH.
+
+    Args:
+        language_name: Name of the RTL language
+
+    Returns:
+        True if user wants to proceed, False if they cancel
+    """
+
+    terminal_width = 80  # Use default width
+    title = "⚠️  RTL Language Detected".center(terminal_width)
+
+    click.echo()
+    click.echo(click.style(title, fg="yellow", bold=True))
+    click.echo()
+    click.echo("Right-to-left (RTL) languages may not display correctly in gac due to terminal limitations.")
+    click.echo("However, the commit messages will work fine and should be readable in Git clients")
+    click.echo("that properly support RTL text (like most web interfaces and modern tools).\n")
+
+    proceed = questionary.confirm("Do you want to proceed anyway?").ask()
+    if proceed:
+        # Remember that user has confirmed RTL acceptance
+        set_key(str(GAC_ENV_PATH), "GAC_RTL_CONFIRMED", "true")
+        click.echo("✓ RTL preference saved - you won't see this warning again")
+    return proceed if proceed is not None else False
+
+
 def _prompt_required_text(prompt: str) -> str | None:
     """Prompt until a non-empty string is provided or the user cancels."""
     while True:
@@ -23,24 +65,25 @@ def _prompt_required_text(prompt: str) -> str | None:
         click.echo("A value is required. Please try again.")
 
 
-@click.command()
-def init() -> None:
-    """Interactively set up $HOME/.gac.env for gac."""
-    click.echo("Welcome to gac initialization!\n")
-
-    # Load existing environment values
-    existing_env = {}
+def _load_existing_env() -> dict[str, str]:
+    """Ensure the env file exists and return its current values."""
+    existing_env: dict[str, str] = {}
     if GAC_ENV_PATH.exists():
         click.echo(f"$HOME/.gac.env already exists at {GAC_ENV_PATH}. Values will be updated.")
-        existing_env = dict(dotenv_values(str(GAC_ENV_PATH)))
+        existing_env = {k: v for k, v in dotenv_values(str(GAC_ENV_PATH)).items() if v is not None}
     else:
         GAC_ENV_PATH.touch()
         click.echo(f"Created $HOME/.gac.env at {GAC_ENV_PATH}.")
+    return existing_env
+
 
+def _configure_model(existing_env: dict[str, str]) -> bool:
+    """Run the provider/model/API key configuration flow."""
     providers = [
         ("Anthropic", "claude-haiku-4-5"),
         ("Cerebras", "zai-glm-4.6"),
         ("Chutes", "zai-org/GLM-4.6-FP8"),
+        ("Claude Code", "claude-sonnet-4-5"),
         ("Custom (Anthropic)", ""),
         ("Custom (OpenAI)", ""),
         ("DeepSeek", "deepseek-chat"),
@@ -63,13 +106,14 @@ def init() -> None:
     provider = questionary.select("Select your provider:", choices=provider_names).ask()
     if not provider:
         click.echo("Provider selection cancelled. Exiting.")
-        return
+        return False
     provider_key = provider.lower().replace(".", "").replace(" ", "-").replace("(", "").replace(")", "")
 
     is_ollama = provider_key == "ollama"
     is_lmstudio = provider_key == "lm-studio"
     is_streamlake = provider_key == "streamlake"
     is_zai = provider_key in ("zai", "zai-coding")
+    is_claude_code = provider_key == "claude-code"
     is_custom_anthropic = provider_key == "custom-anthropic"
     is_custom_openai = provider_key == "custom-openai"
 
@@ -77,7 +121,7 @@ def init() -> None:
         endpoint_id = _prompt_required_text("Enter the Streamlake inference endpoint ID (required):")
         if endpoint_id is None:
             click.echo("Streamlake configuration cancelled. Exiting.")
-            return
+            return False
         model_to_save = endpoint_id
     else:
         model_suggestion = dict(providers)[provider]
@@ -88,7 +132,7 @@ def init() -> None:
         model = questionary.text(model_prompt, default=model_suggestion).ask()
         if model is None:
             click.echo("Model entry cancelled. Exiting.")
-            return
+            return False
         model_to_save = model.strip() if model.strip() else model_suggestion
 
     set_key(str(GAC_ENV_PATH), "GAC_MODEL", f"{provider_key}:{model_to_save}")
@@ -98,7 +142,7 @@ def init() -> None:
         base_url = _prompt_required_text("Enter the custom Anthropic-compatible base URL (required):")
         if base_url is None:
             click.echo("Custom Anthropic base URL entry cancelled. Exiting.")
-            return
+            return False
         set_key(str(GAC_ENV_PATH), "CUSTOM_ANTHROPIC_BASE_URL", base_url)
         click.echo(f"Set CUSTOM_ANTHROPIC_BASE_URL={base_url}")
 
@@ -112,7 +156,7 @@ def init() -> None:
         base_url = _prompt_required_text("Enter the custom OpenAI-compatible base URL (required):")
         if base_url is None:
             click.echo("Custom OpenAI base URL entry cancelled. Exiting.")
-            return
+            return False
         set_key(str(GAC_ENV_PATH), "CUSTOM_OPENAI_BASE_URL", base_url)
         click.echo(f"Set CUSTOM_OPENAI_BASE_URL={base_url}")
     elif is_ollama:
@@ -120,7 +164,7 @@ def init() -> None:
         url = questionary.text(f"Enter the Ollama API URL (default: {url_default}):", default=url_default).ask()
         if url is None:
             click.echo("Ollama URL entry cancelled. Exiting.")
-            return
+            return False
         url_to_save = url.strip() if url.strip() else url_default
         set_key(str(GAC_ENV_PATH), "OLLAMA_API_URL", url_to_save)
         click.echo(f"Set OLLAMA_API_URL={url_to_save}")
@@ -129,11 +173,46 @@ def init() -> None:
         url = questionary.text(f"Enter the LM Studio API URL (default: {url_default}):", default=url_default).ask()
         if url is None:
             click.echo("LM Studio URL entry cancelled. Exiting.")
-            return
+            return False
         url_to_save = url.strip() if url.strip() else url_default
         set_key(str(GAC_ENV_PATH), "LMSTUDIO_API_URL", url_to_save)
         click.echo(f"Set LMSTUDIO_API_URL={url_to_save}")
 
+    # Handle Claude Code OAuth separately
+    if is_claude_code:
+        from gac.oauth.claude_code import authenticate_and_save, load_stored_token
+
+        existing_token = load_stored_token()
+        if existing_token:
+            click.echo("\n✓ Claude Code access token already configured.")
+            action = questionary.select(
+                "What would you like to do?",
+                choices=[
+                    "Keep existing token",
+                    "Re-authenticate (get new token)",
+                ],
+            ).ask()
+
+            if action is None or action.startswith("Keep existing"):
+                if action is None:
+                    click.echo("Claude Code configuration cancelled. Keeping existing token.")
+                else:
+                    click.echo("Keeping existing Claude Code token")
+                return True
+            else:
+                click.echo("\n🔐 Starting Claude Code OAuth authentication...")
+                if not authenticate_and_save(quiet=False):
+                    click.echo("❌ Claude Code authentication failed. Keeping existing token.")
+                    return False
+                return True
+        else:
+            click.echo("\n🔐 Starting Claude Code OAuth authentication...")
+            click.echo("   (Your browser will open automatically)\n")
+            if not authenticate_and_save(quiet=False):
+                click.echo("\n❌ Claude Code authentication failed. Exiting.")
+                return False
+            return True
+
     # Determine API key name based on provider
     if is_lmstudio:
         api_key_name = "LMSTUDIO_API_KEY"
@@ -189,7 +268,13 @@ def init() -> None:
         else:
             click.echo("No API key entered. You can add one later by editing ~/.gac.env")
 
-    # Language selection
+    return True
+
+
+def _configure_language(existing_env: dict[str, str]) -> None:
+    """Run the language configuration flow."""
+    from gac.language_cli import is_rtl_text
+
     click.echo("\n")
     existing_language = existing_env.get("GAC_LANGUAGE")
 
@@ -216,7 +301,11 @@ def init() -> None:
             # Proceed with language selection
             display_names = [lang[0] for lang in Languages.LANGUAGES]
             language_selection = questionary.select(
-                "Select a language for commit messages:", choices=display_names, use_shortcuts=True, use_arrow_keys=True
+                "Select a language for commit messages:",
+                choices=display_names,
+                use_shortcuts=True,
+                use_arrow_keys=True,
+                use_jk_keys=False,
             ).ask()
 
             if not language_selection:
@@ -237,10 +326,30 @@ def init() -> None:
                         language_value = None
                     else:
                         language_value = custom_language.strip()
+
+                        # Check if the custom language appears to be RTL
+                        if is_rtl_text(language_value):
+                            if not _should_show_rtl_warning_for_init():
+                                click.echo(
+                                    f"\nℹ️  Using RTL language {language_value} (RTL warning previously confirmed)"
+                                )
+                            else:
+                                if not _show_rtl_warning_for_init(language_value):
+                                    click.echo("Language selection cancelled. Keeping existing language.")
+                                    language_value = None
                 else:
                     # Find the English name for the selected language
                     language_value = next(lang[1] for lang in Languages.LANGUAGES if lang[0] == language_selection)
 
+                    # Check if predefined language is RTL
+                    if is_rtl_text(language_value):
+                        if not _should_show_rtl_warning_for_init():
+                            click.echo(f"\nℹ️  Using RTL language {language_value} (RTL warning previously confirmed)")
+                        else:
+                            if not _show_rtl_warning_for_init(language_value):
+                                click.echo("Language selection cancelled. Keeping existing language.")
+                                language_value = None
+
                 if language_value:
                     # Ask about prefix translation
                     prefix_choice = questionary.select(
@@ -266,7 +375,11 @@ def init() -> None:
         # No existing language - proceed with normal flow
         display_names = [lang[0] for lang in Languages.LANGUAGES]
         language_selection = questionary.select(
-            "Select a language for commit messages:", choices=display_names, use_shortcuts=True, use_arrow_keys=True
+            "Select a language for commit messages:",
+            choices=display_names,
+            use_shortcuts=True,
+            use_arrow_keys=True,
+            use_jk_keys=False,
         ).ask()
 
         if not language_selection:
@@ -287,10 +400,28 @@ def init() -> None:
                     language_value = None
                 else:
                     language_value = custom_language.strip()
+
+                    # Check if the custom language appears to be RTL
+                    if is_rtl_text(language_value):
+                        if not _should_show_rtl_warning_for_init():
+                            click.echo(f"\nℹ️  Using RTL language {language_value} (RTL warning previously confirmed)")
+                        else:
+                            if not _show_rtl_warning_for_init(language_value):
+                                click.echo("Language selection cancelled. Using English (default).")
+                                language_value = None
             else:
                 # Find the English name for the selected language
                 language_value = next(lang[1] for lang in Languages.LANGUAGES if lang[0] == language_selection)
 
+                # Check if predefined language is RTL
+                if is_rtl_text(language_value):
+                    if not _should_show_rtl_warning_for_init():
+                        click.echo(f"\nℹ️  Using RTL language {language_value} (RTL warning previously confirmed)")
+                    else:
+                        if not _show_rtl_warning_for_init(language_value):
+                            click.echo("Language selection cancelled. Using English (default).")
+                            language_value = None
+
             if language_value:
                 # Ask about prefix translation
                 prefix_choice = questionary.select(
@@ -313,4 +444,29 @@ def init() -> None:
                 click.echo(f"Set GAC_LANGUAGE={language_value}")
                 click.echo(f"Set GAC_TRANSLATE_PREFIXES={'true' if translate_prefixes else 'false'}")
 
+    return
+
+
+@click.command()
+def init() -> None:
+    """Interactively set up $HOME/.gac.env for gac."""
+    click.echo("Welcome to gac initialization!\n")
+
+    existing_env = _load_existing_env()
+    if not _configure_model(existing_env):
+        return
+    _configure_language(existing_env)
+
     click.echo(f"\ngac environment setup complete. You can edit {GAC_ENV_PATH} to update values later.")
+
+
+@click.command()
+def model() -> None:
+    """Interactively update provider/model/API key without language prompts."""
+    click.echo("Welcome to gac model configuration!\n")
+
+    existing_env = _load_existing_env()
+    if not _configure_model(existing_env):
+        return
+
+    click.echo(f"\nModel configuration complete. You can edit {GAC_ENV_PATH} to update values later.")