memnite_core/

conflicts.rs

use std::collections::{BTreeMap, HashSet};

use crate::event::{Event, EventKind, MemoryData};

/// A cross-writer lost-field conflict: a value some writer set for `field` of
/// `memory_id` did not survive into the projected winner (it lost to a different
/// writer). Heuristic — lamport is a total order, not causal — so this can
/// over-report a deliberately-superseded edit. Advisory; never blocks.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Conflict {
    pub memory_id: String,
    pub field: String,
    pub lost_writer: String,
    pub lost_lamport: u64,
    pub winning_writer: String,
    pub winning_lamport: u64,
}

const FIELDS: [&str; 8] = [
    "title",
    "body",
    "mem_type",
    "scope",
    "project",
    "topic_key",
    "anchors",
    "tags",
];

fn writer(ev: &Event) -> String {
    format!("{}@{}", ev.engine, ev.machine)
}

fn content_data(ev: &Event) -> bool {
    matches!(
        ev.kind,
        EventKind::MemoryAdded(_) | EventKind::MemoryUpdated(_) | EventKind::MemoryPatched(_)
    )
}

/// Per-field view of one content event: for each of the 8 fields, whether the
/// event touched it and (if so) its string value. `MemoryAdded`/`MemoryUpdated`
/// touch every field (full snapshot). `MemoryPatched` touches only `Some` fields.
fn touched_values(ev: &Event) -> [(bool, String); 8] {
    match &ev.kind {
        EventKind::MemoryAdded(d) | EventKind::MemoryUpdated(d) => {
            let v = full_field_values(d);
            std::array::from_fn(|i| (true, v[i].clone()))
        }
        EventKind::MemoryPatched(p) => [
            opt(&p.title),
            opt(&p.body),
            opt(&p.mem_type),
            p.scope
                .as_ref()
                .map_or((false, String::new()), |s| (true, format!("{s:?}"))),
            opt(&p.project),
            p.topic_key
                .as_ref()
                .map_or((false, String::new()), |s| (true, format!("{:?}", Some(s)))),
            p.anchors
                .as_ref()
                .map_or((false, String::new()), |a| (true, format!("{a:?}"))),
            p.tags
                .as_ref()
                .map_or((false, String::new()), |t| (true, format!("{t:?}"))),
        ],
        _ => std::array::from_fn(|_| (false, String::new())),
    }
}

fn opt(v: &Option<String>) -> (bool, String) {
    match v {
        Some(s) => (true, s.clone()),
        None => (false, String::new()),
    }
}

/// Full field values for a whole-snapshot event (index matches `FIELDS`).
fn full_field_values(d: &MemoryData) -> [String; 8] {
    [
        d.title.clone(),
        d.body.clone(),
        d.mem_type.clone(),
        format!("{:?}", d.scope),
        d.project.clone(),
        format!("{:?}", d.topic_key),
        format!("{:?}", d.anchors),
        format!("{:?}", d.tags),
    ]
}

/// Detect cross-writer lost-field conflicts across the event log. Pure, total,
/// deterministic (memory_ids sorted; fields in fixed order). Skips memories with
/// a terminal `MemoryDeleted`.
pub fn detect_conflicts(events: &[Event]) -> Vec<Conflict> {
    let deleted: HashSet<&str> = events
        .iter()
        .filter(|e| matches!(e.kind, EventKind::MemoryDeleted))
        .map(|e| e.memory_id.as_str())
        .collect();

    let mut by_mem: BTreeMap<&str, Vec<&Event>> = BTreeMap::new();
    for ev in events {
        if content_data(ev) && !deleted.contains(ev.memory_id.as_str()) {
            by_mem.entry(ev.memory_id.as_str()).or_default().push(ev);
        }
    }

    let mut out = Vec::new();
    for (mem_id, mut evs) in by_mem {
        if evs.len() < 2 {
            continue;
        }
        evs.sort_by(|a, b| {
            a.lamport
                .cmp(&b.lamport)
                .then_with(|| a.event_id.cmp(&b.event_id))
        });

        let tvals: Vec<[(bool, String); 8]> = evs.iter().map(|e| touched_values(e)).collect();

        for fi in 0..FIELDS.len() {
            // Walk in order, carrying the last-seen value of this field. A setter
            // is an event that TOUCHED the field AND changed its value. The first
            // observed value seeds `prev` as a baseline (not a competing setter).
            // The field's winner is the LAST event that touched it (which may not
            // be the global last event, since a delta can touch other fields).
            let mut prev: Option<String> = None;
            let mut setters: Vec<(&Event, String)> = Vec::new();
            let mut field_winner: Option<&Event> = None;
            for (i, ev_i) in evs.iter().enumerate() {
                let (touched, val) = &tvals[i][fi];
                if *touched {
                    let changed = prev.as_deref() != Some(val.as_str());
                    if changed && prev.is_some() {
                        setters.push((ev_i, val.clone()));
                    }
                    prev = Some(val.clone());
                    field_winner = Some(ev_i);
                }
            }
            let winner_val = prev.unwrap_or_default();
            let winner_ev = match field_winner {
                Some(e) => e,
                None => continue,
            };
            let winner_writer = writer(winner_ev);

            let distinct: HashSet<String> = setters.iter().map(|(e, _)| writer(e)).collect();
            if distinct.len() < 2 {
                continue;
            }
            let lost = setters
                .iter()
                .rev()
                .find(|(e, v)| writer(e) != winner_writer && *v != winner_val);
            if let Some((lose_ev, _)) = lost {
                out.push(Conflict {
                    memory_id: mem_id.to_string(),
                    field: FIELDS[fi].to_string(),
                    lost_writer: writer(lose_ev),
                    lost_lamport: lose_ev.lamport,
                    winning_writer: winner_writer.clone(),
                    winning_lamport: winner_ev.lamport,
                });
            }
        }
    }
    out
}