unfault 1.0.62

Unfault — a cognitive context engine for thoughtful engineers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Local graph building helper.
//!
//! Builds an in-memory CodeGraph from the current workspace using unfault-core
//! for parsing and unfault-analysis for graph construction.

use anyhow::{Context, Result};
use colored::Colorize;

/// Build a CodeGraph and the per-file semantics together.
///
/// Like `build_analysis_graph` but also returns the semantics entries so
/// callers can inspect `http_calls`, `orm_queries`, etc. per file.
pub fn build_analysis_graph_with_semantics(
    workspace_path: &std::path::Path,
    verbose: bool,
) -> Result<(
    unfault_analysis::graph::CodeGraph,
    Vec<unfault_core::semantics::SourceSemantics>,
)> {
    use crate::session::ir_builder::build_ir_cached;

    let build_result = build_ir_cached(workspace_path, None, verbose)
        .context("Failed to build IR for graph analysis")?;

    let semantics = build_result.ir.semantics;
    let graph = unfault_analysis::graph::CodeGraph::from(build_result.ir.graph);

    Ok((graph, semantics))
}

/// Build a CodeGraph from the workspace by parsing all source files.
///
/// This builds the same IR that the review command uses, then extracts
/// the graph from it. The graph can be queried for impact, dependencies,
/// centrality, etc.
pub fn build_analysis_graph(
    workspace_path: &std::path::Path,
    verbose: bool,
) -> Result<unfault_analysis::graph::CodeGraph> {
    use crate::session::ir_builder::{build_ir_cached, try_load_code_graph_only};

    if verbose {
        eprintln!(
            "{} Building code graph for: {}",
            "→".cyan(),
            workspace_path.display()
        );
    }

    if let Some(graph) =
        try_load_code_graph_only(workspace_path, verbose).context("Failed to check graph cache")?
    {
        let graph = unfault_analysis::graph::CodeGraph::from(graph);

        if verbose {
            eprintln!(
                "{} Graph: {} files, {} functions",
                "✓".green(),
                graph.file_nodes.len(),
                graph.function_nodes.len()
            );
        }

        return Ok(graph);
    }

    // Build IR (parses files, builds semantics, constructs graph)
    let build_result = build_ir_cached(workspace_path, None, verbose)
        .context("Failed to build IR for graph analysis")?;

    // Convert core's CodeGraph directly into the analysis CodeGraph — zero copies,
    // no serialization. GraphNode and GraphEdgeKind are now the same types in both
    // crates (analysis/src/graph/mod.rs re-exports them from unfault-core).
    let graph = unfault_analysis::graph::CodeGraph::from(build_result.ir.graph);

    if verbose {
        eprintln!(
            "{} Graph: {} files, {} functions",
            "✓".green(),
            graph.file_nodes.len(),
            graph.function_nodes.len(),
        );
    }

    Ok(graph)
}