gac Command-Line Usage

English | 简体中文 | 繁體中文 | 日本語 | 한국어 | हिन्दी | Tiếng Việt | Français | Русский | Español | Português | Norsk | Svenska | Deutsch | Nederlands | Italiano

This document describes all available flags and options for the uvx gac CLI tool.

Table of Contents

• gac Command-Line Usage
  • Table of Contents
  • Basic Usage
  • Core Workflow Flags
  • Message Customization
  • Output and Verbosity
  • Help and Version
  • Example Workflows
  • Advanced
    • Script Integration and External Processing
    • Skipping Pre-commit and Lefthook Hooks
    • Security Scanning
    • Binary File Detection
    • SSL Certificate Verification
  • Configuration Notes
    • Advanced Configuration Options
    • Configuration Subcommands
  • Interactive Mode
    • How It Works
    • When to Use Interactive Mode
    • Usage Examples
    • Question-Answering Workflow
    • Combining with Other Flags
    • Best Practices
  • Usage Statistics
  • Getting Help

Basic Usage

uvx gac init
# Then follow the prompts to configure your provider, model, and API keys interactively
uvx gac

Generates an LLM-powered commit message for staged changes and prompts for confirmation. The confirmation prompt accepts:

• y or yes - Proceed with the commit
• n or no - Cancel the commit
• r or reroll - Regenerate the commit message with the same context
• e or edit - Edit the commit message. By default, opens an in-place TUI with vi/emacs keybindings. Set GAC_EDITOR to open your preferred editor instead (e.g., GAC_EDITOR=code gac for VS Code, GAC_EDITOR=vim gac for vim)
• Any other text - Regenerate with that text as feedback (e.g., make it shorter, focus on performance)
• Empty input (just Enter) - Show the prompt again

---

Core Workflow Flags

Flag / Option	Short	Description
--add-all	-a	Stage all changes before committing
--stage	-S	Interactively select files to stage with a tree-based TUI
--group	-g	Group staged changes into multiple logical commits
--push	-p	Push changes to remote after committing
--yes	-y	Automatically confirm commit without prompting
--dry-run		Show what would happen without making any changes
--message-only		Output only the generated commit message without committing
--no-verify		Skip pre-commit and lefthook hooks when committing
--skip-secret-scan		Skip security scan for secrets in staged changes
--no-verify-ssl		Skip SSL certificate verification (useful for corporate proxies)
--signoff		Add Signed-off-by line to the commit message (DCO compliance)
--interactive	-i	Ask questions about the changes to generate better commits

Note: --stage and --add-all are mutually exclusive. Use --stage to interactively select which files to stage, and --add-all to stage all changes at once.

Note: Combine -a and -g (i.e., -ag) to stage ALL changes first, then group them into commits.

Note: To always use grouped commit mode without typing -g every time, set GAC_ALWAYS_GROUPED=true in your .gac.env file. See Advanced Configuration Options for more details.

Note: When using --group, the max output tokens limit is automatically scaled based on the number of files being committed (2x for 1-9 files, 3x for 10-19 files, 4x for 20-29 files, 5x for 30+ files). This ensures the LLM has enough tokens to generate all grouped commits without truncation, even for large changesets.

Note: --message-only and --group are mutually exclusive. Use --message-only when you want to get the commit message for external processing, and --group when you want to organize multiple commits within the current git workflow.

Note: The --interactive flag asks you questions about your changes to provide additional context to the LLM, resulting in more accurate and detailed commit messages. This is particularly helpful for complex changes or when you want to ensure the commit message captures the full context of your work.

Message Customization

Flag / Option	Short	Description
--one-liner	-o	Generate a single-line commit message
--verbose	-v	Generate detailed commit messages with motivation, architecture, & impact
--hint <text>	-h	Add a hint to guide the LLM
--model <model>	-m	Specify the model to use for this commit
--language <lang>	-l	Override the language (name or code: 'Spanish', 'es', 'zh-CN', 'ja')
--scope	-s	Infer an appropriate scope for the commit
--50-72		Enforce the 50/72 rule for commit message formatting

