Struct DependencyIndex 

pub struct DependencyIndex { /* private fields */ }

Manages dependency storage and graph operations

Implementations

impl DependencyIndex

pub fn new(cache: CacheManager) -> Self

Create a new dependency index for the given cache

pub fn from_db_path(db_path: impl Into<PathBuf>) -> Self

Create a dependency index pointing directly at a database file.

Used by Pulse to run analysis against snapshot databases.

pub fn get_cache(&self) -> &CacheManager

Get a reference to the cache manager.

Panics if this index was created via from_db_path().

pub fn insert_dependency( &self, file_id: i64, imported_path: String, resolved_file_id: Option<i64>, import_type: ImportType, line_number: usize, imported_symbols: Option<Vec<String>>, ) -> Result<()>

Insert a dependency into the database

Arguments

• file_id - Source file ID
• imported_path - Import path as written in source
• resolved_file_id - Resolved target file ID (None if external/stdlib)
• import_type - Type of import (internal/external/stdlib)
• line_number - Line where import appears
• imported_symbols - Optional list of imported symbols

pub fn insert_export( &self, file_id: i64, exported_symbol: Option<String>, source_path: String, resolved_source_id: Option<i64>, line_number: usize, ) -> Result<()>

Insert an export into the database

Arguments

• file_id - Source file ID containing the export statement
• exported_symbol - Symbol name being exported (None for wildcard exports)
• source_path - Path where the symbol is re-exported from
• resolved_source_id - Resolved target file ID (None if unresolved)
• line_number - Line where export appears

pub fn batch_insert_dependencies( &self, dependencies: &[Dependency], ) -> Result<()>

Batch insert multiple dependencies in a single transaction

More efficient than individual inserts for bulk operations.

pub fn get_dependencies(&self, file_id: i64) -> Result<Vec<Dependency>>

Get all direct dependencies for a file

Returns a list of files/modules that this file imports.

pub fn get_dependents(&self, file_id: i64) -> Result<Vec<i64>>

Get all files that depend on this file (reverse lookup)

Returns a list of file IDs that import this file. Uses resolved_file_id column for instant SQL lookup (sub-10ms).

pub fn get_dependencies_info(&self, file_id: i64) -> Result<Vec<DependencyInfo>>

Get dependencies as DependencyInfo (for API output)

Converts internal Dependency records to simplified DependencyInfo suitable for JSON output.

pub fn get_transitive_deps( &self, file_id: i64, max_depth: usize, ) -> Result<HashMap<i64, usize>>

Get transitive dependencies up to a given depth

Traverses the dependency graph using BFS to find all dependencies reachable within the specified depth. Uses resolved_file_id column for instant SQL lookup (sub-100ms).

Arguments

• file_id - Starting file ID
• max_depth - Maximum traversal depth (0 = only direct deps)

Returns

HashMap mapping file_id to depth (distance from start file)

pub fn detect_circular_dependencies(&self) -> Result<Vec<Vec<i64>>>

Detect circular dependencies in the entire codebase

Uses depth-first search to find cycles in the dependency graph. Uses resolved_file_id column for instant SQL lookup (sub-100ms).

Returns a list of cycle paths, where each cycle is represented as a vector of file IDs forming the cycle.

pub fn get_file_paths(&self, file_ids: &[i64]) -> Result<HashMap<i64, String>>

Get file paths for a list of file IDs

Useful for converting file ID results to human-readable paths.

pub fn find_hotspots( &self, limit: Option<usize>, min_dependents: usize, ) -> Result<Vec<(i64, usize)>>

Find hotspots (most imported files)

Returns a list of (file_id, count) tuples sorted by import count descending.

Uses resolved_file_id column for instant SQL aggregation (sub-100ms).

Arguments

• limit - Maximum number of hotspots to return (None = all)
• min_dependents - Minimum number of imports required to be a hotspot (default: 2)

pub fn find_unused_files(&self) -> Result<Vec<i64>>

Find unused files (files with no incoming dependencies)

Files that are never imported are potential candidates for deletion. Uses resolved_file_id column for instant SQL lookup (sub-10ms).

Barrel Export Resolution: This function now follows barrel export chains to detect files that are indirectly imported via re-exports. For example:

• WithLabel.vue exported by packages/ui/components/index.ts
• App imports @packages/ui/components (resolves to index.ts)
• This function follows the export chain and marks WithLabel.vue as used

pub fn resolve_through_barrel_exports( &self, barrel_file_id: i64, ) -> Result<Vec<i64>>

Resolve barrel export chains to find all files transitively exported from a given file

Given a barrel file (e.g., index.ts that re-exports from other files), this function follows the export chain to find all source files that are transitively exported.

Example

If packages/ui/components/index.ts contains:

export { default as WithLabel } from './WithLabel.vue';
export { default as Button } from './Button.vue';

Then calling this with the file_id of index.ts will return the file IDs of WithLabel.vue and Button.vue.

Arguments

• barrel_file_id - File ID of the barrel file to start from

Returns

Vec of file IDs that are transitively exported (includes the barrel file itself)

pub fn find_islands(&self) -> Result<Vec<Vec<i64>>>

Find disconnected components (islands) in the dependency graph

An “island” is a connected component - a group of files that depend on each other (directly or transitively) but have no dependencies to files outside the group.

This is useful for identifying:

• Independent subsystems that could be extracted as separate modules
• Unreachable code clusters that might be dead code
• Microservice boundaries in a monolith

Returns a list of islands, where each island is a vector of file IDs. Islands are sorted by size (largest first).

pub fn clear_dependencies(&self, file_id: i64) -> Result<()>

Clear all dependencies for a file (used during incremental reindexing)

pub fn resolve_imported_path_to_file_id( &self, imported_path: &str, ) -> Result<Option<i64>>

Resolve an imported path to a file ID using fuzzy matching

This method converts an import path (e.g., namespace, module path) to various file path variants and tries to find a matching file using fuzzy path matching.

Arguments

• imported_path - The import path as stored in the database (e.g., “Rcm\Http\Controllers\Controller”, “crate::models”, etc.)

Returns

Some(file_id) if exactly one matching file is found, None otherwise

Examples

• Rcm\\Http\\Controllers\\Controller → finds services/php/rcm-backend/app/Http/Controllers/Controller.php
• crate::models → finds src/models.rs

pub fn get_file_id_by_path(&self, path: &str) -> Result<Option<i64>>

Get file ID by path with fuzzy matching support

Supports various path formats:

• Exact paths: services/php/app/Http/Controllers/FooController.php
• Relative paths: ./services/php/app/Http/Controllers/FooController.php
• Path fragments: Controllers/FooController.php or FooController.php
• Absolute paths: /home/user/project/services/php/.../FooController.php

Returns None if no matches found. Returns error if multiple matches found (ambiguous path fragment).

pub fn get_resolution_stats(&self) -> Result<Vec<(String, usize, usize, f64)>>

Get dependency resolution statistics grouped by language

Returns statistics showing how many internal dependencies are resolved vs unresolved for each language in the project.

Returns

A vector of tuples: (language, total_deps, resolved_deps, resolution_rate)

pub fn get_all_internal_dependencies( &self, ) -> Result<Vec<(String, String, Option<String>)>>

Get all internal dependencies with their resolution status

Returns detailed information about each internal dependency including source file, imported path, and whether it was successfully resolved.

Returns

A vector of tuples: (source_file, imported_path, resolved_file_path) where resolved_file_path is None if the dependency couldn’t be resolved.

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

Get total count of dependencies by type (for debugging)