CCG — Code Change Guardian

CCG (Code Change Guardian) is a multi-model code review and Git workflow automation system. Two independent AI model families guard every change across Review · Commit · Merge · Push — divergence-aware review, risk-aware model routing, AI merge-conflict resolution, and a pre-push gate, from the working tree to the remote.

CCG runs two independent models in parallel on each diff and lets Claude synthesize their findings. When they agree, signal is low; when they diverge, that's where humans should focus. Beyond review it adds a zero-LLM commit gate, AI-powered merge-conflict resolution, and a graphical pre-push scorecard — with a JSONL ledger that makes every review reusable.

Other languages: 简体中文 · 日本語 · 한국어

Why CCG

CCG guards the entire path from working tree to remote — not just the review step. Each stage targets a specific pain point:

Problem	CCG's Answer
Single-model review has blind spots	Two independent model families review in parallel — surface where they disagree
One-size-fits-all model wastes money / quality	Risk-aware auto-routing: cheap for low-risk, premium for critical
Merge conflicts are tedious and error-prone	AI conflict resolution with Bailian as primary — multiple safety guards, never silently drops code
Push decisions lack context	Stage 4 produces a graphical quality scorecard before push
Reviews aren't reusable	JSONL ledger captures every review, queryable by path

Installation

npm 安装（推荐）

npm install -g @mcgrapeng/ccg

从源码安装

git clone https://github.com/mcgrapeng/ccg.git
cd ccg
npm link

验证安装

ccg --version
ccg doctor        # 检查环境配置

环境要求:

bash 3.2+, git, curl, jq
Node.js >= 16

Configuration

CCG supports two configuration methods (config file takes priority over environment variables):

Method 1: Config File (Recommended)

One-time setup, permanent effect:

# Initialize config file
ccg config init

# Set API keys (pick one or more)
ccg config set DEEPSEEK_API_KEY sk-xxx
ccg config set KIMI_API_KEY sk-xxx
ccg config set BAILIAN_API_KEY sk-xxx
ccg config set ANTHROPIC_API_KEY sk-ant-xxx

# Set default provider (optional)
ccg config set CCG_PROVIDERS deepseek

# View all config
ccg config list

# Edit config file directly
ccg config edit

Config file location: ~/.config/ccg/config

Method 2: Environment Variables

# Set in ~/.bashrc or ~/.zshrc
export DEEPSEEK_API_KEY="sk-xxx"
export KIMI_API_KEY="sk-xxx"

Priority: Environment variables > Config file > Default values

自定义 API 端点（支持第三方代理）:

CCG_CODEX_BASE_URL / OPENAI_BASE_URL — Codex / OpenAI 代理
CCG_CLAUDE_BASE_URL / ANTHROPIC_BASE_URL — Claude / Anthropic 代理
CCG_GEMINI_BASE_URL / GEMINI_BASE_URL — Gemini 代理
CCG_BAILIAN_BASE_URL — 百炼代理

Quick Start

# 1. Review your current changes
ccg review

# 2. Auto-commit if review gate passes
ccg commit "feat: add user auth"

# 3. Merge with AI conflict resolution
ccg merge main

# 4. Pre-push graphical analysis & decision
ccg push origin main

# Helper commands
ccg config           # Show current configuration
ccg models           # List all available models

Skip Review Mode

For trivial changes (docs, typos) you can disable Stage 1 entirely:

# Skip review — commit becomes the first stage
export CCG_REVIEW=off

ccg commit "docs: fix typo"   # Auto git add + commits (no LLM)
ccg push origin main           # Push still works

# Re-enable later
unset CCG_REVIEW   # or: export CCG_REVIEW=on

The CCG_REVIEW switch accepts: on (default) / off / 0 / false / disabled.

Complete Workflow

Default Flow (Review enabled)