Note: The --50-72 flag enforces the 50/72 rule where:

• Subject line: maximum 50 characters
• Body lines: maximum 72 characters per line
• This keeps commit messages readable in git log --oneline and GitHub's UI

You can also set GAC_USE_50_72_RULE=true in your .gac.env file to always apply this rule.

Note: You can provide feedback interactively by simply typing it at the confirmation prompt - no need to prefix with 'r'. Type r for a simple reroll, e to edit the message (in-place TUI by default, or your $GAC_EDITOR if set), or type your feedback directly like make it shorter.

Output and Verbosity

Flag / Option	Short	Description
--quiet	-q	Suppress all output except errors
--log-level <level>		Set log level (debug, info, warning, error)
--show-prompt		Print the LLM prompt used for commit message generation

Help and Version

Flag / Option	Short	Description
--version		Show gac version and exit
--help		Show help message and exit

---

Example Workflows

• Stage all changes and commit:

  uvx gac -a
  

• Commit and push in one step:

  uvx gac -ap
  

• Generate a one-line commit message:

  uvx gac -o
  

• Generate a detailed commit message with structured sections:

  uvx gac -v
  

• Add a hint for the LLM:

  uvx gac -h "Refactor authentication logic"
  

• Infer scope for the commit:

  uvx gac -s
  

• Group staged changes into logical commits:

  uvx gac -g
  # Groups only the files you've already staged
  

• Group all changes (staged + unstaged) and auto-confirm:

  uvx gac -agy
  # Stages everything, groups it, and auto-confirms
  

• Use a specific model just for this commit:

  uvx gac -m anthropic:claude-haiku-4-5
  

• Generate commit message in a specific language:

  # Using language codes (shorter)
  uvx gac -l zh-CN
  uvx gac -l ja
  uvx gac -l es
  
  # Using full names
  uvx gac -l "Simplified Chinese"
  uvx gac -l Japanese
  uvx gac -l Spanish
  

• Dry run (see what would happen):

  uvx gac --dry-run
  

• Get only the commit message (for script integration):

  uvx gac --message-only
  # Outputs: feat: add user authentication system
  

• Get commit message in one-liner format:

  uvx gac --message-only --one-liner
  # Outputs: feat: add user authentication system
  

• Use interactive mode to provide context:

  uvx gac -i
  # What is the main purpose of these changes?
  # What problem are you solving?
  # Are there any implementation details worth mentioning?
  

• Interactive mode with verbose output:

  uvx gac -i -v
  # Ask questions and generate detailed commit message
  

Advanced

• Combine flags for more powerful workflows (e.g., uvx gac -ayp to stage, auto-confirm, and push)
• Use --show-prompt to debug or review the prompt sent to the LLM
• Adjust verbosity with --log-level or --quiet
• Use --message-only for script integration and automated workflows

Script Integration and External Processing

The --message-only flag is designed for script integration and external tool workflows. It outputs only the raw commit message without any formatting, spinners, or additional UI elements.

Use cases:

• Agent integration: Allow AI agents to get commit messages and handle commits themselves
• Alternative VCS: Use generated messages with other version control systems (Mercurial, Jujutsu, etc.)
• Custom commit workflows: Process or modify the message before committing
• CI/CD pipelines: Extract commit messages for automated processes

Example script usage:

#!/bin/bash
# Get commit message and use with custom commit function
MESSAGE=$(uvx gac --message-only --add-all --yes)
git commit -m "$MESSAGE"

# Python integration example
import subprocess

def get_commit_message():
    result = subprocess.run(
        ["gac", "--message-only", "--yes"],
        capture_output=True, text=True
    )
    return result.stdout.strip()

message = get_commit_message()
print(f"Generated message: {message}")

Key features for script usage:

• Clean output with no Rich formatting or spinners
• Automatically bypasses confirmation prompts
• No actual commit is made to git
• Works with --one-liner for simplified output
• Can be combined with other flags like --hint, --model, etc.

Skipping Pre-commit and Lefthook Hooks

The --no-verify flag allows you to skip any pre-commit or lefthook hooks configured in your project:

