turbovault-tools 1.2.10

MCP tools implementation using turbomcp
Documentation 
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Vault analysis tools for statistics and relationship analysis

use serde_json::json;
use std::sync::Arc;
use turbovault_core::prelude::*;
use turbovault_vault::VaultManager;

/// Analysis tools context
pub struct AnalysisTools {
    pub manager: Arc<VaultManager>,
}

/// Statistics response structure
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct VaultStats {
    pub total_files: usize,
    pub total_links: usize,
    pub orphaned_files: usize,
    pub average_links_per_file: f64,
}

impl AnalysisTools {
    /// Create new analysis tools
    pub fn new(manager: Arc<VaultManager>) -> Self {
        Self { manager }
    }

    /// Get vault statistics
    pub async fn get_vault_stats(&self) -> Result<VaultStats> {
        let stats = self.manager.get_stats().await?;

        Ok(VaultStats {
            total_files: stats.total_files,
            total_links: stats.total_links,
            orphaned_files: stats.orphaned_files,
            average_links_per_file: stats.average_links_per_file,
        })
    }

    /// List all orphaned notes (no incoming or outgoing links)
    pub async fn list_orphaned_notes(&self) -> Result<Vec<String>> {
        let orphans = self.manager.get_orphaned_notes().await?;

        Ok(orphans
            .into_iter()
            .filter_map(|p| p.to_str().map(|s| s.to_string()))
            .collect())
    }

    /// Detect cycles (mutual linking patterns)
    pub async fn detect_cycles(&self) -> Result<Vec<Vec<String>>> {
        let graph = self.manager.link_graph();
        let graph_read = graph.read().await;

        let cycles = graph_read
            .cycles()
            .into_iter()
            .map(|cycle| {
                cycle
                    .into_iter()
                    .filter_map(|p| p.to_str().map(|s| s.to_string()))
                    .collect()
            })
            .collect();

        Ok(cycles)
    }

    /// Get link density (total links / possible links)
    pub async fn get_link_density(&self) -> Result<f64> {
        let stats = self.manager.get_stats().await?;

        // Link density = actual_links / possible_links
        // where possible_links = n * (n - 1) for directed graph
        if stats.total_files <= 1 {
            return Ok(0.0);
        }

        let possible_links = (stats.total_files as f64) * ((stats.total_files as f64) - 1.0);
        let density = (stats.total_links as f64) / possible_links;

        Ok(density)
    }

    /// Get connectivity metrics
    pub async fn get_connectivity_metrics(&self) -> Result<serde_json::Value> {
        let stats = self.manager.get_stats().await?;
        let density = self.get_link_density().await?;

        Ok(json!({
            "total_files": stats.total_files,
            "total_links": stats.total_links,
            "orphaned_files": stats.orphaned_files,
            "connected_files": stats.total_files - stats.orphaned_files,
            "average_links_per_file": stats.average_links_per_file,
            "link_density": density,
            "connectivity_rate": if stats.total_files > 0 {
                (stats.total_files - stats.orphaned_files) as f64 / stats.total_files as f64
            } else {
                0.0
            }
        }))
    }
}