┌───────────────────────────────────────────────────────────────────────┐
│  Stage 1: ccg review                                  【3 LLM calls】 │
│  ─────────────────────                                                │
│   1. ccg_init           → mktemp workdir + paths                      │
│   2. ccg_diff_capture   → 4-level fallback (worktree / staged / ...)  │
│   3. ccg_risk_score     → Bailian LLM (fallback: rule engine)         │
│   4. Auto-pick CCG_MODE (cost/balanced/quality) by risk               │
│   5. Run any 2 providers in parallel (codex/gemini/bailian)           │
│   6. ccg_synthesize     → Claude meta-review                          │
│      → CLASSIFICATION: AGREEMENT / DIVERGENCE / BLINDSPOT             │
│      → VERDICT: merge / fix-required / discuss                        │
│   7. Persist state to <repo>/.git/ccg/last-review.json                │
└───────────────────────────────────────────────────────────────────────┘
                                  ↓
┌───────────────────────────────────────────────────────────────────────┐
│  Stage 2: ccg commit "msg"                            【0 LLM calls】 │
│  ─────────────────────────                                            │
│   1. git add -A               (auto-stage worktree; opt out via       │
│                                CCG_NO_AUTO_ADD=1)                     │
│   2. Read last-review.json    (refuses if missing)                    │
│   3. Compare staged diff hash with reviewed hash                      │
│      → mismatch? refuse and ask user to re-run 'ccg review'           │
│   4. Apply verdict:                                                   │
│      • merge        → ✅ commit                                       │
│      • discuss      → ⚠️ commit (or block if CCG_GATE_DISCUSS=block)  │
│      • fix-required → ❌ block                                        │
│   5. git commit -m "msg"                                              │
│   6. Delete state file (one-shot)                                     │
└───────────────────────────────────────────────────────────────────────┘
                                  ↓
┌───────────────────────────────────────────────────────────────────────┐
│  Stage 3: ccg merge <target>                       【on-demand LLM】 │
│  ───────────────────────────                                          │
│   1. Safety checks: clean tree, no detached HEAD, no mid-op           │
│   2. git fetch + sync local target with origin                        │
│   3. Create backup branch (ccg-backup/<target>-<ts>-<pid>-<rand>)     │
│   4. git checkout target + git merge --no-commit feature              │
│   5. For each conflict file:                                          │
│      a. classify (content / binary / submodule / symlink / ...)       │
│      b. parse <<<<<<< >>>>>>> blocks                                  │
│      c. AI resolution (Bailian → Claude → Codex+Gemini)               │
│      d. validate (no markdown fences, no conflict markers, non-empty) │
│      e. atomic file rewrite (mktemp + mv, preserve perms)             │
│      f. git add (only if resolved cleanly)                            │
│   6. git commit (if all clean) OR leave uncommitted (if needs-human)  │
│   7. Real-time progress: [3/12] src/auth.js ... ✅ resolved           │
└───────────────────────────────────────────────────────────────────────┘
                                  ↓
┌───────────────────────────────────────────────────────────────────────┐
│  Stage 4: ccg push <remote> <branch>                 【1 LLM call】  │
│  ──────────────────────────────────                                   │
│   1. Detect upstream + remote URL                                     │
│   2. Compute commits ahead / behind                                   │
│   3. List commits with quality markers (✓ conventional / ⚠ WIP)       │
│   4. Categorize files (💻 code / 🧪 tests / 📖 docs / ⚙️ config)      │
│   5. Detect sensitive files (.env / *.pem / credentials / ...)        │
│   6. ccg_risk_score on the push diff (Bailian LLM)                    │
│   7. Quality Scorecard (5 checks):                                    │
│      • conventional commit messages                                   │
│      • tests updated alongside code                                   │
│      • no sensitive files                                             │
│      • up to date with remote                                         │
│      • risk level acceptable                                          │
│   8. Recommendation: 🟢 READY / 🟡 CAUTION / 🔴 NOT RECOMMENDED       │
│   9. Decision prompt: y/n/d (diff)/l (log)                            │
│  10. git push (if y)                                                  │
└───────────────────────────────────────────────────────────────────────┘

Skip-Review Flow (`CCG_REVIEW=off`)

┌───────────────────────────────────────────────────────────────────────┐
│  Stage 1: ccg review                                   【0 LLM calls】│
│  → ℹ️  Review stage is DISABLED — no-op                              │
└───────────────────────────────────────────────────────────────────────┘

