oven_cli/agents/

mod.rs

pub mod fixer;
pub mod implementer;
pub mod planner;
pub mod reviewer;

use std::path::PathBuf;

use anyhow::Result;
use serde::{Deserialize, de::DeserializeOwned};

use crate::{db::ReviewFinding, process::CommandRunner};

/// The four agent roles in the pipeline.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum AgentRole {
    Planner,
    Implementer,
    Reviewer,
    Fixer,
}

impl AgentRole {
    pub const fn allowed_tools(&self) -> &[&str] {
        match self {
            Self::Planner | Self::Reviewer => &["Read", "Glob", "Grep"],
            Self::Implementer | Self::Fixer => &["Read", "Write", "Edit", "Glob", "Grep", "Bash"],
        }
    }

    pub const fn as_str(&self) -> &str {
        match self {
            Self::Planner => "planner",
            Self::Implementer => "implementer",
            Self::Reviewer => "reviewer",
            Self::Fixer => "fixer",
        }
    }

    pub fn tools_as_strings(&self) -> Vec<String> {
        self.allowed_tools().iter().map(|s| (*s).to_string()).collect()
    }
}

impl std::fmt::Display for AgentRole {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl std::str::FromStr for AgentRole {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "planner" => Ok(Self::Planner),
            "implementer" => Ok(Self::Implementer),
            "reviewer" => Ok(Self::Reviewer),
            "fixer" => Ok(Self::Fixer),
            other => anyhow::bail!("unknown agent role: {other}"),
        }
    }
}

/// Context passed to agent prompt builders.
#[derive(Debug, Clone)]
pub struct AgentContext {
    pub issue_number: u32,
    pub issue_title: String,
    pub issue_body: String,
    pub branch: String,
    pub pr_number: Option<u32>,
    pub test_command: Option<String>,
    pub lint_command: Option<String>,
    pub review_findings: Option<Vec<ReviewFinding>>,
    pub cycle: u32,
    /// When set, indicates this is a multi-repo pipeline where the PR lives in a
    /// different repo than the issue.
    pub target_repo: Option<String>,
    /// Issue source: "github" or "local".
    pub issue_source: String,
    /// The default branch name (e.g. "main" or "master").
    pub base_branch: String,
}

/// An invocation ready to be sent to the process runner.
pub struct AgentInvocation {
    pub role: AgentRole,
    pub prompt: String,
    pub working_dir: PathBuf,
    pub max_turns: Option<u32>,
    pub model: Option<String>,
}

/// Invoke an agent via the command runner.
pub async fn invoke_agent<R: CommandRunner>(
    runner: &R,
    invocation: &AgentInvocation,
) -> Result<crate::process::AgentResult> {
    runner
        .run_claude(
            &invocation.prompt,
            &invocation.role.tools_as_strings(),
            &invocation.working_dir,
            invocation.max_turns,
            invocation.model.clone(),
        )
        .await
}

/// Complexity classification from the planner agent.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Complexity {
    Simple,
    Full,
}

impl std::fmt::Display for Complexity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(match self {
            Self::Simple => "simple",
            Self::Full => "full",
        })
    }
}

impl std::str::FromStr for Complexity {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "simple" => Ok(Self::Simple),
            "full" => Ok(Self::Full),
            other => anyhow::bail!("unknown complexity: {other}"),
        }
    }
}

/// Structured output from the planner agent (legacy batch format).
#[derive(Debug, Deserialize)]
pub struct PlannerOutput {
    pub batches: Vec<Batch>,
    #[serde(default)]
    pub total_issues: u32,
    #[serde(default)]
    pub parallel_capacity: u32,
}

#[derive(Debug, Deserialize)]
pub struct Batch {
    pub batch: u32,
    pub issues: Vec<PlannedIssue>,
    #[serde(default)]
    pub reasoning: String,
}

#[derive(Debug, Deserialize)]
pub struct PlannedIssue {
    pub number: u32,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub area: String,
    #[serde(default)]
    pub predicted_files: Vec<String>,
    #[serde(default)]
    pub has_migration: bool,
    #[serde(default = "default_full")]
    pub complexity: Complexity,
}

const fn default_full() -> Complexity {
    Complexity::Full
}