uvx gac --no-verify  # Skip all pre-commit and lefthook hooks

Use --no-verify when:

• Pre-commit or lefthook hooks are failing temporarily
• Working with time-consuming hooks
• Committing work-in-progress code that doesn't pass all checks yet

Note: Use with caution as these hooks maintain code quality standards.

Security Scanning

uvx gac includes built-in security scanning that automatically detects potential secrets and API keys in your staged changes before any AI API calls are made. If a secret is detected, the workflow aborts immediately — no API call occurs. This ensures your sensitive data is never sent to any AI model. The scanner uses regex-based pattern matching, not LLMs, so scanning is fast and runs entirely locally.

Skipping security scans:

uvx gac --skip-secret-scan  # Skip security scan for this commit

To disable permanently: Set GAC_SKIP_SECRET_SCAN=true in your .gac.env file.

When to skip:

• Committing example code with placeholder keys
• Working with test fixtures that contain dummy credentials
• When you've verified the changes are safe

Note: The scanner uses regex-based pattern matching (not LLMs) to detect common secret formats. It runs before any AI API call — if a secret is found, no API call occurs. Always review your staged changes before committing.

Binary File Detection

uvx gac includes automatic detection of binary files in staged changes, preventing accidental commits of compiled files, images, and other binary assets that typically shouldn't be in version control. The detector uses multiple strategies:

• Extension-based detection - Fast recognition of 60+ binary file types
• Null byte detection - Reliable indicator of binary content
• UTF-8 validity checking - Text files should be valid UTF-8 or ASCII
• Magic byte identification - Detects file types from file signatures

Supported binary types:

• Executables: .exe, .dll, .so, .dylib, .bin, .o, .obj, .lib, .a
• Archives: .zip, .tar, .gz, .bz2, .7z, .rar, .xz, .zst
• Images: .png, .jpg, .jpeg, .gif, .bmp, .ico, .tiff, .webp
• Media: .mp3, .wav, .ogg, .flac, .m4a, .aac, .mp4, .avi, .mkv, .mov, .wmv
• Fonts: .ttf, .otf, .woff, .woff2, .eot
• Documents: .pdf, .doc, .docx, .xls, .xlsx, .ppt, .pptx
• Databases: .db, .sqlite, .sqlite3, .mdb, .accdb
• Compiled code: .class, .jar, .war, .ear, .pyc, .pyd, .pyo, .beam, .hi

When binary files are detected:

uvx gac
# Output:
# BINARY FILE WARNING: Binary files detected!
#
#   • image.png
#     Type: Image file
#     Size: 2.3 MB
#
# Binary files should typically be excluded from version control.
# Use .gitignore to prevent accidental commits of binary files.
#
# Options:
#   [a] Abort commit (recommended)
#   [c] Continue anyway (you know what you're doing)
#   [r] Unstage binary file(s) and continue
#
# Choose an option [a]:

Best practices:

1. Add binary patterns to .gitignore:

   # Compiled files
   *.exe
   *.dll
   *.so
   *.dylib
   *.o
   *.a
   
   # Images
   *.png
   *.jpg
   *.jpeg
   *.gif
   
   # Archives
   *.zip
   *.tar.gz
   
   # Python
   *.pyc
   __pycache__/
   

2. Use Git LFS for large binary files that must be tracked:

   git lfs track "*.psd"
   git lfs track "*.zip"
   

3. Commit binary files only when necessary:

   • Icons and assets that are part of the codebase
   • Test fixtures that need to be versioned
   • Documentation images

Note: Binary detection runs automatically during the commit workflow (similar to secret scanning). There is no flag to disable it, as binary files generally should not be committed unless there's a specific reason. If you need to commit a binary file, choose the "Continue anyway" option or ensure it's properly documented in your project's guidelines.

SSL Certificate Verification

uvx gac supports skipping SSL certificate verification for environments where corporate proxies intercept SSL traffic and cause certificate verification failures.

Skipping SSL verification:

uvx gac --no-verify-ssl  # Skip SSL verification for this commit

