mindcore 0.2.0

Pluggable, feature-gated memory engine for AI agent applications
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

use chrono::{DateTime, Duration, Utc};

/// Result of query expansion — cleaned text plus any extracted date filters.
#[derive(Debug, Clone)]
pub struct ExpandedQuery {
    /// The query text with temporal expressions removed.
    pub cleaned_text: String,
    /// SQL date-range filters extracted from temporal expressions.
    pub date_filters: Vec<DateFilter>,
}

/// A date range filter extracted from a query.
#[derive(Debug, Clone)]
pub struct DateFilter {
    /// SQL column to filter on.
    pub column: String,
    /// Filter operation.
    pub operator: FilterOp,
}

/// Date filter operation.
#[derive(Debug, Clone)]
pub enum FilterOp {
    /// created_at > datetime
    After(DateTime<Utc>),
    /// created_at < datetime
    Before(DateTime<Utc>),
    /// created_at BETWEEN start AND end
    Between(DateTime<Utc>, DateTime<Utc>),
}

/// Expand temporal expressions in a query into date filters.
///
/// Converts natural language time references like "last week", "yesterday",
/// "last month" into SQL-compatible date range filters.
pub fn expand_query(query: &str, now: DateTime<Utc>) -> ExpandedQuery {
    let lower = query.to_lowercase();
    let mut cleaned = query.to_string();
    let mut filters = Vec::new();

    let patterns: &[(&str, Box<dyn Fn(DateTime<Utc>) -> FilterOp>)] = &[
        ("yesterday", Box::new(|now| {
            FilterOp::Between(now - Duration::days(2), now - Duration::days(1))
        })),
        ("last week", Box::new(|now| {
            FilterOp::After(now - Duration::days(7))
        })),
        ("last month", Box::new(|now| {
            FilterOp::After(now - Duration::days(30))
        })),
        ("last year", Box::new(|now| {
            FilterOp::After(now - Duration::days(365))
        })),
        ("today", Box::new(|now| {
            FilterOp::After(now - Duration::days(1))
        })),
        ("this week", Box::new(|now| {
            FilterOp::After(now - Duration::days(7))
        })),
        ("this month", Box::new(|now| {
            FilterOp::After(now - Duration::days(30))
        })),
        ("recently", Box::new(|now| {
            FilterOp::After(now - Duration::days(7))
        })),
    ];

    for (pattern, make_filter) in patterns {
        if lower.contains(pattern) {
            filters.push(DateFilter {
                column: "created_at".to_string(),
                operator: make_filter(now),
            });
            // Remove the temporal expression from the query
            if let Some(pos) = lower.find(pattern) {
                cleaned = format!(
                    "{} {}",
                    cleaned[..pos].trim(),
                    cleaned[pos + pattern.len()..].trim()
                ).trim().to_string();
            }
            break; // Only apply first match
        }
    }

    ExpandedQuery {
        cleaned_text: cleaned,
        date_filters: filters,
    }
}

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

    #[test]
    fn no_temporal_expression() {
        let now = Utc::now();
        let result = expand_query("authentication error JWT", now);
        assert_eq!(result.cleaned_text, "authentication error JWT");
        assert!(result.date_filters.is_empty());
    }

    #[test]
    fn last_week_expansion() {
        let now = Utc::now();
        let result = expand_query("errors from last week", now);
        assert_eq!(result.cleaned_text, "errors from");
        assert_eq!(result.date_filters.len(), 1);
        assert!(matches!(result.date_filters[0].operator, FilterOp::After(_)));
    }

    #[test]
    fn yesterday_expansion() {
        let now = Utc::now();
        let result = expand_query("what happened yesterday", now);
        assert!(result.date_filters.len() == 1);
        assert!(matches!(result.date_filters[0].operator, FilterOp::Between(_, _)));
    }

    #[test]
    fn last_month_expansion() {
        let now = Utc::now();
        let result = expand_query("decisions last month", now);
        assert_eq!(result.date_filters.len(), 1);
        assert_eq!(result.date_filters[0].column, "created_at");
    }

    #[test]
    fn cleaned_text_usable_for_fts() {
        let now = Utc::now();
        let result = expand_query("build errors from last week in production", now);
        // The cleaned text should still be useful for FTS search
        assert!(result.cleaned_text.contains("build errors"));
        assert!(result.cleaned_text.contains("production"));
        assert!(!result.cleaned_text.contains("last week"));
    }
}