/// Structured output from the planner agent (DAG format with explicit dependencies).
#[derive(Debug, Deserialize)]
pub struct PlannerGraphOutput {
    pub nodes: Vec<PlannedNode>,
    #[serde(default)]
    pub total_issues: u32,
    #[serde(default)]
    pub parallel_capacity: u32,
}

/// A single issue node in the planner's DAG output.
#[derive(Debug, Deserialize)]
pub struct PlannedNode {
    pub number: u32,
    #[serde(default)]
    pub title: String,
    #[serde(default)]
    pub area: String,
    #[serde(default)]
    pub predicted_files: Vec<String>,
    #[serde(default)]
    pub has_migration: bool,
    #[serde(default = "default_full")]
    pub complexity: Complexity,
    #[serde(default)]
    pub depends_on: Vec<u32>,
    #[serde(default)]
    pub reasoning: String,
}

/// Context passed to the planner about existing graph state.
#[derive(Debug, Clone)]
pub struct GraphContextNode {
    pub number: u32,
    pub title: String,
    pub state: crate::db::graph::NodeState,
    pub area: String,
    pub predicted_files: Vec<String>,
    pub has_migration: bool,
    pub depends_on: Vec<u32>,
    pub target_repo: Option<String>,
}

/// Parse structured planner output from the planner's text response.
///
/// Tries the new DAG format first, falls back to the legacy batch format
/// (converting batches into dependency edges).
pub fn parse_planner_output(text: &str) -> Option<PlannerOutput> {
    extract_json(text)
}

/// Parse planner output as a DAG. Tries the new format first, converts
/// legacy batch format into equivalent DAG nodes if needed.
pub fn parse_planner_graph_output(text: &str) -> Option<PlannerGraphOutput> {
    // Try new DAG format first
    if let Some(output) = extract_json::<PlannerGraphOutput>(text) {
        return Some(output);
    }

    // Fall back to legacy batch format and convert
    let legacy: PlannerOutput = extract_json(text)?;
    Some(batches_to_graph_output(&legacy))
}

/// Convert a legacy batch-based planner output into a DAG output.
///
/// Issues in batch N+1 depend on all issues in batches 1..N (cumulative).
fn batches_to_graph_output(legacy: &PlannerOutput) -> PlannerGraphOutput {
    let mut nodes = Vec::new();
    let mut prior_batch_issues: Vec<u32> = Vec::new();

    for batch in &legacy.batches {
        let depends_on = prior_batch_issues.clone();
        for pi in &batch.issues {
            nodes.push(PlannedNode {
                number: pi.number,
                title: pi.title.clone(),
                area: pi.area.clone(),
                predicted_files: pi.predicted_files.clone(),
                has_migration: pi.has_migration,
                complexity: pi.complexity.clone(),
                depends_on: depends_on.clone(),
                reasoning: batch.reasoning.clone(),
            });
        }
        prior_batch_issues.extend(batch.issues.iter().map(|pi| pi.number));
    }

    PlannerGraphOutput {
        total_issues: legacy.total_issues,
        parallel_capacity: legacy.parallel_capacity,
        nodes,
    }
}

/// Structured output from the reviewer agent.
#[derive(Debug, Deserialize)]
pub struct ReviewOutput {
    pub findings: Vec<Finding>,
    #[serde(default)]
    pub summary: String,
}

#[derive(Debug, Deserialize)]
pub struct Finding {
    pub severity: Severity,
    pub category: String,
    #[serde(default)]
    pub file_path: Option<String>,
    #[serde(default)]
    pub line_number: Option<u32>,
    pub message: String,
}

#[derive(Debug, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Severity {
    Critical,
    Warning,
    Info,
}

impl Severity {
    pub const fn as_str(&self) -> &str {
        match self {
            Self::Critical => "critical",
            Self::Warning => "warning",
            Self::Info => "info",
        }
    }
}

impl std::fmt::Display for Severity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Structured output from the fixer agent.
#[derive(Debug, Deserialize, Default)]
pub struct FixerOutput {
    #[serde(default)]
    pub addressed: Vec<FixerAction>,
    #[serde(default)]
    pub disputed: Vec<FixerDispute>,
}

