xfire-security-review（xfire 安全审查）

xfire — Multi-Agent Adversarial Security Review

Multiple agents. One verdict. Zero blind spots.

xfire sends your code to 3 AI agents (Claude, Codex, Gemini) independently, then runs an adversarial debate where they cross-examine each other's findings. Only vulnerabilities that survive prosecution, defense, and a judge's ruling make the final report.

When to Use

Invoke xfire when a user asks for any of these:

• "security review this PR"
• "find vulnerabilities in this code"
• "audit this repo for security issues"
• "run a security scan"
• "analyze this diff for security problems"
• "check this pull request for vulnerabilities"
• "code review for security"
• "pentest this codebase"
• "threat model this change"

Do NOT use xfire for:

• General code quality / style reviews (use a linter)
• Performance profiling
• Dependency license auditing
• Non-security functional testing

Prerequisites

• Python 3.11+
• Install: pip install xfire
• At least one AI agent CLI or API key configured:

Setup

# Initialize config in current repo
xfire init

# Test agent connectivity
xfire test-llm

# Set up agent credentials
xfire auth login --provider claude
xfire auth login --provider codex
xfire auth login --provider gemini

Commands

Core Analysis

analyze-pr — Analyze a GitHub pull request

xfire analyze-pr --repo owner/repo --pr 123

analyze-diff — Analyze a local diff or staged changes

xfire analyze-diff --staged --repo-dir .
xfire analyze-diff --patch changes.patch --repo-dir .
xfire analyze-diff --commit f1877d3 --repo-dir /path/to/repo
xfire analyze-diff --base main --head feature-branch
xfire analyze-diff --commit f1877d3 --thinking --repo-dir /path/to/repo

code-review — Full codebase security audit

xfire code-review /path/to/repo

scan — Baseline-aware incremental scan

xfire scan . --base main --head feature-branch
xfire scan . --since-last-scan
xfire scan . --last 5
xfire scan . --range abc123~1..abc123
xfire scan . --since 2026-01-01
xfire scan . --diff changes.patch

baseline — Build persistent repo baseline context

xfire baseline /path/to/repo
xfire baseline . --force

Output

report — Re-generate a report from saved JSON results

xfire report --input xfire-results.json --format sarif

debates — Replay adversarial debate transcripts

xfire debates --input xfire-results.json

Setup & Diagnostics

init — Initialize xfire configuration

xfire init

Creates .xfire/config.yaml in the current directory. No flags.

config-check — Validate configuration

xfire config-check --repo-dir .

test-llm — Test agent connectivity

xfire test-llm
xfire test-llm --agents claude --mode api
xfire test-llm --thinking --prompt "What is 2+2?"

auth login — Set up agent credentials

xfire auth login --provider claude
xfire auth login --provider codex
xfire auth login --provider gemini

auth status — Show credential status

xfire auth status

No flags. Displays a table of all provider credential statuses.

Demo

demo — Run fixture or UI demo scenarios

xfire demo --ui
xfire demo --ui --scenario both_accept
xfire demo --fixture auth_bypass_regression

Configuration

xfire looks for .xfire/config.yaml in the repo root (override with XFIRE_CONFIG_PATH).

Priority: CLI flags > environment variables > config.yaml > defaults.

repo:
  purpose: ""                          # describe what your app does
  intended_capabilities: []            # expected capabilities
  sensitive_paths:                     # paths that get extra scrutiny
    - auth/
    - payments/
    - migrations/

analysis:
  context_depth: deep                  # shallow | medium | deep
  max_related_files: 20
  include_test_files: true

agents:
  claude:
    enabled: true
    mode: cli                          # cli | api
    cli_command: claude
    model: claude-sonnet-4-20250514
    api_key_env: ANTHROPIC_API_KEY
    timeout: 600
  codex:
    enabled: true
    mode: cli
    cli_command: codex
    model: o3-mini
    api_key_env: OPENAI_API_KEY
    timeout: 300
  gemini:
    enabled: true
    mode: cli
    cli_command: gemini
    model: gemini-2.5-pro
    api_key_env: GOOGLE_API_KEY
    timeout: 300

  debate:
    role_assignment: evidence          # evidence | rotate | fixed
    fixed_roles:
      prosecutor: claude
      defense: codex
      judge: gemini
    defense_preference: [codex, claude, gemini]
    judge_preference: [codex, gemini, claude]
    max_rounds: 2
    require_evidence_citations: true
    min_agents_for_debate: 2

  skills:
    code_navigation: true
    data_flow_tracing: true
    git_archeology: true
    config_analysis: true
    dependency_analysis: true
    test_coverage_check: true

severity_gate:
  fail_on: high                        # minimum severity to fail CI
  min_confidence: 0.7
  require_debate: true

suppressions: []

fast_model:
  provider: claude
  model: claude-haiku-4-5-20251001
  api_key_env: ANTHROPIC_API_KEY
  cli_command: claude
  cli_args: [--output-format, json]
  timeout: 60

Output Formats

CI/CD Integration

GitHub Actions

name: xfire Security Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  security-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - run: pip install xfire

      - name: Run xfire security review
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          GOOGLE_API_KEY: ${{ secrets.GOOGLE_API_KEY }}
        run: |
          xfire analyze-pr \
            --repo ${{ github.repository }} \
            --pr ${{ github.event.pull_request.number }} \
            --format sarif \
            --output results.sarif \
            --silent

      - name: Upload SARIF
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: results.sarif

How It Works

1. Context Building — parses the diff/PR/repo and collects related files, git history, configs, and dependency data
2. Intent Inference — uses a fast model (Haiku) to understand the repo's purpose, trust boundaries, and security controls
3. Independent Review — sends the context to each enabled agent (Claude, Codex, Gemini) in parallel
4. Finding Extraction — normalizes all agent responses into structured findings with severity, confidence, and CWE tags
5. Adversarial Debate — each finding goes through a prosecution → defense → judge pipeline where agents argue for/against its validity
6. Verdict & Deduplication — the judge issues a final ruling; findings are deduplicated and merged across agents
7. Report Generation — produces the final report in markdown, JSON, or SARIF format with severity gating for CI

Environment Variables

Limitations

• Requires at least one AI agent (Claude, Codex, or Gemini) to be configured and reachable
• CLI mode requires the agent CLI tools to be installed and on PATH
• Does not replace manual penetration testing or formal security audits
• Findings depend on AI model capabilities and may include false positives or miss subtle vulnerabilities
• Large repositories may hit agent context limits; use --max-files to constrain scope
• Does not scan binary files, compiled artifacts, or container images
• Debate quality improves with more agents — single-agent mode skips the adversarial phase