dx-driven 0.1.0

Professional AI-assisted development orchestrator with binary-first architecture
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

//! Rule difference calculator

use crate::parser::UnifiedRule;

/// Calculates differences between rule sets
#[derive(Debug, Default)]
pub struct RuleDiffer;

impl RuleDiffer {
    /// Create a new differ
    pub fn new() -> Self {
        Self
    }

    /// Calculate differences between two rule sets
    pub fn diff(&self, old: &[UnifiedRule], new: &[UnifiedRule]) -> RuleDiff {
        let mut diff = RuleDiff::default();

        // Simple comparison based on type and content
        for new_rule in new {
            if !self.contains_similar(old, new_rule) {
                diff.added.push(new_rule.clone());
            }
        }

        for old_rule in old {
            if !self.contains_similar(new, old_rule) {
                diff.removed.push(old_rule.clone());
            }
        }

        diff
    }

    fn contains_similar(&self, rules: &[UnifiedRule], target: &UnifiedRule) -> bool {
        rules.iter().any(|r| self.rules_similar(r, target))
    }

    fn rules_similar(&self, a: &UnifiedRule, b: &UnifiedRule) -> bool {
        match (a, b) {
            (
                UnifiedRule::Standard {
                    description: desc_a,
                    ..
                },
                UnifiedRule::Standard {
                    description: desc_b,
                    ..
                },
            ) => desc_a == desc_b,
            (
                UnifiedRule::Persona { name: name_a, .. },
                UnifiedRule::Persona { name: name_b, .. },
            ) => name_a == name_b,
            (UnifiedRule::Raw { content: a }, UnifiedRule::Raw { content: b }) => a == b,
            _ => false,
        }
    }
}

/// Difference between two rule sets
#[derive(Debug, Default, Clone)]
pub struct RuleDiff {
    /// Rules added in new set
    pub added: Vec<UnifiedRule>,
    /// Rules removed from old set
    pub removed: Vec<UnifiedRule>,
}

impl RuleDiff {
    /// Check if there are any differences
    pub fn has_changes(&self) -> bool {
        !self.added.is_empty() || !self.removed.is_empty()
    }

    /// Get total number of changes
    pub fn change_count(&self) -> usize {
        self.added.len() + self.removed.len()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::format::RuleCategory;

    #[test]
    fn test_diff_identical() {
        let differ = RuleDiffer::new();
        let rules = vec![UnifiedRule::Standard {
            category: RuleCategory::Style,
            priority: 0,
            description: "Test rule".to_string(),
            pattern: None,
        }];

        let diff = differ.diff(&rules, &rules);
        assert!(!diff.has_changes());
    }

    #[test]
    fn test_diff_added() {
        let differ = RuleDiffer::new();
        let old = vec![];
        let new = vec![UnifiedRule::Standard {
            category: RuleCategory::Style,
            priority: 0,
            description: "New rule".to_string(),
            pattern: None,
        }];

        let diff = differ.diff(&old, &new);
        assert!(diff.has_changes());
        assert_eq!(diff.added.len(), 1);
        assert_eq!(diff.removed.len(), 0);
    }

    #[test]
    fn test_diff_removed() {
        let differ = RuleDiffer::new();
        let old = vec![UnifiedRule::Standard {
            category: RuleCategory::Style,
            priority: 0,
            description: "Old rule".to_string(),
            pattern: None,
        }];
        let new = vec![];

        let diff = differ.diff(&old, &new);
        assert!(diff.has_changes());
        assert_eq!(diff.added.len(), 0);
        assert_eq!(diff.removed.len(), 1);
    }
}