#[derive(Debug, Deserialize)]
pub struct FixerAction {
    /// 1-indexed finding number from the fixer prompt's `<review_findings>` list.
    pub finding: u32,
    pub action: String,
}

#[derive(Debug, Deserialize)]
pub struct FixerDispute {
    /// 1-indexed finding number from the fixer prompt's `<review_findings>` list.
    pub finding: u32,
    pub reason: String,
}

/// Parse structured fixer output from the fixer's text response.
///
/// Returns a default (empty) `FixerOutput` if parsing fails. We don't want
/// a fixer parse failure to block the pipeline, and this preserves backward
/// compatibility with fixers that produce prose-only output.
pub fn parse_fixer_output(text: &str) -> FixerOutput {
    extract_json::<FixerOutput>(text).unwrap_or_default()
}

/// Parse structured review output from the reviewer's text response.
///
/// The JSON may be wrapped in markdown code fences. If the output is
/// unparseable, returns a single warning finding instead of failing the
/// pipeline. This ensures unreviewed code never silently passes through
/// while still keeping the pipeline alive for human follow-up.
pub fn parse_review_output(text: &str) -> ReviewOutput {
    extract_json(text).unwrap_or_else(|| {
        tracing::warn!("reviewer returned unparseable output, emitting warning finding");
        ReviewOutput {
            findings: vec![Finding {
                severity: Severity::Warning,
                category: "review-parse".to_string(),
                file_path: None,
                line_number: None,
                message: "reviewer output was unparseable -- manual review recommended".to_string(),
            }],
            summary: "review output unparseable, manual review recommended".to_string(),
        }
    })
}

/// Try to extract a JSON object of type `T` from text that may contain prose,
/// code fences, or raw JSON.
///
/// Attempts three strategies in order:
/// 1. Direct `serde_json::from_str`
/// 2. JSON inside markdown code fences
/// 3. First `{` to last `}` in the text
fn extract_json<T: DeserializeOwned>(text: &str) -> Option<T> {
    if let Ok(val) = serde_json::from_str::<T>(text) {
        return Some(val);
    }

    if let Some(json_str) = extract_json_from_fences(text) {
        if let Ok(val) = serde_json::from_str::<T>(json_str) {
            return Some(val);
        }
    }

    let start = text.find('{')?;
    let end = text.rfind('}')?;
    if end > start { serde_json::from_str::<T>(&text[start..=end]).ok() } else { None }
}

fn extract_json_from_fences(text: &str) -> Option<&str> {
    let start_markers = ["```json\n", "```json\r\n", "```\n", "```\r\n"];
    for marker in &start_markers {
        if let Some(start) = text.find(marker) {
            let content_start = start + marker.len();
            if let Some(end) = text[content_start..].find("```") {
                return Some(&text[content_start..content_start + end]);
            }
        }
    }
    None
}

#[cfg(test)]
mod tests {
    use proptest::prelude::*;

    use super::*;

    const ALL_ROLES: [AgentRole; 4] =
        [AgentRole::Planner, AgentRole::Implementer, AgentRole::Reviewer, AgentRole::Fixer];

    proptest! {
        #[test]
        fn agent_role_display_fromstr_roundtrip(idx in 0..4usize) {
            let role = ALL_ROLES[idx];
            let s = role.to_string();
            let parsed: AgentRole = s.parse().unwrap();
            assert_eq!(role, parsed);
        }

        #[test]
        fn arbitrary_strings_never_panic_on_role_parse(s in "\\PC{1,50}") {
            let _ = s.parse::<AgentRole>();
        }

        #[test]
        fn parse_review_output_never_panics(text in "\\PC{0,500}") {
            // parse_review_output should never panic on any input and always
            // returns a valid ReviewOutput (either parsed or warning fallback)
            let _ = parse_review_output(&text);
        }

        #[test]
        fn parse_fixer_output_never_panics(text in "\\PC{0,500}") {
            let _ = parse_fixer_output(&text);
        }

        #[test]
        fn valid_review_json_always_parses(
            severity in prop_oneof!["critical", "warning", "info"],
            category in "[a-z]{3,15}",
            message in "[a-zA-Z0-9 ]{1,50}",
        ) {
            let json = format!(
                r#"{{"findings":[{{"severity":"{severity}","category":"{category}","message":"{message}"}}],"summary":"test"}}"#
            );
            let output = parse_review_output(&json);
            assert_eq!(output.findings.len(), 1);
            assert_eq!(output.findings[0].category, category);
        }

        #[test]
        fn review_json_in_fences_parses(
            severity in prop_oneof!["critical", "warning", "info"],
            category in "[a-z]{3,15}",
            message in "[a-zA-Z0-9 ]{1,50}",
            prefix in "[a-zA-Z ]{0,30}",
            suffix in "[a-zA-Z ]{0,30}",
        ) {
            let json = format!(
                r#"{{"findings":[{{"severity":"{severity}","category":"{category}","message":"{message}"}}],"summary":"ok"}}"#
            );
            let text = format!("{prefix}\n```json\n{json}\n```\n{suffix}");
            let output = parse_review_output(&text);
            assert_eq!(output.findings.len(), 1);
        }
    }

