Struct IndexManager 

pub struct IndexManager { /* private fields */ }

Index manager that handles index lifecycle and file watching.

Provides two-phase initialization:

1. new() - Load or refresh index at startup
2. start_file_watcher() - Start background file watching

Implementations

impl IndexManager

pub async fn new<P: AsRef<Path>>( codebase_path: P, stores: Arc<SharedStores>, ) -> Result<Self>

Create a new index manager with shared stores.

This is the first method call - should be called at server startup.

Arguments

• codebase_path - Path to the codebase to index
• stores - Shared stores for concurrent access (created by caller)

Returns

• Result<Self> - Index manager instance or error

Behavior

• Checks if index exists and is up-to-date
• ERROR if index doesn’t exist - user must run codesearch index add first
• If index exists, performs incremental refresh
• Logs all operations with detailed info

Errors

• Returns error if index doesn’t exist (user must create index first)

pub fn stores(&self) -> Arc<SharedStores>

Get a reference to the shared stores (for CodesearchService)

pub async fn new_without_refresh<P: AsRef<Path>>( codebase_path: P, stores: Arc<SharedStores>, ) -> Result<Self>

Create a new index manager WITHOUT performing incremental refresh.

Use this when the caller has already performed the refresh (e.g., MCP server). This avoids FTS lock conflicts by allowing the caller to control when the refresh happens relative to SharedStores creation.

Arguments

• codebase_path - Path to the codebase to index
• stores - Shared stores for concurrent access (created by caller)

pub async fn perform_incremental_refresh_with_stores( codebase_path: &Path, db_path: &Path, stores: &SharedStores, ) -> Result<()>

Perform incremental refresh using shared stores.

This checks for changed/deleted files since last index and updates the index accordingly. Uses the shared stores to avoid lock conflicts.

pub async fn start_watching(&self) -> Result<()>

Start the file system watcher (begin collecting events) without starting the processing loop.

Call this BEFORE a long-running operation (like incremental refresh) to capture file changes that happen during that operation. Then call start_file_watcher() afterwards to begin processing the buffered events.

pub async fn start_file_watcher( &self, cancel_token: CancellationToken, ) -> Result<()>

Start the background file watcher.

This is the second method call - should be called after new(). Spawns a background task that watches for file changes and refreshes the index.

Arguments

• cancel_token - Cancellation token for graceful shutdown

Returns

• Result<()> - Success or error

Behavior

• Spawns a detached background task
• Watches for file modifications, deletions, and renames
• Batches events to avoid overhead with rapid changes
• Flushes batch when no new events for FSW_BATCH_FLUSH_MS
• Logs all file system events and refresh operations
• Continues running even if individual refresh operations fail
• Stops gracefully when the cancellation token is cancelled