┌───────────────────────────────────────────────────────────────────────┐
│  Stage 2: ccg commit "msg"                             【0 LLM calls】│
│  → 1. git add -A                                                      │
│  → 2. ⚠️  Review stage DISABLED — committing without review           │
│  → 3. git commit -m "msg"                                             │
└───────────────────────────────────────────────────────────────────────┘
                                  ↓
            (Stage 3 / Stage 4 unchanged from default flow)

The 4 Stages

CCG is built around four stages. Each has a specific purpose, model strategy, and safety guarantees.

Stage 1 — Code Review (`ccg review`)

Purpose: Identify bugs, security issues, and quality problems in your diff.

Model strategy:

Runs any 2 models in parallel from different vendors
Default depends on mode:
- cost/balanced: two different-vendor Bailian models (e.g., qwen-3.5-haiku + deepseek-v4-lite)
- quality: codex + gemini (CLI-based, independent)
🚫 Claude is STRICTLY FORBIDDEN in Stage 1 — it is reserved exclusively for the Synthesis step where it serves as the meta-reviewer with an independent perspective
Models are selected by current CCG_MODE (see Model Strategy)

CCG_PROVIDERS syntax (Stage 1 only — max 2 parallel):

# quality mode default — codex + gemini (CLI-based, independent)
CCG_PROVIDERS="codex gemini"

# Same provider, two different models — e.g., 2 Bailian models in parallel
CCG_PROVIDERS="bailian:qwen-3.7 bailian:deepseek-v4"

# Mix providers with explicit model overrides (quality mode only)
CCG_MODE=quality CCG_PROVIDERS="codex:gpt-5.5 gemini:gemini-3.5-flash"

# Cost optimization — all domestic models
CCG_PROVIDERS="bailian:kimi-k2.6 bailian:glm-5.1"

# ❌ DO NOT do this — claude is rejected and ccg review will return error
# CCG_PROVIDERS="claude codex"

Output: Synthesis classified as one of:

AGREEMENT — both reviewers flag same issues (high confidence)
DIVERGENCE — reviewers contradict (needs human judgment)
BLINDSPOT — one missed issues the other caught (highest signal)

Pipeline:

git diff → risk scoring → mode selection
   → parallel: [Codex review + Bailian review]
   → synthesize → AGREEMENT | DIVERGENCE | BLINDSPOT

Safety guarantees:

Prompt injection defense (untrusted-content markers, per-call nonce)
Diff size warning (>200KB may exceed context)
Cleanup trap (Ctrl+C kills child processes)
Partial-failure handling (1/2 success → continue with warning)

Stage 2 — Auto Commit (`ccg commit`)

Purpose: Enforce that only reviewed code reaches git history — without any extra LLM calls.

Model strategy: 🚫 No LLM calls in Stage 2. Reuses Stage 1's synthesis verdict.

How it works:

Auto-stage worktree with git add -A (opt out via CCG_NO_AUTO_ADD=1)
Read state file from <repo>/.git/ccg/last-review.json (written by Stage 1)
Verify the staged diff hash matches the reviewed hash
Apply the recorded verdict (merge / fix-required / discuss)
git commit -m "msg"
Delete the state file (one-shot — next commit needs a fresh review)

State file contents:

{
  "ts": "2026-05-29T11:30:00Z",
  "diff_hash": "acb9adaab6516b3e7fc66fed10dd8a8d",
  "diff_source": "worktree",
  "verdict": "merge",
  "classification": "AGREEMENT",
  "mode": "balanced"
}

Verdicts:

Verdict	Action
`merge`	✅ Commit allowed
`discuss`	⚠️ Allowed by default (set `CCG_GATE_DISCUSS=block` to enforce)
`fix-required`	❌ Commit blocked

Failure modes:

Scenario	Result
No prior review	❌ Error: "Run 'ccg review' first" (or set `CCG_REVIEW=off` to skip)
Diff changed since review	❌ Hash mismatch — re-run review
Bypass diff check	`CCG_COMMIT_FORCE=1 ccg commit ...`
Auto-stage disabled	`CCG_NO_AUTO_ADD=1 ccg commit ...` — caller must `git add` first
Review disabled	`CCG_REVIEW=off ccg commit ...` — skips state check entirely

Why no LLM in Stage 2?

The original design ran 2 parallel models here for adversarial robustness — but ccg review already does that (2 models + Claude synthesis). Repeating it on commit doubles cost and latency without adding signal. Reusing Stage 1's verdict is faster, cheaper, and equally safe.

