claude-hindsight 1.1.0

20/20 hindsight for your Claude Code sessions
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

//! DTO (Data Transfer Object) layer for the web API
//!
//! Adds Serialize to existing storage structs via wrapper types with From impls.

use crate::storage::{GlobalAnalytics, ProjectAnalytics, ProjectStats, SessionFile};
use serde::{Deserialize, Serialize};

/// Serializable project stats
#[derive(Debug, Serialize, Deserialize)]
pub struct ProjectStatsDto {
    pub project_name: String,
    pub session_count: usize,
    pub total_size: u64,
    pub last_activity: Option<i64>,
}

impl From<ProjectStats> for ProjectStatsDto {
    fn from(s: ProjectStats) -> Self {
        Self {
            project_name: s.project_name,
            session_count: s.session_count,
            total_size: s.total_size,
            last_activity: s.last_activity,
        }
    }
}

/// Serializable global analytics
#[derive(Debug, Serialize, Deserialize)]
pub struct GlobalAnalyticsDto {
    pub total_sessions: usize,
    pub sessions_this_week: usize,
    pub sessions_today: usize,
    pub total_size: u64,
    pub total_projects: usize,
    pub subagent_count: usize,
    pub avg_session_size: u64,
    pub most_active_project: Option<String>,
    pub top_tools: Vec<(String, usize)>,
    pub total_errors: usize,
}

impl From<GlobalAnalytics> for GlobalAnalyticsDto {
    fn from(a: GlobalAnalytics) -> Self {
        Self {
            total_sessions: a.total_sessions,
            sessions_this_week: a.sessions_this_week,
            sessions_today: a.sessions_today,
            total_size: a.total_size,
            total_projects: a.total_projects,
            subagent_count: a.subagent_count,
            avg_session_size: a.avg_session_size,
            most_active_project: a.most_active_project,
            top_tools: a.top_tools,
            total_errors: a.total_errors,
        }
    }
}

/// Serializable project analytics
#[derive(Debug, Serialize, Deserialize)]
pub struct ProjectAnalyticsDto {
    pub project_name: String,
    pub total_sessions: usize,
    pub sessions_this_week: usize,
    pub sessions_today: usize,
    pub total_size: u64,
    pub subagent_count: usize,
    pub avg_session_size: u64,
    pub top_tools: Vec<(String, usize)>,
    pub last_activity: Option<i64>,
    pub total_errors: usize,
}

impl From<ProjectAnalytics> for ProjectAnalyticsDto {
    fn from(a: ProjectAnalytics) -> Self {
        Self {
            project_name: a.project_name,
            total_sessions: a.total_sessions,
            sessions_this_week: a.sessions_this_week,
            sessions_today: a.sessions_today,
            total_size: a.total_size,
            subagent_count: a.subagent_count,
            avg_session_size: a.avg_session_size,
            top_tools: a.top_tools,
            last_activity: a.last_activity,
            total_errors: a.total_errors,
        }
    }
}

/// Serializable session file (path excluded — internal detail)
#[derive(Debug, Serialize, Deserialize)]
pub struct SessionFileDto {
    pub session_id: String,
    pub project_name: String,
    pub file_size: u64,
    pub created_at: i64,
    pub modified_at: i64,
    pub has_subagents: bool,
    pub model: Option<String>,
    pub error_count: usize,
    pub first_message: Option<String>,
    pub source_dir: String,
    pub subagent_models: Option<Vec<String>>,
}

/// Cross-session prompt entry
#[derive(Debug, Serialize, Deserialize)]
pub struct PromptEntryDto {
    pub session_id: String,
    pub project_name: String,
    pub prompt_text: String,
    pub prompt_score: u8,
    pub timestamp: Option<i64>,
    pub model: Option<String>,
}

impl From<SessionFile> for SessionFileDto {
    fn from(s: SessionFile) -> Self {
        let subagent_models = s.subagent_models.map(|m| {
            m.split(',').map(str::to_string).collect()
        });
        Self {
            session_id: s.session_id,
            project_name: s.project_name,
            file_size: s.file_size,
            created_at: s.created_at,
            modified_at: s.modified_at,
            has_subagents: s.has_subagents,
            model: s.model,
            error_count: s.error_count,
            first_message: s.first_message,
            source_dir: s.source_dir,
            subagent_models,
        }
    }
}