sara-tasks 1.8.0

Sara — folder-aware task manager
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

use anyhow::Result;
use rusqlite::Connection;
use serde_json::json;

use crate::commands::recall::enrich::confidence::match_confidence;
use crate::commands::recall::enrich::hit::{item_hit, recent_hits, record_recalled};
use crate::commands::recall::enrich::patterns::detect_patterns;
use crate::commands::recall::enrich::spread::{
    associative_guide, should_auto_spread, spreading_related,
};
use crate::commands::recall::enrich::stale::mark_stale;
use crate::commands::recall::render::keyword::keyword_json;
use crate::commands::recall::search::collect::collect_hits;
use crate::commands::recall::search::query::{RecallInput, resolve_label_query};
use crate::commands::recall::search::semantic::SemanticOpts;
use crate::infrastructure::config::Config;
use crate::infrastructure::db;

pub fn recall_value(
    conn: &Connection,
    cfg: &Config,
    query: &str,
    tags: &[String],
    projects: &[String],
    files: &[String],
    limit: i64,
    spread: bool,
) -> Result<serde_json::Value> {
    let input = RecallInput::new(query, tags, projects, files);
    let recent = input.is_recent();
    let RecallInput {
        query,
        tags,
        projects,
        files,
    } = input;

    if recent {
        let hits = recent_hits(conn, limit)?;
        record_recalled(conn, &hits);
        let keyword = keyword_json(&hits);
        let patterns = detect_patterns(conn, &hits);
        return Ok(json!({
            "query": query,
            "tag": tags,
            "project": projects,
            "files": files,
            "keyword": keyword,
            "patterns": patterns,
            "associative": [],
            "confidence": "recent",
            "caveat": "Most recent memories (no query or filter given).",
            "recent": true,
        }));
    }

    if let Some(item) = resolve_label_query(conn, query) {
        let _ = db::record_memory_recall(conn, &item.uuid);
        let mut hit = item_hit(conn, item, true);
        mark_stale(conn, std::slice::from_mut(&mut hit));
        let related = spreading_related(conn, std::slice::from_ref(&hit))?;
        let associative = associative_guide(conn, &related);
        let label = hit.label.clone();
        return Ok(json!({
            "query": query,
            "tag": tags,
            "project": projects,
            "files": files,
            "keyword": keyword_json(std::slice::from_ref(&hit)),
            "associative": associative,
            "spread": "label",
            "confidence": "exact",
            "caveat": format!("Resolved memory {label} by label; `associative` maps its cluster."),
            "deep": true,
        }));
    }

    let hits = collect_hits(
        conn,
        query,
        &tags,
        &projects,
        &files,
        limit,
        &SemanticOpts::from_cfg(cfg),
    )?;
    let keyword = keyword_json(&hits);
    let patterns = detect_patterns(conn, &hits);

    let (confidence, caveat) = match_confidence(query, &tags, &hits);

    let auto_spread = !spread && !query.trim().is_empty() && should_auto_spread(&hits);
    let do_spread = spread || auto_spread;
    let associative: Vec<_> = if do_spread {
        let related = spreading_related(conn, &hits)?;
        associative_guide(conn, &related)
    } else {
        vec![]
    };

    Ok(json!({
        "query": query,
        "tag": tags,
        "project": projects,
        "files": files,
        "keyword": keyword,
        "patterns": patterns,
        "associative": associative,
        "spread": if spread { "explicit" } else if auto_spread { "auto" } else { "off" },
        "confidence": confidence,
        "caveat": caveat,
    }))
}