cargo-rail 0.22.1

//! `cargo rail graph` - planner/action reasoning graph output.

use crate::commands::common::PlanOutputFormat;
use crate::commands::plan::{PlanOptions, build_plan_output};
use crate::error::{RailError, RailResult};
use crate::workspace::WorkspaceContext;
use serde::Serialize;
use std::collections::BTreeSet;
use std::io::Write as _;
use std::path::PathBuf;

/// Options for the `graph` command.
pub struct GraphOptions {
    /// Git ref to compare against.
    pub since: Option<String>,
    /// Start of SHA range (used with `to`).
    pub from: Option<String>,
    /// End of SHA range (used with `from`).
    pub to: Option<String>,
    /// Use merge-base with default branch.
    pub merge_base: bool,
    /// Planner confidence profile override.
    pub confidence_profile: Option<String>,
    /// Emit GraphViz DOT output.
    pub dot: bool,
    /// Optional output path.
    pub output: Option<PathBuf>,
}

#[derive(Serialize)]
struct GraphNode {
    id: String,
    kind: String,
    label: String,
}

#[derive(Serialize)]
struct GraphEdge {
    from: String,
    to: String,
    relation: String,
}

#[derive(Serialize)]
struct PlannerGraph {
    nodes: Vec<GraphNode>,
    edges: Vec<GraphEdge>,
}

/// Run the graph command.
pub fn run_graph(ctx: &WorkspaceContext, opts: GraphOptions) -> RailResult<()> {
    crate::output::set_json_mode(true);

    let plan = build_plan_output(
        ctx,
        &PlanOptions {
            since: opts.since,
            from: opts.from,
            to: opts.to,
            merge_base: opts.merge_base,
            format: PlanOutputFormat::Json,
            output: None,
            explain: false,
            confidence_profile: opts.confidence_profile,
        },
    )?;

    let graph = build_graph(&plan);
    let rendered = if opts.dot {
        to_dot(&graph)
    } else {
        let payload =
            serde_json::to_value(&graph).map_err(|e| RailError::message(format!("graph JSON failed: {}", e)))?;
        let output = crate::output::machine_json_envelope("graph", "inspect", "success", 0, payload);
        serde_json::to_string_pretty(&output).map_err(|e| RailError::message(format!("graph JSON failed: {}", e)))?
    };

    write_output(&rendered, opts.output.as_ref())
}

fn build_graph(plan: &crate::commands::plan::PlanOutput) -> PlannerGraph {
    // Estimate: each file typically has 1-2 owners, so nodes ~ 2*files, edges ~ 2*files
    let file_count = plan.files.len();
    let mut nodes = Vec::with_capacity(file_count * 2);
    let mut edges = Vec::with_capacity(file_count * 2);
    let mut seen = BTreeSet::new();

    for file in &plan.files {
        let file_id = format!("file:{}", file.path);
        let is_new_file = seen.insert(file_id.clone());
        if is_new_file {
            nodes.push(GraphNode {
                id: file_id.clone(),
                kind: "file".to_string(),
                label: file.path.clone(),
            });
        }

        for owner in &file.owners {
            let crate_id = format!("crate:{}", owner);
            let is_new_crate = seen.insert(crate_id.clone());
            if is_new_crate {
                nodes.push(GraphNode {
                    id: crate_id.clone(),
                    kind: "crate".to_string(),
                    label: owner.clone(),
                });
            }
            edges.push(GraphEdge {
                from: file_id.clone(),
                to: crate_id, // Move instead of clone - last use
                relation: "owned_by".to_string(),
            });
        }
    }

    for (surface, decision) in &plan.surfaces {
        let surface_id = format!("surface:{}", surface);
        let is_new_surface = seen.insert(surface_id.clone());
        if is_new_surface {
            nodes.push(GraphNode {
                id: surface_id.clone(),
                kind: "surface".to_string(),
                label: format!(
                    "{} ({})",
                    surface,
                    if decision.enabled { "enabled" } else { "disabled" }
                ),
            });
        }

        for reason_id in &decision.reasons {
            let reason_node_id = format!("reason:{}", reason_id);
            let is_new_reason = seen.insert(reason_node_id.clone());
            if is_new_reason {
                let reason_label = plan
                    .trace
                    .iter()
                    .find(|r| r.id == *reason_id)
                    .map(|r| r.code.to_string())
                    .unwrap_or_else(|| format!("reason_{}", reason_id));
                nodes.push(GraphNode {
                    id: reason_node_id.clone(),
                    kind: "reason".to_string(),
                    label: reason_label,
                });
            }
            edges.push(GraphEdge {
                from: reason_node_id, // Move - last use
                to: surface_id.clone(),
                relation: "enables".to_string(),
            });
        }
    }

    PlannerGraph { nodes, edges }
}

fn to_dot(graph: &PlannerGraph) -> String {
    let mut out = String::new();
    out.push_str("digraph rail_plan {\n");
    out.push_str("  rankdir=LR;\n");
    for node in &graph.nodes {
        let shape = match node.kind.as_str() {
            "file" => "box",
            "crate" => "ellipse",
            "surface" => "diamond",
            _ => "oval",
        };
        out.push_str(&format!(
            "  \"{}\" [label=\"{}\", shape={}];\n",
            escape_dot(&node.id),
            escape_dot(&node.label),
            shape
        ));
    }
    for edge in &graph.edges {
        out.push_str(&format!(
            "  \"{}\" -> \"{}\" [label=\"{}\"];\n",
            escape_dot(&edge.from),
            escape_dot(&edge.to),
            escape_dot(&edge.relation)
        ));
    }
    out.push_str("}\n");
    out
}

fn escape_dot(input: &str) -> String {
    input.replace('\\', "\\\\").replace('"', "\\\"")
}

fn write_output(content: &str, output_file: Option<&PathBuf>) -> RailResult<()> {
    match output_file {
        Some(path) => {
            let mut file = std::fs::OpenOptions::new()
                .create(true)
                .truncate(true)
                .write(true)
                .open(path)
                .map_err(|e| RailError::message(format!("failed to open '{}': {}", path.display(), e)))?;
            writeln!(file, "{}", content)
                .map_err(|e| RailError::message(format!("failed to write '{}': {}", path.display(), e)))?;
            crate::progress!("output: {}", path.display());
            Ok(())
        }
        None => {
            println!("{}", content);
            Ok(())
        }
    }
}