Stage 3 — AI Merge (`ccg merge <target>`) ⭐ Core Competitive Advantage

Purpose: Resolve merge conflicts professionally and reliably.

Model strategy (3-tier fallback):

Bailian (primary) — Aliyun-hosted models (most reliable for code)
Claude (secondary) — direct Anthropic API
Codex + Gemini (tertiary) — parallel race
NEEDS_HUMAN_DECISION if all fail

Conflict classification (only content goes to AI):

Kind	Handling
`content`	AI resolution
`binary`	NEEDS HUMAN
`submodule`	NEEDS HUMAN
`symlink`	NEEDS HUMAN
`delete_modify`	NEEDS HUMAN
`both_deleted`	NEEDS HUMAN
`added_one_side`	NEEDS HUMAN
`both_added`	NEEDS HUMAN

Pipeline:

checkout target → backup branch → git merge --no-commit
  ↓ (for each conflict file)
  classify → parse <<<<<<< blocks
  → Bailian resolution
    ↓ (if failed)
    Codex + Gemini parallel
    ↓ (if both failed)
    NEEDS_HUMAN_DECISION
  → validate (no markdown fences, no conflict markers, non-empty)
  → atomic file rewrite (mktemp + mv, preserve permissions)
  → git add (if resolved)
  ↓
  commit (if all clean) | leave uncommitted (if any needs-human)

Safety guarantees:

Backup branch created BEFORE merge (ccg-backup/<target>-<timestamp>-<pid>-<rand>)
Aborts if working tree is dirty, detached HEAD, or mid-operation
Rejects diverged remote
Per-conflict nonce prevents OURS/THEIRS injection
Validates resolved content (no markdown fences, no conflict markers, non-empty)
Atomic file replacement (mktemp + mv)
Preserves file permissions and refuses to write through symlinks
Never silently drops code — fails to NEEDS_HUMAN
Real-time progress: [3/12] src/auth.js ... ✅ resolved
Limits max conflicts (default 50, override via CCG_MERGE_MAX_CONFLICTS)

Stage 4 — Pre-Push Analysis (`ccg push <remote> <branch>`)

Purpose: Show a comprehensive, graphical report before pushing — let user decide informed.

Model strategy: Bailian LLM for risk scoring (falls back to deterministic rules).

Report sections:

╔══════════════════════════════════════════════════════════╗
║          🚀  CCG Pre-Push Analysis Report  🚀            ║
╚══════════════════════════════════════════════════════════╝

  📍 Branch / Remote / HEAD / Author / Time

  ┌─ Commit Summary ─────────────────────────────────────┐
  │  Ahead: N commit(s) / Behind: M commit(s)
  └──────────────────────────────────────────────────────┘

  📝 Commits with quality markers (✓ conventional / ⚠ WIP)

  ┌─ Code Changes ───────────────────────────────────────┐
  │  Files / Lines added / Lines removed + visual bar
  └──────────────────────────────────────────────────────┘

  📂 File Categories: 💻 Code / 🧪 Tests / 📖 Docs / ⚙️ Config

  🚨 SENSITIVE FILES DETECTED (.env, *.pem, credentials, ...)

  ┌─ Risk Assessment ────────────────────────────────────┐
  │  Score: 🔴 CRITICAL (85) — auth + payment
  │  [████████████████████████████████████████████]
  └──────────────────────────────────────────────────────┘

  📊 Push Quality Scorecard:
     ✅ Conventional commit messages
     ✅ Code changes accompanied by tests
     ❌ Sensitive files in changeset
     ✅ Up to date with remote
     ⚠️  High risk score — review carefully

  ┌─ Recommendation ─────────────────────────────────────┐
  │  🔴 NOT RECOMMENDED (3/5 checks passed)
  └──────────────────────────────────────────────────────┘

  ┌─ Decision ───────────────────────────────────────────┐
  │  y — push   |   n — cancel   |   d — view diff   |   l — view log
  └──────────────────────────────────────────────────────┘

Quality checks:

Conventional commit messages (feat|fix|chore|...:)
Test files updated alongside code
No sensitive files (.env, *.pem, credentials, etc.)
Up to date with remote (not behind)
Risk level acceptable (<80)