To disable permanently: Set GAC_NO_VERIFY_SSL=true in your .gac.env file, or add no_verify_ssl=true to your configuration.

When to use:

• Corporate environments with SSL-intercepting proxies
• Development environments with self-signed certificates
• When you encounter SSL certificate verification errors

Note: Disabling SSL verification reduces security. Only use this option when necessary and in trusted network environments.

Signed-off-by Line (DCO Compliance)

uvx gac supports adding a Signed-off-by line to commit messages, which is required for Developer Certificate of Origin (DCO) compliance in many open-source projects.

Adding signoff:

uvx gac --signoff  # Add Signed-off-by line to the commit

To enable permanently: Set GAC_SIGNOFF=true in your .gac.env file, or add signoff=true to your configuration.

What it does:

• Appends Signed-off-by: Your Name <your.email@example.com> to the commit message
• Uses your git config (user.name and user.email) to populate the line
• Required for projects like Cherry Studio, Linux kernel, and others using DCO

Setting up your git identity:

Ensure your git config has the correct name and email:

git config --global user.name "Your Full Name"
git config --global user.email "your.email@example.com"

Note: The signoff line is added by git during the commit, not by the AI during message generation. You won't see it in the preview, but it will be in the final commit (check with git log -1).

Configuration Notes

• The recommended way to set up gac is to run uvx gac init and follow the interactive prompts.
• Already configured language and just need to switch providers or models? Run uvx gac model to repeat the setup without language questions.
• Using Claude Code? See the Claude Code setup guide for OAuth authentication instructions.
• Using ChatGPT OAuth? See the ChatGPT OAuth setup guide for browser-based authentication instructions.
• Using GitHub Copilot? See the GitHub Copilot setup guide for Device Flow authentication instructions.
• gac loads configuration in the following order of precedence:
  1. CLI flags
  2. Project-level .gac.env
  3. User-level ~/.gac.env
  4. Shell environment variables

Advanced Configuration Options

You can customize gac's behavior with these optional environment variables:

• GAC_EDITOR=code --wait - Override the editor used when you press e at the confirmation prompt. By default, e opens an in-place TUI; setting GAC_EDITOR switches to an external editor. Supports any editor command with arguments. Wait flags (--wait/-w) are auto-inserted for known GUI editors (VS Code, Cursor, Zed, Sublime Text) so the process blocks until you close the file
• GAC_ALWAYS_INCLUDE_SCOPE=true - Automatically infer and include scope in commit messages (e.g., feat(auth): vs feat:)
• GAC_ALWAYS_GROUPED=true - Always use grouped commit mode (equivalent to always passing the -g or --group flag)
• GAC_VERBOSE=true - Generate detailed commit messages with motivation, architecture, and impact sections
• GAC_USE_50_72_RULE=true - Always enforce the 50/72 rule for commit messages (subject ≤50 chars, body lines ≤72 chars)
• GAC_SIGNOFF=true - Always add Signed-off-by line to commits (for DCO compliance)
• GAC_TEMPERATURE=0.7 - Control LLM creativity (0.0-1.0, lower = more focused)
• GAC_REASONING_EFFORT=medium - Control reasoning/thinking depth for models that support extended thinking (low, medium, high, max). Leave unset to use each model's default. Only sent to compatible providers (OpenAI-style; not Anthropic).
• GAC_MAX_OUTPUT_TOKENS=4096 - Maximum tokens for generated messages (automatically scaled 2-5x when using --group based on file count; override to go higher or lower)
• GAC_WARNING_LIMIT_TOKENS=4096 - Warn when prompts exceed this token count
• GAC_SYSTEM_PROMPT_PATH=/path/to/custom_prompt.txt - Use a custom system prompt for commit message generation
• GAC_LANGUAGE=Spanish - Generate commit messages in a specific language (e.g., Spanish, French, Japanese, German). Supports full names or ISO codes (es, fr, ja, de, zh-CN). Use uvx gac language for interactive selection
• GAC_TRANSLATE_PREFIXES=true - Translate conventional commit prefixes (feat, fix, etc.) into the target language (default: false, keeps prefixes in English)
• GAC_SKIP_SECRET_SCAN=true - Disable automatic security scanning for secrets in staged changes (use with caution)
• GAC_NO_VERIFY_SSL=true - Skip SSL certificate verification for API calls (useful for corporate proxies that intercept SSL traffic)
• GAC_DISABLE_STATS=true - Disable usage statistics tracking (no stats file reads or writes; existing data is preserved). Only truthy values disable stats; setting it to false/0/no/off keeps stats enabled, same as leaving it unset