    #[test]
    fn tool_scoping_per_role() {
        assert_eq!(AgentRole::Planner.allowed_tools(), &["Read", "Glob", "Grep"]);
        assert_eq!(
            AgentRole::Implementer.allowed_tools(),
            &["Read", "Write", "Edit", "Glob", "Grep", "Bash"]
        );
        assert_eq!(AgentRole::Reviewer.allowed_tools(), &["Read", "Glob", "Grep"]);
        assert_eq!(
            AgentRole::Fixer.allowed_tools(),
            &["Read", "Write", "Edit", "Glob", "Grep", "Bash"]
        );
    }

    #[test]
    fn role_display_roundtrip() {
        let roles =
            [AgentRole::Planner, AgentRole::Implementer, AgentRole::Reviewer, AgentRole::Fixer];
        for role in roles {
            let s = role.to_string();
            let parsed: AgentRole = s.parse().unwrap();
            assert_eq!(role, parsed);
        }
    }

    #[test]
    fn parse_review_output_valid_json() {
        let json = r#"{"findings":[{"severity":"critical","category":"bug","file_path":"src/main.rs","line_number":10,"message":"null pointer"}],"summary":"one issue found"}"#;
        let output = parse_review_output(json);
        assert_eq!(output.findings.len(), 1);
        assert_eq!(output.findings[0].severity, Severity::Critical);
        assert_eq!(output.findings[0].message, "null pointer");
        assert_eq!(output.summary, "one issue found");
    }

    #[test]
    fn parse_review_output_in_code_fences() {
        let text = r#"Here are my findings:

```json
{"findings":[{"severity":"warning","category":"style","message":"missing docs"}],"summary":"ok"}
```

That's it."#;
        let output = parse_review_output(text);
        assert_eq!(output.findings.len(), 1);
        assert_eq!(output.findings[0].severity, Severity::Warning);
    }

    #[test]
    fn parse_review_output_embedded_json() {
        let text = r#"I reviewed the code and found: {"findings":[{"severity":"info","category":"note","message":"looks fine"}],"summary":"clean"} end of review"#;
        let output = parse_review_output(text);
        assert_eq!(output.findings.len(), 1);
    }

    #[test]
    fn parse_review_output_no_json_returns_warning() {
        let text = "The code looks great, no issues found.";
        let output = parse_review_output(text);
        assert_eq!(output.findings.len(), 1);
        assert_eq!(output.findings[0].severity, Severity::Warning);
        assert_eq!(output.findings[0].category, "review-parse");
        assert!(output.summary.contains("unparseable"));
    }

    #[test]
    fn parse_review_output_malformed_json_returns_warning() {
        let text = r#"{"findings": [{"broken json"#;
        let output = parse_review_output(text);
        assert_eq!(output.findings.len(), 1);
        assert_eq!(output.findings[0].severity, Severity::Warning);
    }

    // --- Planner output parsing tests ---