One-Click Ship (`ccg ship [target] [msg]`)

Purpose: Combine review → commit → merge in a single command.

Pipeline:

ccg review — run full Stage 1 review
ccg commit — commit with review gate (only if verdict is merge)
ccg merge <target> — merge into target branch

Usage:

# Ship to main with auto-detected target
ccg ship

# Ship to specific branch
ccg ship main

# Ship with custom commit message
ccg ship main "feat: add user auth"

When to use: For rapid iteration when you want the full review-commit-merge pipeline in one command.

Model Strategy

Four Independent Providers

Provider	API Path	Required Env	Custom Endpoint
`codex`	Codex CLI (calls OpenAI)	`codex` binary	`CCG_CODEX_BASE_URL` / `OPENAI_BASE_URL`
`claude`	Direct Anthropic API	`ANTHROPIC_API_KEY` or `CLAUDE_API_KEY`	`CCG_CLAUDE_BASE_URL` / `ANTHROPIC_BASE_URL`
`gemini`	Gemini CLI (calls Google)	`gemini` binary + `GEMINI_API_KEY`	`CCG_GEMINI_BASE_URL` / `GEMINI_BASE_URL`
`bailian`	Direct Aliyun Bailian API	`BAILIAN_API_KEY`	`CCG_BAILIAN_BASE_URL`

Three Modes

CCG auto-selects mode based on risk score, or you can force it via CCG_MODE.

Risk Score	Auto Mode	Strategy
`< 30`	`cost`	Use cheap Bailian models everywhere
`30 – 70`	`balanced`	Mix of mid-tier models per provider
`> 70`	`quality`	Top-tier models per provider

Model Per Mode

Mode	codex	claude	gemini	bailian
`cost`	`gpt-5-mini`	`claude-haiku-4-5`	`gemini-2.5-flash-lite`	`qwen-3.5-haiku`
`balanced`	`gpt-5.4`	`claude-sonnet-4-6`	`gemini-2.5-flash`	`qwen-3.6`
`quality`	`gpt-5.5`	`claude-opus-4-7`	`gemini-3.5-flash`	`qwen-3.7`

Per-Stage Model Usage

Stage	Uses Models?	Which Models
Diff Capture	❌	Pure git ops
Risk Score	✅ Bailian LLM	Falls back to rule engine
Stage 1: Review	✅ any 2 slots in parallel	Default: codex + gemini. Same provider can run twice with different models (e.g., `bailian:qwen-3.7 bailian:deepseek-v4`)
Synthesize	✅ 1 model	Claude preferred (reserved meta-reviewer) → fallback: codex → bailian → gemini
Stage 2: Commit Gate	❌ NO LLM	Reuses Stage 1 synthesis verdict (zero extra cost)
Stage 3: Merge Conflicts	✅ 3-tier fallback	Bailian → Claude → Codex+Gemini
Stage 4: Push Check	✅ Bailian LLM	Risk scoring only

Available Bailian Models

Model	Tier	Input ¥/1M	Output ¥/1M	Notes
`qwen-3.7`	quality	0.30	0.90	Latest Qwen
`deepseek-v4`	quality	0.35	1.05	Top reasoning
`kimi-k2.6`	quality	0.32	0.96	Long context
`glm-5.1`	quality	0.28	0.84	Multimodal
`qwen-3.6`	balanced	0.25	0.75
`mimo-v2.5-pro`	balanced	0.22	0.66
`qwen-3.6-plus`	balanced	0.20	0.60
`qwen-3.5-sonnet`	balanced	0.15	0.45
`deepseek-v4-lite`	balanced	0.18	0.54
`kimi-k2.6-lite`	balanced	0.16	0.48
`glm-5.1-lite`	balanced	0.14	0.42
`mimo-v2.5`	cost	0.11	0.33
`qwen-3.5-haiku`	cost	0.05	0.15	Cheapest

Configuration

Environment Variables

