Building an AI Code Review CLI Tool in Rust: A Comprehensive Technical Guide

loop {
    match reader.read_event(&mut buf) {
        Ok(Event::Start(ref e)) => {
            match e.name().as_ref() {
                b"rule" => {
                    let rule = parse_rule_element(&mut reader, e)?;
                    rules.push(rule);
                }
                _ => {}
            }
        }
        Ok(Event::Eof) => break,
        Err(e) => return Err(Error::XmlParse(e)),
        _ => {}
    }
    buf.clear();
}

Ok(rules)

**XSD schema validation presents challenges in Rust's ecosystem.** Native XSD support is limited, requiring either libxml2 bindings for full compliance or custom validation logic using quick-xml for domain-specific rules. [Rust Programming Language +2](https://users.rust-lang.org/t/xml-xsd-validation-and-xsl-transform/30393?ReviewRule) -> Result<(), ValidationError> {
    // Validate required fields
    if rule.id.is_empty() {
        return Err(ValidationError::MissingField("id".to_string()));
    }
    
    // Validate rule patterns
    if rule.pattern.is_empty() {
        return Err(ValidationError::MissingField("pattern".to_string()));
    }
    
    // Validate severity levels
    if !["error", "warning", "info"].contains(&rule.severity.as_str()) {
        return Err(ValidationError::InvalidSeverity(rule.severity.clone()));
    }
    
    Ok(())
}

pub fn analyze_staged_changes(&self) -> Result<Vec<FileChange>, git2::Error> {
    let mut opts = DiffOptions::new();
    let diff = self.repo.diff_index_to_workdir(None, Some(&mut opts))?;
    
    let mut changes = Vec::new();
    
    diff.foreach(
        &mut |delta, _progress| {
            if let Some(path) = delta.new_file().path() {
                changes.push(FileChange::new(path.to_path_buf()));
            }
            true
        },
        None,
        None,
        Some(&mut |_delta, _hunk, line| {
            // Process line-by-line changes
            true
        })
    )?;
    
    Ok(changes)
}

The git2 library excels at reading diffs, parsing commit information, and handling repository operations. [GitHub](https://github.com/rust-lang/git2-rs?self, owner: &str, repo: &str, pr_number: u64, body: &str) -> Result<(), octocrab::Error> {
        self.github_client
            .issues(owner, repo)
            .create_comment(pr_number, body)
            .await?;
        Ok(())
    }
}

    if self.tokens == 0 {
        sleep(self.refill_rate).await;
        self.refill_tokens();
    }
    
    if self.tokens > 0 {
        self.tokens -= 1;
        Ok(())
    } else {
        Err("Rate limit exceeded".into())
    }
}

## Testing Strategy and CI/CD Integration

**CLI testing relies on assert_cmd for comprehensive end-to-end validation.** This library provides `Command::cargo_bin()` for running binaries in tests, supporting output assertions, exit code validation, and error handling scenarios. [Ubuntu Ask +2](https://ubuntuask.com/blog/how-to-test-cli-arguments-with-clap-in-rust?rules_file, r#"
        <rules>
            <rule id="syntax-check" severity="error">
                <pattern>TODO</pattern>
                <message>Remove TODO comments</message>
            </rule>
        </rules>
    "#)?;
    
    let mut cmd = Command::cargo_bin("ai-review")?;
    cmd.arg("review")
       .arg("--rules")
       .arg(&rules_file)
       .arg(".")
       .assert()
       .success()
       .stdout(predicate::str::contains("Analysis complete"));
    
    Ok(())
}

Ok(())

**Logging architecture uses tracing for structured, async-aware logging.** This provides span-based context tracking essential for debugging complex CLI operations: [Rust +2](https://docs.rs/tracing?str, rules: Option<&str>, format: Option<&str>) -> Result<()> {
    info!(path = %path, "Starting repository analysis");
    
    let rules = load_rules(rules).await
        .with_context(|| "Failed to load analysis rules")?;
    
    let git_analyzer = GitAnalyzer::new(Path::new(path))
        .with_context(|| "Failed to initialize Git analyzer")?;
    
    let changes = git_analyzer.analyze_staged_changes()
        .with_context(|| "Failed to analyze Git changes")?;
    
    info!(change_count = changes.len(), "Analyzed repository changes");
    
    Ok(())
}

    let prompt = self.build_analysis_prompt(code, rules);
    
    let mut child = TokioCommand::new("gemini")
        .arg("--model")
        .arg("gemini-pro")
        .arg("--prompt")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()?;
    
    if let Some(stdin) = child.stdin.take() {
        tokio::io::AsyncWriteExt::write_all(&mut stdin, prompt.as_bytes()).await?;
    }
    
    let output = child.wait_with_output().await?;
    
    if output.status.success() {
        let result = String::from_utf8_lossy(&output.stdout);
        self.parse_gemini_response(&result)
    } else {
        Err(format!("Gemini CLI failed: {}", String::from_utf8_lossy(&output.stderr)).into())
    }
}

**reviewdog integration follows structured output formats** for seamless integration with existing code review workflows: [GitHub +2](https://github.com/reviewdog/reviewdog?[Finding]) -> Result<String, serde_json::Error> {
    let results: Vec<ReviewdogResult> = findings.iter().map(|finding| {
        ReviewdogResult {
            message: finding.message.clone(),
            location: ReviewdogLocation {
                path: finding.file_path.clone(),
                range: ReviewdogRange {
                    start: ReviewdogPosition {
                        line: finding.line,
                        column: finding.column,
                    },
                    end: ReviewdogPosition {
                        line: finding.line,
                        column: finding.column + finding.length,
                    },
                },
            },
            severity: finding.severity.clone(),
        }
    }).collect();
    
    serde_json::to_string_pretty(&results)
}

use figment::{Figment, providers::{Format, Toml, Env}};
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]
pub struct Config {
    pub ai: AiConfig,
    pub github: GitHubConfig,
    pub output: OutputConfig,
}

impl Config {
    pub fn load() -> Result<Self, figment::Error> {
        Figment::new()
            .merge(Toml::file("ai-review.toml"))
            .merge(Env::prefixed("AI_REVIEW_"))
            .extract()
    }
}