rusty-beads 0.1.0

Git-backed graph issue tracker for AI coding agents - a Rust implementation with context store, dependency tracking, and semantic compaction
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

//! Event type definitions for audit trail.

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::fmt;
use std::str::FromStr;

/// An audit event recording a change to an issue.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Event {
    /// Unique event ID.
    pub id: i64,
    /// Associated issue ID.
    pub issue_id: String,
    /// Type of change.
    pub event_type: EventType,
    /// Who made the change.
    pub actor: String,
    /// Previous value (if applicable).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub old_value: Option<String>,
    /// New value (if applicable).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_value: Option<String>,
    /// Explanatory note.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment: Option<String>,
    /// When the event occurred.
    pub created_at: DateTime<Utc>,
}

impl Event {
    /// Create a new event.
    pub fn new(
        id: i64,
        issue_id: impl Into<String>,
        event_type: EventType,
        actor: impl Into<String>,
    ) -> Self {
        Self {
            id,
            issue_id: issue_id.into(),
            event_type,
            actor: actor.into(),
            old_value: None,
            new_value: None,
            comment: None,
            created_at: Utc::now(),
        }
    }

    /// Set old and new values.
    pub fn with_change(
        mut self,
        old_value: Option<String>,
        new_value: Option<String>,
    ) -> Self {
        self.old_value = old_value;
        self.new_value = new_value;
        self
    }

    /// Set a comment.
    pub fn with_comment(mut self, comment: impl Into<String>) -> Self {
        self.comment = Some(comment.into());
        self
    }
}

/// The type of audit event.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum EventType {
    /// Issue created.
    Created,
    /// General update.
    Updated,
    /// Status transition.
    StatusChanged,
    /// Comment added.
    Commented,
    /// Issue closed.
    Closed,
    /// Issue reopened.
    Reopened,
    /// Dependency created.
    DependencyAdded,
    /// Dependency removed.
    DependencyRemoved,
    /// Label added.
    LabelAdded,
    /// Label removed.
    LabelRemoved,
    /// Issue compacted.
    Compacted,
}

impl EventType {
    /// Returns the string representation for database storage.
    pub fn as_str(&self) -> &'static str {
        match self {
            EventType::Created => "created",
            EventType::Updated => "updated",
            EventType::StatusChanged => "status_changed",
            EventType::Commented => "commented",
            EventType::Closed => "closed",
            EventType::Reopened => "reopened",
            EventType::DependencyAdded => "dependency_added",
            EventType::DependencyRemoved => "dependency_removed",
            EventType::LabelAdded => "label_added",
            EventType::LabelRemoved => "label_removed",
            EventType::Compacted => "compacted",
        }
    }
}

impl fmt::Display for EventType {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl FromStr for EventType {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "created" => Ok(EventType::Created),
            "updated" => Ok(EventType::Updated),
            "status_changed" => Ok(EventType::StatusChanged),
            "commented" => Ok(EventType::Commented),
            "closed" => Ok(EventType::Closed),
            "reopened" => Ok(EventType::Reopened),
            "dependency_added" => Ok(EventType::DependencyAdded),
            "dependency_removed" => Ok(EventType::DependencyRemoved),
            "label_added" => Ok(EventType::LabelAdded),
            "label_removed" => Ok(EventType::LabelRemoved),
            "compacted" => Ok(EventType::Compacted),
            _ => Err(format!("unknown event type: {}", s)),
        }
    }
}