    #[test]
    fn parse_planner_output_valid_json() {
        let json = r#"{
            "batches": [{
                "batch": 1,
                "issues": [{
                    "number": 42,
                    "title": "Add login",
                    "area": "auth",
                    "predicted_files": ["src/auth.rs"],
                    "has_migration": false,
                    "complexity": "simple"
                }],
                "reasoning": "standalone issue"
            }],
            "total_issues": 1,
            "parallel_capacity": 1
        }"#;
        let output = parse_planner_output(json).unwrap();
        assert_eq!(output.batches.len(), 1);
        assert_eq!(output.batches[0].issues.len(), 1);
        assert_eq!(output.batches[0].issues[0].number, 42);
        assert_eq!(output.batches[0].issues[0].complexity, Complexity::Simple);
        assert!(!output.batches[0].issues[0].has_migration);
    }

    #[test]
    fn parse_planner_output_in_code_fences() {
        let text = r#"Here's the plan:

```json
{
    "batches": [{"batch": 1, "issues": [{"number": 1, "complexity": "full"}], "reasoning": "ok"}],
    "total_issues": 1,
    "parallel_capacity": 1
}
```

That's the plan."#;
        let output = parse_planner_output(text).unwrap();
        assert_eq!(output.batches.len(), 1);
        assert_eq!(output.batches[0].issues[0].complexity, Complexity::Full);
    }

    #[test]
    fn parse_planner_output_malformed_returns_none() {
        assert!(parse_planner_output("not json at all").is_none());
        assert!(parse_planner_output(r#"{"batches": "broken"}"#).is_none());
        assert!(parse_planner_output("").is_none());
    }

    #[test]
    fn complexity_deserializes_from_strings() {
        let simple: Complexity = serde_json::from_str(r#""simple""#).unwrap();
        assert_eq!(simple, Complexity::Simple);
        let full: Complexity = serde_json::from_str(r#""full""#).unwrap();
        assert_eq!(full, Complexity::Full);
    }

    #[test]
    fn complexity_display_roundtrip() {
        for c in [Complexity::Simple, Complexity::Full] {
            let s = c.to_string();
            let parsed: Complexity = s.parse().unwrap();
            assert_eq!(c, parsed);
        }
    }

    #[test]
    fn planner_output_defaults_complexity_to_full() {
        let json = r#"{"batches": [{"batch": 1, "issues": [{"number": 5}], "reasoning": ""}], "total_issues": 1, "parallel_capacity": 1}"#;
        let output = parse_planner_output(json).unwrap();
        assert_eq!(output.batches[0].issues[0].complexity, Complexity::Full);
    }

    #[test]
    fn planner_output_with_multiple_batches() {
        let json = r#"{
            "batches": [
                {"batch": 1, "issues": [{"number": 1, "complexity": "simple"}, {"number": 2, "complexity": "simple"}], "reasoning": "independent"},
                {"batch": 2, "issues": [{"number": 3, "complexity": "full"}], "reasoning": "depends on batch 1"}
            ],
            "total_issues": 3,
            "parallel_capacity": 2
        }"#;
        let output = parse_planner_output(json).unwrap();
        assert_eq!(output.batches.len(), 2);
        assert_eq!(output.batches[0].issues.len(), 2);
        assert_eq!(output.batches[1].issues.len(), 1);
        assert_eq!(output.total_issues, 3);
    }

    // --- DAG planner output parsing tests ---

    #[test]
    fn parse_graph_output_new_format() {
        let json = r#"{
            "nodes": [
                {"number": 1, "title": "A", "area": "cli", "depends_on": [], "complexity": "simple"},
                {"number": 2, "title": "B", "area": "db", "depends_on": [1], "complexity": "full"}
            ],
            "total_issues": 2,
            "parallel_capacity": 2
        }"#;
        let output = parse_planner_graph_output(json).unwrap();
        assert_eq!(output.nodes.len(), 2);
        assert!(output.nodes[0].depends_on.is_empty());
        assert_eq!(output.nodes[1].depends_on, vec![1]);
    }

    #[test]
    fn parse_graph_output_falls_back_to_batch_format() {
        let json = r#"{
            "batches": [
                {"batch": 1, "issues": [{"number": 1, "complexity": "simple"}, {"number": 2, "complexity": "simple"}], "reasoning": "ok"},
                {"batch": 2, "issues": [{"number": 3, "complexity": "full"}], "reasoning": "deps"}
            ],
            "total_issues": 3,
            "parallel_capacity": 2
        }"#;
        let output = parse_planner_graph_output(json).unwrap();
        assert_eq!(output.nodes.len(), 3);
        // Batch 1 issues have no dependencies
        assert!(output.nodes[0].depends_on.is_empty());
        assert!(output.nodes[1].depends_on.is_empty());
        // Batch 2 issue depends on batch 1 issues
        let mut deps = output.nodes[2].depends_on.clone();
        deps.sort_unstable();
        assert_eq!(deps, vec![1, 2]);
    }

    #[test]
    fn parse_graph_output_malformed_returns_none() {
        assert!(parse_planner_graph_output("garbage").is_none());
    }

    #[test]
    fn batches_to_graph_three_batches() {
        let legacy = PlannerOutput {
            batches: vec![
                Batch {
                    batch: 1,
                    issues: vec![PlannedIssue {
                        number: 1,
                        title: "A".into(),
                        area: "a".into(),
                        predicted_files: vec![],
                        has_migration: false,
                        complexity: Complexity::Simple,
                    }],
                    reasoning: String::new(),
                },
                Batch {
                    batch: 2,
                    issues: vec![PlannedIssue {
                        number: 2,
                        title: "B".into(),
                        area: "b".into(),
                        predicted_files: vec![],
                        has_migration: false,
                        complexity: Complexity::Full,
                    }],
                    reasoning: String::new(),
                },
                Batch {
                    batch: 3,
                    issues: vec![PlannedIssue {
                        number: 3,
                        title: "C".into(),
                        area: "c".into(),
                        predicted_files: vec![],
                        has_migration: false,
                        complexity: Complexity::Full,
                    }],
                    reasoning: String::new(),
                },
            ],
            total_issues: 3,
            parallel_capacity: 1,
        };

        let output = batches_to_graph_output(&legacy);
        assert_eq!(output.nodes.len(), 3);
        assert!(output.nodes[0].depends_on.is_empty()); // batch 1
        assert_eq!(output.nodes[1].depends_on, vec![1]); // batch 2
        let mut deps = output.nodes[2].depends_on.clone();
        deps.sort_unstable();
        assert_eq!(deps, vec![1, 2]); // batch 3
    }

    // --- Fixer output parsing tests ---

    #[test]
    fn parse_fixer_output_valid_json() {
        let json = r#"{"addressed":[{"finding":1,"action":"fixed"}],"disputed":[{"finding":2,"reason":"prop does not exist in v2"}]}"#;
        let output = parse_fixer_output(json);
        assert_eq!(output.addressed.len(), 1);
        assert_eq!(output.addressed[0].finding, 1);
        assert_eq!(output.disputed.len(), 1);
        assert_eq!(output.disputed[0].finding, 2);
        assert_eq!(output.disputed[0].reason, "prop does not exist in v2");
    }

    #[test]
    fn parse_fixer_output_in_code_fences() {
        let text = "I fixed everything.\n\n```json\n{\"addressed\":[{\"finding\":1,\"action\":\"added test\"}],\"disputed\":[]}\n```\n\nDone.";
        let output = parse_fixer_output(text);
        assert_eq!(output.addressed.len(), 1);
        assert!(output.disputed.is_empty());
    }

    #[test]
    fn parse_fixer_output_missing_disputed_defaults_empty() {
        let json = r#"{"addressed":[{"finding":1,"action":"fixed"}]}"#;
        let output = parse_fixer_output(json);
        assert_eq!(output.addressed.len(), 1);
        assert!(output.disputed.is_empty());
    }

    #[test]
    fn parse_fixer_output_missing_addressed_defaults_empty() {
        let json = r#"{"disputed":[{"finding":1,"reason":"API removed"}]}"#;
        let output = parse_fixer_output(json);
        assert!(output.addressed.is_empty());
        assert_eq!(output.disputed.len(), 1);
    }

    #[test]
    fn parse_fixer_output_garbage_returns_default() {
        let output = parse_fixer_output("This is just prose, no JSON here.");
        assert!(output.addressed.is_empty());
        assert!(output.disputed.is_empty());
    }

    #[test]
    fn parse_fixer_output_empty_returns_default() {
        let output = parse_fixer_output("");
        assert!(output.addressed.is_empty());
        assert!(output.disputed.is_empty());
    }
}