memoryd: Tiers listing; bxctl memory tiers

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

crates/bxctl/src/cli.rs

@@ -34,7 +34,7 @@ usage: bxctl <command> [options]
   bxctl reindex [--memory-socket PATH]
       Rebuild memoryd's index from the session logs and notes.
 
-  bxctl memory log [N] | undo <id> | pending | accept <id> | reject <id> | sync [--memory-socket PATH]
+  bxctl memory log [N] | undo <id> | pending | accept <id> | reject <id> | sync | tiers [--memory-socket PATH]
       List memory edits, undo the latest edit of a file, or answer writes waiting for review.
       sync shows what memoryd sends to Honcho: counts, and each failed item by its label.
 

crates/bxctl/src/memory.rs

@@ -57,6 +57,7 @@ pub fn parse_memory(args: &[String], home: &Path) -> Result<Command, UsageError>
         ["accept", id] => Ask::Admin(MemoryCommand::Accept, id.to_string()),
         ["reject", id] => Ask::Admin(MemoryCommand::Reject, id.to_string()),
         ["sync"] => Ask::Admin(MemoryCommand::Sync, String::new()),
+        ["tiers"] => Ask::Admin(MemoryCommand::Tiers, String::new()),
         _ => return Err(UsageError),
     };
     Ok(Command::Memory { socket, ask })

crates/bxctl/tests/cli_memory_sync.rs

@@ -61,7 +61,7 @@ fn sync_parses() {
     );
     assert_eq!(parse(&args("memory sync now"), &home), Err(UsageError));
     assert!(
-        USAGE.contains("| reject <id> | sync [--memory-socket PATH]\n"),
+        USAGE.contains("| reject <id> | sync | tiers [--memory-socket PATH]\n"),
         "{USAGE}"
     );
 }

crates/bxctl/tests/cli_memory_tiers.rs

@@ -0,0 +1,86 @@
+//! Tests for `bxctl memory tiers`. Do not edit.
+
+#[path = "support/temp.rs"]
+mod temp;
+use std::os::unix::net::UnixListener;
+use std::path::{Path, PathBuf};
+use std::sync::mpsc;
+use std::time::Duration;
+
+use bxcore::{Envelope, MemoryAdminReply, MemoryCommand, Message, read_frame, write_frame};
+use bxctl::cli::{Command, UsageError, parse};
+use bxctl::memory::{Ask, run};
+
+fn args(line: &str) -> Vec<String> {
+    line.split_whitespace().map(str::to_string).collect()
+}
+
+fn home() -> PathBuf {
+    PathBuf::from("/srv/bx")
+}
+
+fn fake(socket: &Path, answer: Message) -> mpsc::Receiver<Message> {
+    let listener = UnixListener::bind(socket).unwrap();
+    let (tx, rx) = mpsc::channel();
+    std::thread::spawn(move || {
+        let (mut stream, _) = listener.accept().unwrap();
+        let env = read_frame(&mut stream).unwrap();
+        tx.send(env.msg).unwrap();
+        let reply = Envelope {
+            v: 1,
+            id: env.id,
+            r#final: true,
+            msg: answer,
+        };
+        write_frame(&mut stream, &reply).unwrap();
+    });
+    rx
+}
+
+#[test]
+fn memory_tiers_parses() {
+    let h = home();
+    assert_eq!(
+        parse(&args("memory tiers"), &h),
+        Ok(Command::Memory {
+            socket: PathBuf::from("/srv/bx/run/owner-memory/admin.sock"),
+            ask: Ask::Admin(MemoryCommand::Tiers, String::new())
+        })
+    );
+    assert_eq!(
+        parse(&args("memory --memory-socket /r/m.sock tiers"), &h),
+        Ok(Command::Memory {
+            socket: PathBuf::from("/r/m.sock"),
+            ask: Ask::Admin(MemoryCommand::Tiers, String::new())
+        })
+    );
+    assert_eq!(parse(&args("memory tiers extra"), &h), Err(UsageError));
+}
+
+#[test]
+fn memory_tiers_prints_the_reply() {
+    let d = temp::TempDir::new("bx-tiers");
+    let socket = d.join("admin.sock");
+    let listing = "identity  memory.md  hits 0  last -\n  I like tea.\n";
+    let seen = fake(
+        &socket,
+        Message::MemoryAdminReply(MemoryAdminReply {
+            text: listing.to_string(),
+        }),
+    );
+    let mut out = Vec::new();
+    run(
+        &socket,
+        &Ask::Admin(MemoryCommand::Tiers, String::new()),
+        Duration::from_secs(5),
+        &mut out,
+    )
+    .unwrap();
+    assert_eq!(String::from_utf8(out).unwrap(), format!("{listing}\n"));
+    match seen.recv().unwrap() {
+        Message::MemoryAdmin(m) => {
+            assert_eq!((m.command, m.arg.as_str()), (MemoryCommand::Tiers, ""))
+        }
+        other => panic!("{other:?}"),
+    }
+}