See .gac.env.example for a complete configuration template.

For detailed guidance on creating custom system prompts, see docs/CUSTOM_SYSTEM_PROMPTS.md.

Configuration Subcommands

The following subcommands are available:

• uvx gac init — Interactive setup wizard for provider, model, and language configuration
• uvx gac model — Provider/model/API key setup without language prompts (ideal for quick switches)
• uvx gac auth — Show OAuth authentication status for all providers
• uvx gac auth claude-code login — Login to Claude Code using OAuth (opens browser)
• uvx gac auth claude-code logout — Logout from Claude Code and remove stored token
• uvx gac auth claude-code status — Check Claude Code authentication status
• uvx gac auth chatgpt login — Login to ChatGPT using OAuth (opens browser)
• uvx gac auth chatgpt logout — Logout from ChatGPT and remove stored tokens
• uvx gac auth chatgpt status — Check ChatGPT authentication status
• uvx gac auth copilot login — Login to GitHub Copilot using Device Flow
• uvx gac auth copilot login --host ghe.mycompany.com — Login to Copilot on a GitHub Enterprise instance
• uvx gac auth copilot logout — Logout from Copilot and remove stored tokens
• uvx gac auth copilot status — Check Copilot authentication status
• uvx gac config show — Show current configuration
• uvx gac config set KEY VALUE — Set a config key in $HOME/.gac.env
• uvx gac config get KEY — Get a config value
• uvx gac config unset KEY — Remove a config key from $HOME/.gac.env
• uvx gac language (or uvx gac lang) — Interactive language selector for commit messages (sets GAC_LANGUAGE)
• uvx gac editor (or uvx gac edit) — Interactive editor selector for the e key at the confirmation prompt (sets GAC_EDITOR)
• uvx gac diff — Show filtered git diff with options for staged/unstaged changes, color, and truncation
• uvx gac serve — Start GAC as an MCP server for AI agent integration (stdio transport)
• uvx gac stats show — View your gac usage statistics (totals, streaks, daily & weekly activity, token usage, top projects with avg files, top models with speed and latency)
• uvx gac stats models — View detailed stats for all models with token breakdowns, speed, latency, and per-commit latency comparison charts
• uvx gac stats projects — View stats for all projects with token breakdowns and avg files per gac
• uvx gac stats recent — View your last 10 gacs with per-gac tokens, speed, latency, and files (-n 20 for more)
• uvx gac stats reset — Reset all statistics to zero (prompts for confirmation)
• uvx gac stats reset model <model-id> — Reset statistics for a specific model (case-insensitive match)

Interactive Mode

The --interactive (-i) flag enhances gac's commit message generation by asking you targeted questions about your changes. This additional context helps the LLM create more accurate, detailed, and contextually appropriate commit messages.

How It Works

When you use --interactive, gac will prompt you with questions such as:

• What is the main purpose of these changes? - Helps understand the high-level goal
• What problem are you solving? - Provides context about the motivation
• Are there any implementation details worth mentioning? - Captures technical specifics
• Are there any breaking changes? - Identifies potential impact issues
• Is this related to any issue or ticket? - Links to project management

When to Use Interactive Mode

Interactive mode is particularly useful for:

• Complex changes where the context isn't obvious from the diff alone
• Refactoring work that spans multiple files and concepts
• New features that require explanation of the overall purpose
• Bug fixes where the root cause isn't immediately visible
• Performance optimizations where the reasoning isn't obvious
• Code review preparation - the questions help you think through your changes

Usage Examples

Basic interactive mode:

uvx gac -i

This will:

