claude-hindsight 2.0.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

//! Hook event API routes

use crate::server::{error::ApiError, AppState};
use crate::storage::{
    HookCompactionEvent, HookLifecycleEvent, HookPermissionEvent, HookSubagentEvent,
    HookToolEvent,
};
use axum::{
    extract::{Query, State},
    Json,
};
use serde::{Deserialize, Serialize};

use super::with_index;

#[derive(Deserialize)]
pub struct SessionEventQuery {
    pub session_id: Option<String>,
    pub event: Option<String>,
    pub limit: Option<usize>,
}

pub async fn get_tool_events(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookToolEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(500);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_tool_events(&sid, q.event.as_deref()),
        None => idx.get_global_tool_events(q.event.as_deref(), limit),
    })
    .await
}

pub async fn get_tool_failures(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookToolEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(100);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_tool_failures(&sid),
        None => idx.get_global_tool_failures(limit),
    })
    .await
}

pub async fn get_subagent_events(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookSubagentEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(500);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_subagent_events(&sid),
        None => idx.get_global_subagent_events(limit),
    })
    .await
}

pub async fn get_compaction_events(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookCompactionEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(500);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_compaction_events(&sid),
        None => idx.get_global_compaction_events(limit),
    })
    .await
}

pub async fn get_permission_events(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookPermissionEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(500);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_permission_events(&sid),
        None => idx.get_global_permission_events(limit),
    })
    .await
}

pub async fn get_lifecycle_events(
    State(_): State<AppState>,
    Query(q): Query<SessionEventQuery>,
) -> Result<Json<Vec<HookLifecycleEvent>>, ApiError> {
    let limit = q.limit.unwrap_or(500);
    with_index(move |idx| match q.session_id {
        Some(sid) => idx.get_lifecycle_events(&sid, q.event.as_deref()),
        None => idx.get_global_lifecycle_events(q.event.as_deref(), limit),
    })
    .await
}

/// Activity summary across all sessions
#[derive(Serialize)]
pub struct HookActivitySummary {
    pub total_tool_events: usize,
    pub total_subagent_events: usize,
    pub total_lifecycle_events: usize,
    pub total_permission_events: usize,
    pub tool_event_counts: Vec<(String, usize)>,
    pub recent_errors: usize,
}

pub async fn get_activity_summary(
    State(_): State<AppState>,
) -> Result<Json<HookActivitySummary>, ApiError> {
    with_index(|idx| idx.get_activity_summary()).await
}