Variable	Default	Description
Switches / Mode
`CCG_MODE`	auto	`cost` / `balanced` / `quality`
`CCG_REVIEW`	`on`	Master switch: `on` / `off` (when off, `ccg review` is a no-op and `ccg commit` skips state check)
`CCG_PROVIDERS`	auto (depends on mode)	Providers for Stage 1 (max 2 parallel). quality: codex+gemini, cost/balanced: bailian pair. Claude is reserved for Synthesis by default.
Provider models
`CCG_CODEX_MODEL`	by mode	Override Codex model
`CCG_CLAUDE_MODEL`	by mode	Override Claude model
`CCG_GEMINI_MODEL`	by mode	Override Gemini model
`CCG_BAILIAN_MODEL`	by mode	Override Bailian model
`CCG_DEEPSEEK_MODEL`	by mode	Override DeepSeek model
`CCG_KIMI_MODEL`	by mode	Override Kimi model
`CCG_GLM_MODEL`	by mode	Override GLM model
`CCG_MINIMAX_MODEL`	by mode	Override MiniMax model
`CCG_MIMO_MODEL`	by mode	Override Mimo model
API keys
`BAILIAN_API_KEY`	—	Bailian (Aliyun) API key
`ANTHROPIC_API_KEY` / `CLAUDE_API_KEY`	—	Anthropic API key
`GEMINI_API_KEY`	—	Google Gemini API key
`DEEPSEEK_API_KEY`	—	DeepSeek official API key
`KIMI_API_KEY`	—	Kimi (Moonshot) official API key
`GLM_API_KEY`	—	GLM (Zhipu) official API key
`MINIMAX_API_KEY`	—	MiniMax official API key
`MIMO_API_KEY`	—	Mimo official API key
Custom endpoints (proxies)
`CCG_CODEX_BASE_URL` / `OPENAI_BASE_URL`	OpenAI	Codex / OpenAI proxy URL
`CCG_CLAUDE_BASE_URL` / `ANTHROPIC_BASE_URL`	api.anthropic.com	Claude proxy URL
`CCG_GEMINI_BASE_URL` / `GEMINI_BASE_URL`	Google	Gemini proxy URL
`CCG_BAILIAN_BASE_URL`	dashscope.aliyuncs.com	Bailian proxy URL
`CCG_DEEPSEEK_BASE_URL`	api.deepseek.com/v1	DeepSeek official API URL
`CCG_KIMI_BASE_URL`	api.moonshot.cn/v1	Kimi official API URL
`CCG_GLM_BASE_URL`	open.bigmodel.cn/api/paas/v4	GLM official API URL
`CCG_MINIMAX_BASE_URL`	api.minimax.chat/v1	MiniMax official API URL
`CCG_MIMO_BASE_URL`	—	Mimo official API URL (required)
Timeouts / Parameters
`CCG_CODEX_TIMEOUT`	240	Codex timeout (seconds)
`CCG_GEMINI_TIMEOUT`	120	Gemini timeout (seconds)
`CCG_BAILIAN_TIMEOUT`	120	Bailian timeout (seconds)
`CCG_CLAUDE_TIMEOUT`	120	Claude timeout (seconds)
`CCG_DEEPSEEK_TIMEOUT`	120	DeepSeek timeout (seconds)
`CCG_KIMI_TIMEOUT`	120	Kimi timeout (seconds)
`CCG_GLM_TIMEOUT`	120	GLM timeout (seconds)
`CCG_MINIMAX_TIMEOUT`	120	MiniMax timeout (seconds)
`CCG_MIMO_TIMEOUT`	120	Mimo timeout (seconds)
`CCG_BAILIAN_TEMP`	0.7	Bailian temperature
`CCG_BAILIAN_MAX_TOKENS`	4096	Bailian max tokens
`CCG_BAILIAN_RETRIES`	3	Bailian retry count
`CCG_CLAUDE_RETRIES`	3	Claude retry count
Gate / Commit
`CCG_GATE_OFFLINE`	0	Set to 1 to skip Stage 2 review (legacy gate)
`CCG_GATE_DISCUSS`	allow	Set to `block` to block discuss verdict
`CCG_NO_AUTO_ADD`	0	Stage 2: skip auto `git add -A`, use only what's already staged
`CCG_COMMIT_FORCE`	0	Stage 2: bypass diff-hash check (force commit even if diff changed)
`CCG_AUTOCOMMIT_ALL`	0	Auto-commit all changes (including untracked)
`CCG_AUTOCOMMIT_DRY_RUN`	0	Dry run mode for autocommit
`CCG_DIFF_CACHED_ONLY`	0	Only use cached diff
Merge
`CCG_MERGE_DRY_RUN`	0	Stage 3: resolve but don't commit
`CCG_MERGE_NO_AI`	0	Stage 3: skip AI resolution
`CCG_MERGE_NO_FETCH`	0	Stage 3: skip remote fetch
`CCG_MERGE_MAX_CONFLICTS`	50	Stage 3: max conflict files
`CCG_MERGE_KEEP_BACKUP`	0	Stage 3: keep backup branch after success
Cache / Ledger / Reports
`CCG_NO_CACHE`	0	Disable prompt cache
`CCG_CACHE_TTL_HOURS`	24	Prompt cache TTL
`CCG_CACHE_DIR`	XDG default	Custom cache directory
`CCG_MAX_PROMPT_KB`	100	Max prompt size in KB
`CCG_USAGE_LOG`	XDG default	Custom usage log path
`CCG_LEDGER_LOG`	XDG default	Custom ledger log path
`CCG_LEDGER_MAX_LINES`	10000	Max ledger lines before rotation
`CCG_NO_HISTORY`	0	Disable review history injection
`CCG_HISTORY_MAX`	3	Max historical reviews to inject
`CCG_NO_REPORT`	0	Disable report persistence
`CCG_REPORT_DIR`	.ccg/reports	Custom report directory
`CCG_KEEP_ARTIFACTS`	0	Keep workdir for debugging
Other
`CCG_ALLOW_SAME_VENDOR`	0	Allow same vendor in Stage 1 slots
`CCG_SYNTH_PROVIDER`	auto	Override synthesizer provider
`CCG_RISK_LLM`	0	Enable LLM-based risk scoring

