bookmark 0.1.4

Interactive bookmark manager with knowledge graph generation from browser bookmarks and history
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

mod analyzer;
mod builder;
pub mod formats;
#[cfg(test)]
mod tests;

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

// Re-export public API
pub use builder::GraphBuilder;

/// Node types in the knowledge graph
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum NodeType {
    Bookmark,
    Domain,
    Folder,
    Tag,
    Category,
}

/// Edge types representing different relationships
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum EdgeType {
    BelongsToDomain,
    InFolder,
    SameDomain,
    HasTag,
    InCategory,
    SimilarContent,
}

/// Metadata for a graph node
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NodeMetadata {
    pub date_added: Option<DateTime<Utc>>,
    pub visit_count: Option<i64>,
    pub bookmark_count: usize,
}

/// A node in the knowledge graph
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphNode {
    pub id: String,
    pub title: String,
    pub node_type: NodeType,
    pub url: Option<String>,
    pub domain: Option<String>,
    pub folder: Option<String>,
    pub size: usize,
}

/// An edge in the knowledge graph
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphEdge {
    pub source: String,
    pub target: String,
    pub edge_type: EdgeType,
    pub weight: f64,
}

/// Metadata for the knowledge graph
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphMetadata {
    pub total_nodes: usize,
    pub total_edges: usize,
    pub bookmark_count: usize,
    pub domain_count: usize,
    pub folder_count: usize,
    pub generated_at: DateTime<Utc>,
}

/// The main knowledge graph structure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KnowledgeGraph {
    pub nodes: Vec<GraphNode>,
    pub edges: Vec<GraphEdge>,
    pub metadata: GraphMetadata,
}

/// Detail level for graph generation
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DetailLevel {
    /// Overview: Only domains and folders, no individual bookmarks
    Overview,
    /// Standard: Domains, folders, and top N bookmarks per domain
    Standard,
    /// Detailed: Full graph with all bookmarks
    Detailed,
}

/// Configuration for graph generation
#[derive(Debug, Clone)]
pub struct GraphConfig {
    pub include_domain_edges: bool,
    pub include_folder_edges: bool,
    pub include_same_domain_edges: bool,
    pub include_tag_edges: bool,
    pub include_category_edges: bool,
    pub include_similarity_edges: bool,
    pub min_domain_threshold: usize,
    pub min_tag_threshold: usize,
    pub similarity_threshold: f64,
    /// Level of detail for the graph
    pub detail_level: DetailLevel,
    /// Maximum number of bookmarks to show per domain (None = all)
    pub max_bookmarks_per_domain: Option<usize>,
    /// Maximum total bookmarks (None = no limit)
    pub max_total_bookmarks: Option<usize>,
    /// Only include bookmarks newer than this date (None = all time)
    pub min_date: Option<chrono::DateTime<chrono::Utc>>,
    /// Domain-only mode (collapse all bookmarks into domains)
    pub domain_only: bool,
}

impl Default for GraphConfig {
    fn default() -> Self {
        Self {
            include_domain_edges: true,
            include_folder_edges: true,
            include_same_domain_edges: false,
            include_tag_edges: false,
            include_category_edges: true,
            include_similarity_edges: false,
            min_domain_threshold: 5,
            min_tag_threshold: 3,
            similarity_threshold: 0.3,
            detail_level: DetailLevel::Standard,
            max_bookmarks_per_domain: Some(10),
            max_total_bookmarks: Some(5000),
            min_date: None,
            domain_only: false,
        }
    }
}