Struct RepoGraph 

pub struct RepoGraph {
    pub files: Vec<FileNode>,
    pub edges: Vec<(u32, u32, u32)>,
    pub base_ranks: Vec<f32>,
    pub callers: Vec<Vec<u32>>,
    pub callees: Vec<Vec<u32>>,
    pub def_edges: Vec<(DefId, DefId, u32)>,
    pub def_ranks: Vec<f32>,
    pub def_callers: Vec<Vec<DefId>>,
    pub def_callees: Vec<Vec<DefId>>,
    pub def_offsets: Vec<usize>,
    pub alpha: f32,
}

Persisted dependency graph with PageRank scores.

Fields

files: Vec<FileNode>

Files in the repository with definitions, imports, and calls.

edges: Vec<(u32, u32, u32)>

File-level edges (derived from def-level call edges).

base_ranks: Vec<f32>

File-level PageRank scores (aggregated from def-level).

callers: Vec<Vec<u32>>

File-level callers (indices into files).

callees: Vec<Vec<u32>>

File-level callees (indices into files).

def_edges: Vec<(DefId, DefId, u32)>

Definition-level call edges: (caller_def, callee_def, weight).

def_ranks: Vec<f32>

Definition-level PageRank scores (flattened: offsets[file_idx] + def_idx).

def_callers: Vec<Vec<DefId>>

Definition-level callers (flattened, parallel to def_ranks).

def_callees: Vec<Vec<DefId>>

Definition-level callees (flattened, parallel to def_ranks).

def_offsets: Vec<usize>

Prefix-sum offsets for flattening DefId to linear index.

alpha: f32

Auto-tuned alpha for search boost.

Implementations

impl RepoGraph

pub fn def_rank(&self, did: DefId) -> f32

Get the PageRank score for a specific definition.

pub fn find_def(&self, file_path: &str, def_name: &str) -> Option<DefId>

Look up a definition by file path and name. Returns the first match.

pub fn resolve_focus_file(&self, focus: &str) -> FocusResolution

Resolve a caller-supplied focus_file string to a file index in Self::files.

Accepts any of the path forms that ripvec itself emits or accepts:

• Exact stored path (device_opt/services/storage.py) — direct match.
• LSP-shaped path (./device_opt/services/storage.py) — the ./ prefix used by every RepoMapLspLocation::file_path is stripped before comparison so the documented chaining pattern get_repo_map(focus_file=hits[0].lsp_location.file_path) works.
• Strict suffix (storage.py, services/storage.py) — match when the previous character in the stored path is /. Avoids matching foo_storage.py for storage.py.

Returns FocusResolution::Found when exactly one file matches, FocusResolution::Ambiguous when multiple files match (the caller surfaces the candidate list to the user), and FocusResolution::NotFound when no file matches.

Background

Prior to this helper the MCP layer (crates/ripvec-mcp/src/tools.rs) did the matching inline with two bugs:

1. ./ prefix mismatch. RepoMapLspLocation::file_path always carries a leading ./ (see [file_lsp_location]), but FileNode::path does not. Passing the LSP location verbatim as focus_file matched zero files. The matcher silently returned focus = None, producing rank values bit-identical to the unfocused call — the bug originally reported as “I#20 focus_file rebias invisible on Python”.
2. Equal-length false negative. When the user passed ./device_opt/services/storage.py and the stored path was device_opt/services/storage.py, exact was false (the strings differ by two bytes) and strict_suffix was false (the focus is longer than the stored path, so p.len() > focus.len() fails). The pathology surfaced specifically when the focus was a full path with the LSP ./ prefix.

Centralising the resolution here gives every caller the same normalization-tolerant semantics and one place to test the contract.

Trait Implementations

impl Archive for RepoGraph

where Vec<FileNode>: Archive, Vec<(u32, u32, u32)>: Archive, Vec<f32>: Archive, Vec<Vec<u32>>: Archive, Vec<(DefId, DefId, u32)>: Archive, Vec<Vec<DefId>>: Archive, Vec<usize>: Archive, f32: Archive,

const COPY_OPTIMIZATION: CopyOptimization<Self>

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

type Archived = ArchivedRepoGraph

The archived representation of this type.

type Resolver = RepoGraphResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for RepoGraph

fn clone(&self) -> RepoGraph

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RepoGraph

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<RepoGraph, __D> for Archived<RepoGraph>

where Vec<FileNode>: Archive, <Vec<FileNode> as Archive>::Archived: Deserialize<Vec<FileNode>, __D>, Vec<(u32, u32, u32)>: Archive, <Vec<(u32, u32, u32)> as Archive>::Archived: Deserialize<Vec<(u32, u32, u32)>, __D>, Vec<f32>: Archive, <Vec<f32> as Archive>::Archived: Deserialize<Vec<f32>, __D>, Vec<Vec<u32>>: Archive, <Vec<Vec<u32>> as Archive>::Archived: Deserialize<Vec<Vec<u32>>, __D>, Vec<(DefId, DefId, u32)>: Archive, <Vec<(DefId, DefId, u32)> as Archive>::Archived: Deserialize<Vec<(DefId, DefId, u32)>, __D>, Vec<Vec<DefId>>: Archive, <Vec<Vec<DefId>> as Archive>::Archived: Deserialize<Vec<Vec<DefId>>, __D>, Vec<usize>: Archive, <Vec<usize> as Archive>::Archived: Deserialize<Vec<usize>, __D>, f32: Archive, <f32 as Archive>::Archived: Deserialize<f32, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<RepoGraph, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for RepoGraph

where Vec<FileNode>: Serialize<__S>, Vec<(u32, u32, u32)>: Serialize<__S>, Vec<f32>: Serialize<__S>, Vec<Vec<u32>>: Serialize<__S>, Vec<(DefId, DefId, u32)>: Serialize<__S>, Vec<Vec<DefId>>: Serialize<__S>, Vec<usize>: Serialize<__S>, f32: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.