palace-rs 0.20.0

Local memory palace for AI assistants — Rust edition
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

//! Lightweight query intent classification for adaptive retrieval.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum QueryIntent {
    Preference,
    Decision,
    HowTo,
    Definition,
    Temporal,
    Unknown,
}

impl QueryIntent {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Preference => "preference",
            Self::Decision => "decision",
            Self::HowTo => "how_to",
            Self::Definition => "definition",
            Self::Temporal => "temporal",
            Self::Unknown => "unknown",
        }
    }
}

pub fn classify(query: &str) -> QueryIntent {
    let q = query.to_lowercase();
    let q = q.split_whitespace().collect::<Vec<_>>().join(" ");

    if contains_any(
        &q,
        &[
            "what do i prefer",
            "what do i like",
            "what is my favorite",
            "my go-to",
            "my preferred",
            "my preference",
            "do i prefer",
            "how do i like",
            "what should i use",
        ],
    ) {
        return QueryIntent::Preference;
    }

    if contains_any(
        &q,
        &[
            "what changed",
            "last session",
            "last time",
            "recent",
            "currently",
            "now",
            "timeline",
            "as of",
            "before",
            "after",
        ],
    ) {
        return QueryIntent::Temporal;
    }

    if contains_any(
        &q,
        &[
            "why did we",
            "why was",
            "why were",
            "why choose",
            "why chose",
            "decision",
            "decided",
            "tradeoff",
            "settled on",
        ],
    ) {
        return QueryIntent::Decision;
    }

    if q.starts_with("how do ")
        || q.starts_with("how should ")
        || q.starts_with("how can ")
        || contains_any(&q, &["command", "run ", "steps", "setup", "install"])
    {
        return QueryIntent::HowTo;
    }

    if q.starts_with("what is ")
        || q.starts_with("what are ")
        || q.starts_with("define ")
        || q.starts_with("where is ")
    {
        return QueryIntent::Definition;
    }

    QueryIntent::Unknown
}

fn contains_any(haystack: &str, needles: &[&str]) -> bool {
    needles.iter().any(|needle| haystack.contains(needle))
}