Usage Examples

# Force quality mode for a critical review
CCG_MODE=quality ccg review

# Use only Bailian (offline-friendly for China)
CCG_PROVIDERS="bailian" ccg review

# Mix providers — codex + claude (requires quality mode)
CCG_MODE=quality CCG_PROVIDERS="codex claude" ccg review

# Specific Bailian model
CCG_BAILIAN_MODEL=deepseek-v4 ccg review

# Use DeepSeek official API
DEEPSEEK_API_KEY="sk-xxx" CCG_PROVIDERS="deepseek" ccg review

# Use Kimi (Moonshot) official API
KIMI_API_KEY="sk-xxx" CCG_PROVIDERS="kimi" ccg review

# Use GLM (Zhipu) official API
GLM_API_KEY="xxx.xxx" CCG_PROVIDERS="glm" ccg review

# Use MiniMax official API
MINIMAX_API_KEY="xxx" CCG_PROVIDERS="minimax" ccg review

# Use Mimo official API (requires custom base URL)
MIMO_API_KEY="sk-xxx" CCG_MIMO_BASE_URL="https://api.mimo.com/v1" CCG_PROVIDERS="mimo" ccg review

# Mix independent providers (different vendors)
DEEPSEEK_API_KEY="sk-xxx" KIMI_API_KEY="sk-xxx" CCG_PROVIDERS="deepseek kimi" ccg review

# Use OpenAI through proxy (e.g., for China)
CCG_CODEX_BASE_URL="https://your-proxy.com/v1" ccg review

# Use Claude through proxy (e.g., third-party gateway)
CCG_CLAUDE_BASE_URL="https://tokensolo.com" ccg review

# Dry-run merge (resolve but don't commit)
CCG_MERGE_DRY_RUN=1 ccg merge main

# Skip AI merge resolution (just detect conflicts)
CCG_MERGE_NO_AI=1 ccg merge main

Architecture

