inkhaven 2.4.0

Inkhaven — TUI literary work editor for Typst books
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

//! GRAPHMIND GM-P2 — fact-add edge proposals. Propose typed stance edges
//! (`Judged`, advisory) from a fact to the facts it relates to — the confront
//! machinery pointed at your own corpus — for you to triage (`graph pending`, or
//! the confront `P`/`d` keys). Explicit + on-demand (`inkhaven graph link
//! <node>`), so it never slows a fact insert or spends tokens by surprise.

use std::collections::HashMap;

use uuid::Uuid;

use crate::config::Config;
use crate::storage::edge_store::{Edge, EdgeOrigin, EndpointRef};
use crate::store::hierarchy::Hierarchy;
use crate::store::Store;

use super::contradiction::{self, Evidence, Relation};

/// Map graded relations (from the `/relate` judge, each keyed by its evidence
/// label) to `Judged` stance edges from the new fact to each related fact node.
/// `Silent` relations, self-links, and labels that don't resolve to a node are
/// skipped. Unlike confront's `Extern::Evidence` edges, the far endpoint here is
/// a real fact **node**. Pure.
pub(super) fn propose_stance_edges(
    new_fact: Uuid,
    relations: &[Relation],
    neighbor_by_label: &HashMap<String, Uuid>,
) -> Vec<Edge> {
    let mut edges = Vec::new();
    for r in relations {
        let Some(kind) = contradiction::stance_to_edge_kind(r.stance) else {
            continue;
        };
        let Some(&dst) = neighbor_by_label.get(&r.label) else {
            continue;
        };
        if dst == new_fact {
            continue;
        }
        let mut e = Edge::new(
            EndpointRef::Node(new_fact),
            kind,
            EndpointRef::Node(dst),
            EdgeOrigin::Judged,
        );
        if !r.reason.is_empty() {
            e = e.with_reason(r.reason.clone());
        }
        edges.push(e);
    }
    edges
}

/// Propose + persist stance edges from a fact to its nearest related facts:
/// retrieve the neighbours (book-RAG over the Facts book), grade each relation
/// with the `/relate` judge, and persist the non-`Silent` ones as `Judged`
/// edges. Returns the number proposed. Best-effort — an LLM/IO failure yields 0.
pub(crate) fn link_fact(
    store: &Store,
    hierarchy: &Hierarchy,
    cfg: &Config,
    ai: &crate::ai::AiClient,
    model: &str,
    facts_book_id: Uuid,
    new_id: Uuid,
    body: &str,
    lang: &str,
) -> usize {
    let Ok(passages) =
        crate::book_rag::retrieval::retrieve(store, hierarchy, &cfg.book_rag, facts_book_id, body)
    else {
        return 0;
    };
    let mut evidence: Vec<Evidence> = Vec::new();
    let mut by_label: HashMap<String, Uuid> = HashMap::new();
    for p in passages.into_iter().filter(|p| p.id != new_id).take(6) {
        by_label.insert(p.breadcrumb.clone(), p.id);
        evidence.push(Evidence { label: p.breadcrumb, body: p.body });
    }
    if evidence.is_empty() {
        return 0;
    }
    let system = contradiction::relate_system(lang);
    let user = contradiction::relate_user(body, &evidence);
    let Ok(reply) = crate::ai::stream::collect_blocking(
        ai.client.clone(),
        model.to_string(),
        Some(system),
        user,
    ) else {
        return 0;
    };
    let relations = contradiction::parse_relations(&reply, &evidence);
    let edges = propose_stance_edges(new_id, &relations, &by_label);
    if edges.is_empty() {
        return 0;
    }
    let _ = store.add_edges(&edges);
    edges.len()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::research::contradiction::Stance;
    use crate::storage::edge_store::{EdgeKind, ExternRef};

    fn rel(stance: Stance, label: &str, reason: &str) -> Relation {
        Relation { label: label.into(), stance, reason: reason.into() }
    }

    #[test]
    fn proposes_judged_node_to_node_stance_edges() {
        let (new_fact, a, b) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
        let mut by_label = HashMap::new();
        by_label.insert("fact: A".to_string(), a);
        by_label.insert("fact: B".to_string(), b);
        let relations = vec![
            rel(Stance::Contradicts, "fact: A", "opposes it"),
            rel(Stance::Silent, "fact: B", "nothing relevant"), // skipped
            rel(Stance::Agrees, "fact: unknown", "backs it"),   // no node → skipped
        ];
        let edges = propose_stance_edges(new_fact, &relations, &by_label);
        assert_eq!(edges.len(), 1, "Silent + unresolved-label relations are dropped");
        let e = &edges[0];
        assert_eq!(e.kind, EdgeKind::Contradicts);
        assert_eq!(e.src, EndpointRef::Node(new_fact));
        assert_eq!(e.dst, EndpointRef::Node(a), "far endpoint is a real fact node");
        assert_eq!(e.origin, EdgeOrigin::Judged);
        assert_eq!(e.reason.as_deref(), Some("opposes it"));
        assert!(!matches!(e.dst, EndpointRef::Extern(ExternRef::Evidence { .. })));
    }
}