1. Show you a summary of staged changes
2. Ask you questions about the changes
3. Generate a commit message incorporating your answers
4. Prompt for confirmation (or auto-confirm if combined with -y)

Interactive mode with staged changes:

uvx gac -ai
# Stage all changes, then ask questions for better context

Interactive mode with specific hints:

uvx gac -i -h "Database migration for user profiles"
# Ask questions while providing a specific hint to focus the LLM

Interactive mode with verbose output:

uvx gac -i -v
# Ask questions and generate a detailed, structured commit message

Auto-confirmed interactive mode:

uvx gac -i -y
# Ask questions but auto-confirm the resulting commit

Question-Answering Workflow

The interactive workflow follows this pattern:

1. Review changes - gac shows a summary of what you're committing
2. Answer questions - respond to each prompt with relevant details
3. Context enhancement - your answers are added to the LLM prompt
4. Message generation - the LLM creates a commit message with full context
5. Confirmation - review and confirm the commit (or auto-confirm with -y)

Tips for providing helpful answers:

• Be concise but thorough - provide the key details without being overly verbose
• Focus on the "why" - explain the reasoning behind your changes
• Mention constraints - note any limitations or special considerations
• Link to external context - reference issues, documentation, or design docs
• Empty answers are fine - if a question doesn't apply, just press Enter

Combining with Other Flags

Interactive mode works well with most other flags:

# Stage all changes and ask questions
uvx gac -ai

# Ask questions with verbose output
uvx gac -i -v

Best Practices

• Use for complex PRs - especially helpful for pull requests that need detailed descriptions
• Team collaboration - the questions help you think through changes that others will review
• Documentation preparation - your answers can help form the basis for release notes
• Learning tool - the questions reinforce good commit message practices
• Skip when making simple changes - for trivial fixes, basic mode may be faster

Usage Statistics

uvx gac tracks lightweight usage statistics so you can see your commit activity, streaks, token usage, and most-active projects and models. Stats are stored locally in ~/.gac_stats.json and never sent anywhere — there is no telemetry.

What's tracked: total gac runs, total commits, total prompt, output, and reasoning tokens, first/last used dates, daily and weekly counts (gacs, commits, tokens), current and longest streak, per-project activity (gacs, commits, tokens), and per-model activity (gacs, tokens).

What's NOT tracked: commit messages, code content, file paths, personal information, or anything beyond counts, dates, project names (derived from git remote or directory name), and model names.

Opting In or Out

uvx gac init asks whether to enable stats and explains exactly what's stored. You can change your mind at any time:

• Enable stats: unset GAC_DISABLE_STATS or set it to false/0/no/off/empty.
• Disable stats: set GAC_DISABLE_STATS to a truthy value (true, 1, yes, on).

When you decline stats during uvx gac init and an existing ~/.gac_stats.json is detected, you'll be offered the option to delete it.

Stats Subcommands

Command	Description
uvx gac stats	Show your stats (same as uvx gac stats show)
uvx gac stats show	Display full stats: totals, streaks, daily & weekly activity, token usage, top projects, top models
uvx gac stats models	Show detailed stats for all models used, with token breakdowns, speed, latency, and per-commit latency charts
uvx gac stats projects	Show stats for all projects with token breakdowns and avg files per gac
uvx gac stats recent	Show your last 10 gacs (use -n 20 for more), with per-gac tokens, speed, latency, and files
uvx gac stats reset	Reset all statistics to zero (prompts for confirmation)
uvx gac stats reset model <model-id>	Reset statistics for a specific model (case-insensitive match)

Examples

# View your overall stats
uvx gac stats

# Detailed breakdown of every model you've used
uvx gac stats models

# Stats for all projects
uvx gac stats projects

# Recent gac history (last 20)
uvx gac stats recent -n 20

# Reset all stats (with confirmation prompt)
uvx gac stats reset

# Reset stats for a specific model
uvx gac stats reset model wafer:deepseek-v4-pro

What You'll See

Running uvx gac stats displays:

