vtcode-core 0.136.0

Core library for VT Code - a Rust-based terminal coding agent
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

//! Inventory-related accessors for ToolRegistry.

use std::path::PathBuf;
use std::sync::Arc;

use crate::tools::edited_file_monitor::EditedFileMonitor;
use crate::tools::file_ops::FileOpsTool;
use crate::tools::grep_file::GrepSearchManager;

use super::{Tool, ToolHandler, ToolRegistry};

impl ToolRegistry {
    /// Get a tool by name from the inventory (with hot cache optimization).
    pub fn get_tool(&self, name: &str) -> Option<Arc<dyn Tool>> {
        // Check hot cache first if optimizations are enabled
        if self.optimization_config.tool_registry.use_optimized_registry {
            // Use a separate read and write operation to avoid borrow checker issues
            {
                let cache = self.hot_tool_cache.read();
                if let Some(cached_tool) = cache.peek(name) {
                    return Some(cached_tool.clone());
                }
            }
        }

        // Fallback to inventory lookup
        let tool = self.inventory.get_registration(name).and_then(|reg| match reg.handler() {
            ToolHandler::TraitObject(tool) => Some(tool.clone()),
            _ => None,
        });

        // Cache the result if optimizations are enabled and tool was found
        if let Some(ref tool_arc) = tool
            && self.optimization_config.tool_registry.use_optimized_registry
        {
            self.hot_tool_cache.write().put(name.to_string(), tool_arc.clone());
        }

        tool
    }
    pub fn workspace_root(&self) -> &PathBuf {
        self.inventory.workspace_root()
    }

    /// Get the workspace root as an owned PathBuf.
    pub fn workspace_root_owned(&self) -> PathBuf {
        self.inventory.workspace_root().clone()
    }

    pub fn file_ops_tool(&self) -> &FileOpsTool {
        self.inventory.file_ops_tool()
    }

    /// Borrow the edited-file monitor without exposing shared ownership.
    pub fn edited_file_monitor_ref(&self) -> &EditedFileMonitor {
        self.edited_file_monitor.as_ref()
    }

    /// Get the shared edited-file monitor handle for callers that need to clone it.
    pub fn edited_file_monitor(&self) -> &Arc<EditedFileMonitor> {
        &self.edited_file_monitor
    }

    pub fn grep_file_manager(&self) -> Arc<GrepSearchManager> {
        self.inventory.grep_file_manager()
    }
}