git-iris 2.0.8

AI-powered Git workflow assistant for smart commits, code reviews, changelogs, and release notes
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

//! Branch memory for Iris Companion
//!
//! Remembers context per branch across sessions.

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

/// Focus state - where the user was last working
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileFocus {
    /// Path to the focused file
    pub path: PathBuf,
    /// Line number in the file
    pub line: usize,
    /// When this focus was recorded
    pub timestamp: DateTime<Utc>,
}

impl FileFocus {
    /// Create a new file focus
    #[must_use]
    pub fn new(path: PathBuf, line: usize) -> Self {
        Self {
            path,
            line,
            timestamp: Utc::now(),
        }
    }
}

/// Per-branch persistent memory
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BranchMemory {
    /// Branch name
    pub branch_name: String,
    /// When this branch was first visited
    pub created_at: DateTime<Utc>,
    /// When this branch was last visited
    pub last_visited: DateTime<Utc>,
    /// Last focused file and line
    pub last_focus: Option<FileFocus>,
    /// User notes for this branch
    pub notes: Vec<String>,
    /// Number of sessions on this branch
    pub session_count: u32,
    /// Number of commits made on this branch (across sessions)
    pub total_commits: u32,
}

impl BranchMemory {
    /// Create new branch memory
    #[must_use]
    pub fn new(branch_name: String) -> Self {
        let now = Utc::now();
        Self {
            branch_name,
            created_at: now,
            last_visited: now,
            last_focus: None,
            notes: Vec::new(),
            session_count: 0,
            total_commits: 0,
        }
    }

    /// Record a new session visit
    pub fn record_visit(&mut self) {
        self.last_visited = Utc::now();
        self.session_count += 1;
    }

    /// Update last focus
    pub fn set_focus(&mut self, path: PathBuf, line: usize) {
        self.last_focus = Some(FileFocus::new(path, line));
    }

    /// Clear focus
    pub fn clear_focus(&mut self) {
        self.last_focus = None;
    }

    /// Add a note
    pub fn add_note(&mut self, note: String) {
        self.notes.push(note);
    }

    /// Record a commit
    pub fn record_commit(&mut self) {
        self.total_commits += 1;
    }

    /// Time since last visit
    #[must_use]
    pub fn time_since_last_visit(&self) -> chrono::Duration {
        Utc::now() - self.last_visited
    }

    /// Check if this is a returning visit (visited before more than 5 minutes ago)
    #[must_use]
    pub fn is_returning_visit(&self) -> bool {
        self.session_count > 0 && self.time_since_last_visit() > chrono::Duration::minutes(5)
    }

    /// Generate a welcome message if returning
    #[must_use]
    pub fn welcome_message(&self) -> Option<String> {
        if !self.is_returning_visit() {
            return None;
        }

        let duration = self.time_since_last_visit();
        let time_str = if duration.num_days() > 0 {
            format!("{} days ago", duration.num_days())
        } else if duration.num_hours() > 0 {
            format!("{} hours ago", duration.num_hours())
        } else {
            format!("{} minutes ago", duration.num_minutes())
        };

        Some(format!(
            "Welcome back to {}! Last here {}",
            self.branch_name, time_str
        ))
    }
}