• Total gacs and commits — how many times you've used gac and how many commits it created
• Current and longest streak — consecutive days with gac activity (🔥 at 5+ days)
• Activity summary — today's and this week's gacs, commits, and tokens vs your peak day and peak week
• Top projects — your 5 most-active repos by gac + commit count, with avg files per gac and token usage
• Top models — your 5 most-used models with all-time speed, latency, and token usage

Running uvx gac stats projects shows all projects (not just the top 5) with:

• All Projects table — every project sorted by activity, with gac count, commit count, commits-per-gac ratio, avg files per gac, prompt tokens, output tokens, reasoning tokens, total tokens, and share of total gacs
• Activity bar chart — horizontal bars showing relative gac count per project
• Token Usage bar chart — horizontal bars showing relative token consumption per project

Running uvx gac stats models shows all models (not just the top 5) with:

• All Models table — every model you've used sorted by activity, with gac count, commit count, all-time speed (tokens/sec), all-time latency, prompt tokens, output tokens, reasoning tokens, and total tokens
• Speed Comparison (30d) chart — a horizontal bar chart of recent (last 30 days) model speeds, sorted fastest to slowest, color-coded by speed percentile (🟡 blazing, 🟢 fast, 🔵 moderate, 🔘 slow)
• Latency Comparison (30d) chart — a horizontal bar chart of recent per-call latency, sorted shortest to longest
• Per-Commit Latency (30d) chart — a horizontal bar chart of recent latency divided by commit count, showing real wait time per commit (a model that does 5 commits in a 10s gac costs 2s/commit vs one that does 1 commit in a 25s gac at 25s/commit)
• High score celebrations — 🏆 trophies when you set new daily, weekly, token, or streak records; 🥈 for tying them
• Encouragement messages — contextual nudges based on your activity

Running uvx gac stats recent shows your last 10 gacs (configurable with -n):

• Recent Gacs table — each gac with relative time, project, model, commit count, files, speed, latency, and per-gac token breakdown

Disabling Stats

Set the GAC_DISABLE_STATS environment variable to a truthy value:

# Disable stats tracking
export GAC_DISABLE_STATS=true

# Or in .gac.env
GAC_DISABLE_STATS=true

Falsy values (false, 0, no, off, empty) keep stats enabled — the same as leaving the variable unset.

When disabled, gac skips all stats recording — no file reads or writes occur. Existing data is preserved but won't be updated until you re-enable.

---

Discord Webhook Notifications

gac can ping a Discord channel every time you land a commit, using a webhook URL from your channel's integration settings. The integration is opt-in: it does nothing until you explicitly configure a webhook URL.

Setup

Use the dedicated discord subcommand group:

uvx gac discord setup     # interactively configure a webhook URL
uvx gac discord show      # show whether a webhook is configured (URL masked)
uvx gac discord test      # send a test notification to the configured webhook
uvx gac discord remove    # remove the configured webhook URL

Alternatively, set the variable directly in $HOME/.gac.env (or ./.gac.env):

GAC_DISCORD_WEBHOOK_URL='https://discord.com/api/webhooks/XXXX/YYYY'

Behavior

• Fires after each successful commit (single and grouped workflows). Skipped on --dry-run and --message-only.
• Posts a GitHub-style embed with a green stripe, repo + branch as the author row, the commit subject as the title, the commit body as the description, and the short SHA in the footer.
• Uses the gac avatar and the username gac.
• Webhook failures are logged at WARNING and never block your commit.
• Leave GAC_DISCORD_WEBHOOK_URL unset (or blank) to disable. gac init is unaffected — Discord setup lives only under gac discord.

---

Getting Help

• For MCP server setup (AI agent integration), see docs/MCP.md
• For custom system prompts, see docs/CUSTOM_SYSTEM_PROMPTS.md
• For Claude Code OAuth setup, see docs/CLAUDE_CODE.md
• For ChatGPT OAuth setup, see docs/CHATGPT_OAUTH.md
• For GitHub Copilot setup, see docs/GITHUB_COPILOT.md
• For troubleshooting and advanced tips, see docs/TROUBLESHOOTING.md
• For installation and configuration, see README.md#installation-and-configuration
• To contribute, see docs/CONTRIBUTING.md
• License information: LICENSE