ccg/
├── ccg                              # Entry point (4-line delegator)
├── ccg.sh                           # Core engine (~3000 lines)
│   ├── _ccg_xdg_* / _ccg_vcs_*     # XDG paths + git abstraction
│   ├── ccg_init / ccg_preflight    # Workdir setup
│   ├── ccg_diff_capture            # 4-level diff fallback
│   ├── ccg_risk_score              # Bailian LLM + rule engine
│   ├── ccg_codex / ccg_gemini      # Provider runners (with custom endpoint support)
│   ├── ccg_claude / _ccg_claude_retry  # Direct Anthropic API (with custom endpoint)
│   ├── _ccg_bailian_retry          # Bailian with retry/backoff
│   ├── ccg_synthesize              # AGREEMENT/DIVERGENCE/BLINDSPOT
│   ├── ccg_precommit_gate          # Stage 2 commit gate
│   └── ccg_merge                   # Stage 3 AI merge (Bailian → Claude → Codex+Gemini)
│       ├── _ccg_classify_conflict  # content/binary/submodule/...
│       ├── _ccg_parse_conflicts    # extract <<<<<<<>>>>>>> blocks
│       ├── _ccg_resolve_one_conflict  # 3-tier AI resolution
│       └── _ccg_apply_resolutions  # atomic file rewrite
├── ccg-bailian-models.sh           # 15-model Bailian registry
├── ccg-bailian-integration.sh      # Bailian API call helpers
├── ccg-multi-provider.sh           # 4-provider orchestration
├── ccg-workflow.sh                 # 4-stage workflow entry points
└── ccg.md                          # Claude Code slash command spec

docs/
├── README.zh-CN.md / .ja.md / .ko.md    # Translations
├── ARCHITECTURE.md (+ 3 translations)   # Deep architecture
└── CHANGELOG.md                         # Version history

Storage (XDG-compliant)

Path	Content
`$XDG_DATA_HOME/ccg/usage.log`	Token usage + cost log
`$XDG_DATA_HOME/ccg/ledger.jsonl`	Per-review JSONL ledger
`$XDG_CACHE_HOME/ccg/cache/`	Prompt hash → result cache (24h TTL)
`$XDG_CONFIG_HOME/ccg/`	User config

Legacy ~/.ccg/* auto-migrated on first run.

Documentation

Architecture deep-dive (中文 · 日本語 · 한국어)
Capabilities reference — full feature inventory grounded in the source (中文)
Changelog
Slash command spec — Claude Code /ccg command

License

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 38 Commits
bin		bin
docs		docs
scripts		scripts
tests		tests
.gitignore		.gitignore
.npmignore		.npmignore
LICENSE		LICENSE
README.md		README.md
a.txt		a.txt
asym_test.sh		asym_test.sh
ccg		ccg
ccg-bailian-integration.sh		ccg-bailian-integration.sh
ccg-bailian-models.sh		ccg-bailian-models.sh
ccg-multi-provider.sh		ccg-multi-provider.sh
ccg-workflow.sh		ccg-workflow.sh
ccg.md		ccg.md
ccg.sh		ccg.sh
package.json		package.json
test-bailian-full.sh		test-bailian-full.sh
test-bailian.sh		test-bailian.sh

Folders and files

Latest commit

History

Repository files navigation

CCG — Code Change Guardian

Table of Contents

Why CCG

Installation

npm 安装（推荐）

从源码安装

验证安装

Configuration

Method 1: Config File (Recommended)

Method 2: Environment Variables

Quick Start

Skip Review Mode

Complete Workflow

Default Flow (Review enabled)

Skip-Review Flow (CCG_REVIEW=off)

The 4 Stages

Stage 1 — Code Review (ccg review)

Stage 2 — Auto Commit (ccg commit)

Stage 3 — AI Merge (ccg merge <target>) ⭐ Core Competitive Advantage

Stage 4 — Pre-Push Analysis (ccg push <remote> <branch>)

One-Click Ship (ccg ship [target] [msg])

Model Strategy

Four Independent Providers

Three Modes

Model Per Mode

Per-Stage Model Usage

Available Bailian Models

Configuration

Environment Variables

Usage Examples

Architecture

Storage (XDG-compliant)

Documentation

License

About

Resources

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages

Skip-Review Flow (`CCG_REVIEW=off`)

Stage 1 — Code Review (`ccg review`)

Stage 2 — Auto Commit (`ccg commit`)

Stage 3 — AI Merge (`ccg merge <target>`) ⭐ Core Competitive Advantage

Stage 4 — Pre-Push Analysis (`ccg push <remote> <branch>`)

One-Click Ship (`ccg ship [target] [msg]`)