memoryd: Tiers listing; bxctl memory tiers

Co-Authored-By: ornith-1.5-35b-a3b <agent@wntrmute.dev>

crates/memoryd/src/lib.rs

@@ -12,3 +12,4 @@ pub mod recall;
 pub mod review;
 pub mod serve;
 pub mod socket;
+pub mod tiers;

crates/memoryd/src/serve/admin.rs

@@ -62,6 +62,7 @@ impl Memoryd {
                 Some(mirror) => mirror.report(),
                 None => report::NOT_CONFIGURED.to_string(),
             }),
+            MemoryCommand::Tiers => crate::tiers::list(&self.store, now),
         };
         if result.is_ok() && matches!(command, MemoryCommand::Undo | MemoryCommand::Accept) {
             self.mirror(None);

crates/memoryd/src/tiers.rs

@@ -0,0 +1,143 @@
+//! The tiering listing: identity entries and notes with recall-hit counts (M5d spec, 4.4).
+
+use std::collections::{HashMap, HashSet};
+use std::io::ErrorKind;
+
+use bxcore::{MemoryFile, Timestamp};
+use serde::Deserialize;
+
+use crate::files::Store;
+use crate::notes::{self, Kind, Note};
+
+#[derive(Deserialize)]
+struct Logged {
+    time: String,
+    hits: Vec<Hit>,
+}
+
+#[derive(Deserialize)]
+struct Hit {
+    kind: String,
+    session: String,
+    record: i64,
+}
+
+/// How many recall lines named one note, and the latest of those lines' times.
+#[derive(Default)]
+struct Tally {
+    n: u64,
+    last: String,
+}
+
+fn fail(path: &std::path::Path, e: std::io::Error) -> String {
+    format!("{}: {e}", path.display())
+}
+
+fn class_of(note: &Note) -> &'static str {
+    match &note.kind {
+        Kind::Noted { class, .. } => notes::class_name(*class),
+        Kind::Moved(_) | Kind::Dropped(_) => "private",
+    }
+}
+
+fn trust_of(note: &Note) -> &'static str {
+    match &note.kind {
+        Kind::Noted { untrusted, .. } => {
+            if *untrusted {
+                "untrusted"
+            } else {
+                "trusted"
+            }
+        }
+        Kind::Moved(_) | Kind::Dropped(_) => "trusted",
+    }
+}
+
+fn read_notes(store: &Store) -> Result<String, String> {
+    let path = store.path("notes.md");
+    match std::fs::read_to_string(&path) {
+        Ok(text) => Ok(text),
+        Err(e) if e.kind() == ErrorKind::NotFound => Ok(String::new()),
+        Err(e) => Err(fail(&path, e)),
+    }
+}
+
+/// The recall hits per `(session, record)`: how many lines named it and the latest of their times
+/// (M5d spec, section 4.4). A missing `recalls/` is an empty map; a line that does not parse is
+/// skipped, and a line counts once for each note it names.
+fn tally(store: &Store) -> Result<HashMap<(String, i64), Tally>, String> {
+    let dir = store.path("recalls");
+    let files = match std::fs::read_dir(&dir) {
+        Ok(files) => files,
+        Err(e) if e.kind() == ErrorKind::NotFound => return Ok(HashMap::new()),
+        Err(e) => return Err(fail(&dir, e)),
+    };
+    let mut hits: HashMap<(String, i64), Tally> = HashMap::new();
+    for file in files {
+        let file = file.map_err(|e| fail(&dir, e))?;
+        if !file.file_type().map_err(|e| fail(&dir, e))?.is_file() {
+            continue;
+        }
+        let path = file.path();
+        let text = match std::fs::read_to_string(&path) {
+            Ok(text) => text,
+            Err(e) if e.kind() == ErrorKind::NotFound => continue,
+            Err(e) => return Err(fail(&path, e)),
+        };
+        for line in text.lines() {
+            let logged: Logged = match serde_json::from_str(line) {
+                Ok(logged) => logged,
+                Err(_) => continue,
+            };
+            let mut seen: HashSet<(String, i64)> = HashSet::new();
+            for hit in &logged.hits {
+                if hit.kind == "noted" {
+                    seen.insert((hit.session.clone(), hit.record));
+                }
+            }
+            for key in seen {
+                let tally = hits.entry(key).or_default();
+                tally.n += 1;
+                if logged.time > tally.last {
+                    tally.last = logged.time.clone();
+                }
+            }
+        }
+    }
+    Ok(hits)
+}
+
+/// One listing for `bxctl memory tiers` and for the tiering job's user text.
+pub fn list(store: &Store, _now: Timestamp) -> Result<String, String> {
+    let mut out = String::new();
+
+    for file in [MemoryFile::Memory, MemoryFile::User] {
+        for entry in store.entries(file)? {
+            out.push_str(&format!(
+                "identity  {}  hits 0  last -\n  {}\n",
+                file.name(),
+                entry
+            ));
+        }
+    }
+
+    let hits = tally(store)?;
+    for (i, note) in notes::parse(&read_notes(store)?).into_iter().enumerate() {
+        let key = (note.session.clone(), i as i64);
+        let (n, last) = match hits.get(&key) {
+            Some(t) => (t.n, t.last.clone()),
+            None => (0, "-".to_string()),
+        };
+        out.push_str(&format!(
+            "note  session {}  hits {}  last {}  {}  {}\n  {}\n",
+            note.session,
+            n,
+            last,
+            class_of(&note),
+            trust_of(&note),
+            note.text
+        ));
+    }
+
+    Ok(out)
+}