Struct CodeGraph 

pub struct CodeGraph {
    pub dangling_edges: usize,
    /* private fields */
}

Fields

dangling_edges: usize

edges we couldn’t attach because an endpoint symbol was missing.

Implementations

impl CodeGraph

pub fn build(symbols: &[Symbol], edges: &[Edge]) -> CodeGraph

Build from the resolved corpus. Edge endpoints are matched by rendered SCIP id.

pub fn node_count(&self) -> usize

pub fn edge_count(&self) -> usize

pub fn scope_of(&self, focus: &str) -> Option<(String, Vec<String>)>

A symbol and its containers (class, file) as ids: what explains it, from inside out.

pub fn node(&self, idx: NodeIndex) -> Node

pub fn lookup(&self, focus: &str) -> Option<NodeIndex>

Resolve a user-supplied focus string to a node: exact rendered id, then exact descriptor, then descriptor substring, then symbol name. Prefers definitions (functions/classes) over files, and shorter descriptors (less nested) on ties.

pub fn repos(&self) -> Vec<(String, usize)>

Indexed repos with their symbol counts (for a repos overview tool).

pub fn dependents_count(&self, rendered_id: &str) -> usize

Cheap centrality proxy: number of direct dependents (incoming Calls/Imports). Used to boost widely-depended-on code in search ranking — a signal pure semantic/ lexical search (e.g. semble) lacks.

pub fn find(&self, query: &str, limit: usize) -> Vec<Node>

Find symbols by name or descriptor substring. Prefers definitions over files and shorter (less nested) descriptors. Returns up to limit.

pub fn ripple(&self, focus: NodeIndex, max_depth: usize) -> Vec<Hop>

Who breaks if I change focus? Reverse reachability over DEPENDENCY edges (callers of callers, importers), multi-hop, cross-repo. Structural Contains is ignored — a containing module is not a dependency.

pub fn flow_trace(&self, focus: NodeIndex) -> String

The flow from focus as the text a walkthrough is written from, one step per line.

pub fn flow(&self, focus: NodeIndex, max_depth: usize) -> Vec<FlowStep>

Where a request or message started at focus travels: calls, then across contracts to the handler of an HTTP route or the subscribers of a topic or queue, in other repositories too.

pub fn entry_points(&self, top: usize) -> Vec<(NodeIndex, usize)>

Where flows start: production functions whose flow goes furthest, the ones crossing the most repositories first. Returns the node and how many steps its flow has.

pub fn thread(&self, focus: NodeIndex, max_depth: usize) -> Vec<Hop>

What does focus do downstream? Forward call trace.

pub fn contracts(&self, kind: Option<&str>, dangling: bool) -> Vec<ContractView>

All contracts, optionally of one type (http, sqs, …) or only those missing a side.

pub fn zoom(&self, focus: NodeIndex) -> Zoom

The structured neighborhood of focus.

pub fn context_pack( &self, focus: NodeIndex, token_budget: usize, ) -> Vec<(Node, usize)>

The minimal correct context to change focus safely, within token_budget.

Ranks all symbols by personalized-PageRank proximity to focus (restart at focus, edges treated as undirected for proximity), then greedily packs the highest-ranked until the estimated token budget is exhausted. Returns (node, est_tokens) pairs.