nexus-memory-web 1.3.0

Web dashboard for Nexus Memory System with Axum
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
139
140
141
142
143
144
145

//! Statistics API endpoints

use axum::{
    extract::{Path, State},
    Json,
};
use serde_json::json;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;

use crate::{
    error::Result,
    models::{AgentStats, StatsResponse, SystemInfo},
    state::AppState,
};

/// Get global statistics
pub async fn get_stats(State(state): State<Arc<RwLock<AppState>>>) -> Result<Json<StatsResponse>> {
    let state = state.read().await;

    // Get all namespaces
    let namespaces = state.namespace_repo.list_all().await?;

    let mut total_memories: i64 = 0;
    let mut active_memories: i64 = 0;
    let mut archived_memories: i64 = 0;
    let mut categories: HashMap<String, i64> = HashMap::new();
    let mut agent_stats: Vec<AgentStats> = Vec::new();

    for namespace in &namespaces {
        // Count memories using unfiltered queries for accurate totals
        let ns_total = state
            .memory_repo
            .count_all_by_namespace(namespace.id)
            .await?;
        let ns_active = state.memory_repo.count_by_namespace(namespace.id).await?;
        let ns_archived = state
            .memory_repo
            .count_archived_by_namespace(namespace.id)
            .await?;

        // Get active memories for category breakdown
        let memories = state
            .memory_repo
            .search_by_namespace(namespace.id, 10000, 0)
            .await?;

        // Count categories from active memories
        let mut ns_categories: HashMap<String, i64> = HashMap::new();
        for memory in &memories {
            let cat = memory.category.to_string();
            *ns_categories.entry(cat.clone()).or_insert(0) += 1;
            *categories.entry(cat).or_insert(0) += 1;
        }

        // Find oldest and newest memories
        let oldest = memories.iter().map(|m| m.created_at).min();
        let newest = memories.iter().map(|m| m.created_at).max();

        agent_stats.push(AgentStats {
            agent_type: namespace.agent_type.clone(),
            namespace_name: namespace.name.clone(),
            total_memories: ns_total,
            active_memories: ns_active,
            archived_memories: ns_archived,
            categories: json!(ns_categories),
            oldest_memory: oldest.map(|d| d.to_rfc3339()),
            newest_memory: newest.map(|d| d.to_rfc3339()),
        });

        total_memories += ns_total;
        active_memories += ns_active;
        archived_memories += ns_archived;
    }

    let system_info = SystemInfo {
        version: env!("CARGO_PKG_VERSION").to_string(),
        uptime_seconds: state.uptime_seconds(),
        active_sessions: state.orchestrator.active_session_count().await,
    };

    Ok(Json(StatsResponse {
        success: true,
        total_memories,
        active_memories,
        archived_memories,
        categories: json!(categories),
        agents: agent_stats,
        system_info: Some(system_info),
    }))
}

/// Get statistics for a specific agent
pub async fn get_agent_stats(
    State(state): State<Arc<RwLock<AppState>>>,
    Path(agent_type): Path<String>,
) -> Result<Json<AgentStats>> {
    let state = state.read().await;

    // Get namespace for this agent
    let namespace = state
        .namespace_repo
        .get_or_create(&agent_type, &agent_type)
        .await?;

    // Count memories using unfiltered queries for accurate totals
    let count = state
        .memory_repo
        .count_all_by_namespace(namespace.id)
        .await?;
    let active = state.memory_repo.count_by_namespace(namespace.id).await?;
    let archived = state
        .memory_repo
        .count_archived_by_namespace(namespace.id)
        .await?;

    // Get active memories for category breakdown
    let memories = state
        .memory_repo
        .search_by_namespace(namespace.id, 10000, 0)
        .await?;

    // Count categories
    let mut ns_categories: HashMap<String, i64> = HashMap::new();
    for memory in &memories {
        let cat = memory.category.to_string();
        *ns_categories.entry(cat).or_insert(0) += 1;
    }

    // Find oldest and newest memories
    let oldest = memories.iter().map(|m| m.created_at).min();
    let newest = memories.iter().map(|m| m.created_at).max();

    Ok(Json(AgentStats {
        agent_type: namespace.agent_type,
        namespace_name: namespace.name,
        total_memories: count,
        active_memories: active,
        archived_memories: archived,
        categories: json!(ns_categories),
        oldest_memory: oldest.map(|d| d.to_rfc3339()),
        newest_memory: newest.map(|d| d.to_rfc3339()),
    }))
}