claude-hindsight 1.0.1

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

//! Search result types and ranking
#![allow(dead_code)]

use crate::storage::SessionFile;
use chrono::{Local, TimeZone};

/// A search result representing a matching session
#[derive(Debug, Clone)]
pub struct SearchResult {
    /// Session ID
    pub session_id: String,

    /// Project name
    pub project_name: String,

    /// File path
    pub file_path: String,

    /// File size in bytes
    pub file_size: u64,

    /// Last modified timestamp (seconds since epoch)
    pub modified_at: i64,

    /// Whether session has subagents
    pub has_subagents: bool,

    /// Relevance score (higher = more relevant)
    /// For Phase 1, this is based on recency
    pub relevance: f64,
}

impl SearchResult {
    /// Create a search result from a session file
    pub fn from_session_file(session: SessionFile) -> Self {
        // Calculate relevance based on recency
        let now = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .map(|d| d.as_secs() as i64)
            .unwrap_or(0);

        let age_seconds = (now - session.modified_at).max(0) as f64;
        let age_days = age_seconds / 86400.0;

        // Exponential decay: score = 100 * e^(-age_days / 7)
        // Sessions from today: ~100, 1 week ago: ~37, 1 month ago: ~2
        let relevance = 100.0 * (-age_days / 7.0).exp();

        SearchResult {
            session_id: session.session_id,
            project_name: session.project_name,
            file_path: session.path.to_string_lossy().to_string(),
            file_size: session.file_size,
            modified_at: session.modified_at,
            has_subagents: session.has_subagents,
            relevance,
        }
    }

    /// Format the modified_at timestamp as a human-readable string
    pub fn format_time(&self) -> String {
        let dt = Local.timestamp_opt(self.modified_at, 0);
        match dt.single() {
            Some(datetime) => {
                let now = Local::now();
                let duration = now.signed_duration_since(datetime);

                if duration.num_days() == 0 {
                    if duration.num_hours() == 0 {
                        if duration.num_minutes() == 0 {
                            "just now".to_string()
                        } else {
                            format!("{}m ago", duration.num_minutes())
                        }
                    } else {
                        format!("{}h ago", duration.num_hours())
                    }
                } else if duration.num_days() == 1 {
                    "1d ago".to_string()
                } else if duration.num_days() < 7 {
                    format!("{}d ago", duration.num_days())
                } else if duration.num_days() < 30 {
                    format!("{}w ago", duration.num_days() / 7)
                } else {
                    datetime.format("%Y-%m-%d").to_string()
                }
            }
            None => "unknown".to_string(),
        }
    }

    /// Format file size as human-readable string
    pub fn format_size(&self) -> String {
        let size = self.file_size as f64;

        if size < 1024.0 {
            format!("{} B", size)
        } else if size < 1024.0 * 1024.0 {
            format!("{:.1} KB", size / 1024.0)
        } else if size < 1024.0 * 1024.0 * 1024.0 {
            format!("{:.1} MB", size / (1024.0 * 1024.0))
        } else {
            format!("{:.1} GB", size / (1024.0 * 1024.0 * 1024.0))
        }
    }
}