Pre-Merge Check Automation and Integration Patterns in the code-review-graph Repository

The code-review-graph repository ships a built-in pre-merge check workflow that combines a lightweight graph snapshot with an LLM prompt to block risky pull requests before they reach main.

The tirth8205/code-review-graph project implements pre-merge check automation and integration patterns as a first-class concern, exposing both a Python API and a CLI entry point so teams can embed context-aware analysis into Git hooks, CI pipelines, or review bots. Every stage of the workflow is grounded in concrete source files that handle context collection, prompt templating, and execution.

How Pre-Merge Check Automation Works

The pre-merge workflow follows a deterministic pipeline implemented across code_review_graph/prompts.py, code_review_graph/eval/token_benchmark.py, and the CLI entry point. Each stage is designed to fail fast and keep execution under a few hundred milliseconds for medium-sized repositories.

1. Collect Minimal Context – The get_minimal_context(task="pre-merge check") function in code_review_graph/prompts.py (lines 144–150) traverses the repository graph and prunes it to changed files, dependency neighbors, recent reviewers, and metadata such as last commit and test coverage.

2. Render the Prompt – The gathered context is interpolated into the pre-merge MCP template defined in the same file. The template instructs the LLM to verify compilation or type-checking status, flag missing test coverage, detect hard-coded secrets, and summarize risky dependency upgrades.

3. Run the LLM Evaluation – The prompt is dispatched to the configured provider, and the response is parsed into a structured PreMergeReport. The simulation in code_review_graph/eval/token_benchmark.py (lines 135–148) demonstrates this end-to-end invocation.

4. Fail-Fast Decision – If the report contains blockers such as compilation errors or failing security checks, the CLI returns a non-zero exit code that aborts the merge. When the check passes, it emits a concise "All clear" summary with optional improvement suggestions.

5. Human-Readable Summary – The output is formatted for immediate consumption by developers or downstream CI logs, ensuring the reason for a blocked merge is transparent.

Core Components and Source Files

• get_minimal_context(task="pre-merge check") in code_review_graph/prompts.py (lines 144–150): Retrieves the lightweight graph snapshot that serves as prompt context, keeping PR analysis fast enough for local hooks.
• token_benchmark.py in code_review_graph/eval/token_benchmark.py (lines 135–148): Provides a runnable simulation of the full pre-merge check, useful for debugging context size and LLM latency.
• test_prompts.py in tests/test_prompts.py (lines 147–149): Unit tests that enforce correct pre-merge terminology and guarantee the generated prompt remains well-formed after code changes.
• CLI entry point crg in code_review_graph/cli.py: Exposes the crg pre-merge sub-command that wires the Python API into shell-based automation.
• Git hook sample in .git/hooks/pre-merge-commit.sample: A ready-to-adapt shell script showing how to invoke the CLI inside a local Git workflow.

Integration Patterns for Pre-Merge Checks

The repository supports four primary integration patterns that all consume the same core API, eliminating configuration drift between local and remote environments.

Git Hook Enforcement

Rename the sample hook to pre-merge-commit and make it executable. The script calls crg pre-merge $BASE $HEAD and aborts the merge if the exit code is non-zero. This pattern catches issues before they leave a developer's machine.

CI/CD Pipeline Stage

Add a job step that executes crg pre-merge --base ${{ github.base_ref }} --head ${{ github.head_ref }}. Because the CLI exits with an error code on blockers, the pipeline fails automatically without custom parsing logic.

On-Demand Review Bot

A PR comment bot can import get_minimal_context directly from code_review_graph.prompts, build the context for the current branch, and post the PreMergeReport summary back to the pull request thread. This pattern is useful for optional advisory checks rather than hard gates.

Batch Re-Scanning

Schedule a cron job that iterates over open pull requests and re-runs crg pre-merge against stale branches. The shared API ensures that batch results are identical to those produced by interactive or CI-triggered runs.

Practical Code Examples

Call the Python API Directly

from code_review_graph.prompts import get_minimal_context

# Build the context for a PR that merges `feature-xyz` into `main`

context = get_minimal_context(
    task="pre-merge check",
    repo_root=".",          # path to the repository root

    base="main",
    head="feature-xyz"
)

# `context` is a dict that can be fed to the LLM or inspected directly

print(context["summary"])

Wire the Check into a Git Hook

#!/usr/bin/env bash

# .git/hooks/pre-merge-commit (make executable)

BASE=$(git rev-parse "$1")
HEAD=$(git rev-parse "$2")

# Execute the pre‑merge check; abort if it fails

crg pre-merge --base "$BASE" --head "$HEAD"
if [ $? -ne 0 ]; then
    echo "Pre‑merge check failed – aborting merge."
    exit 1
fi

Add a GitHub Actions Job

name: Pre‑Merge Validation
on:
  pull_request:
    types: [opened, synchronize, reopened]

jobs:
  pre-merge:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install crg
        run: pip install code-review-graph
      - name: Run pre‑merge check
        run: |
          crg pre-merge \
            --base ${{ github.base_ref }} \
            --head ${{ github.head_ref }}

Summary

• The pre-merge check in tirth8205/code-review-graph combines a lightweight graph context builder with an LLM prompt to evaluate pull requests before they merge.
• The workflow is anchored by get_minimal_context in code_review_graph/prompts.py and demonstrated in code_review_graph/eval/token_benchmark.py.
• Every integration pattern—whether a local Git hook, a CI/CD stage, a review bot, or a batch job—uses the same CLI or Python API, guaranteeing consistent behavior.
• Running the check requires only crg pre-merge --base <ref> --head <ref>, making it trivial to adopt in existing DevOps pipelines.

Frequently Asked Questions

What file implements the pre-merge context collection?

The get_minimal_context function in code_review_graph/prompts.py (lines 144–150) implements context collection. It walks the repository graph, isolates changed nodes, and decorates them with metadata so the LLM prompt stays small and fast.

How does the pre-merge check fail a merge?

The CLI entry point crg pre-merge returns a non-zero exit code whenever the generated PreMergeReport contains blockers such as compilation errors or security violations. Git hooks and CI pipelines can treat this as a standard shell failure and abort the merge automatically.

Can I run the pre-merge check outside of Git hooks or CI?

Yes. You can import get_minimal_context from code_review_graph.prompts inside any Python script or bot. This lets you generate a pre-merge report on demand, post it as a PR comment, or integrate it into custom review workflows without invoking the CLI.

Where is the pre-merge behavior tested?

The tests/test_prompts.py file (lines 147–149) contains unit tests that verify the pre-merge prompt includes the correct terminology and that the template renders correctly. Additionally, code_review_graph/eval/token_benchmark.py provides an end-to-end simulation for manual validation and performance tuning.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}