303 lines
9.8 KiB
Rust
303 lines
9.8 KiB
Rust
//! Memory: the arguments of `recall` and `memory`, their shape checks, and the messages `memoryd`
|
|
//! exchanges with `loopd`, `brokerd` and `bxctl` (M5a spec, sections 5 and 7). Content rules (an
|
|
//! entry matching the file, a file's limit, the check on characters) are `memoryd`'s.
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::class::DataClass;
|
|
use crate::ids::SessionId;
|
|
use crate::wire::ToolRequest;
|
|
|
|
/// The tool names.
|
|
pub const RECALL: &str = "recall";
|
|
pub const MEMORY: &str = "memory";
|
|
|
|
/// The most characters a `recall` query may have.
|
|
pub const MAX_QUERY: usize = 500;
|
|
/// The most hits a `recall` may ask for, and how many it gets when it does not say.
|
|
pub const MAX_K: u64 = 10;
|
|
pub const DEFAULT_K: u64 = 5;
|
|
/// The most characters a `note` may have.
|
|
pub const MAX_NOTE: usize = 1_000;
|
|
/// The most characters of any other entry: the larger file's limit.
|
|
pub const MAX_ENTRY: usize = 2_200;
|
|
/// The line that separates entries in `memory.md`, `user.md` and `notes.md`.
|
|
pub const SEPARATOR: &str = "§";
|
|
|
|
/// The arguments for `recall`.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct RecallArgs {
|
|
pub query: String,
|
|
#[serde(default = "default_k")]
|
|
pub k: u64,
|
|
}
|
|
|
|
fn default_k() -> u64 {
|
|
DEFAULT_K
|
|
}
|
|
|
|
/// Which identity file an edit is for.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum MemoryFile {
|
|
Memory,
|
|
User,
|
|
}
|
|
|
|
impl MemoryFile {
|
|
/// The file's name under `memory/`.
|
|
pub fn name(self) -> &'static str {
|
|
match self {
|
|
MemoryFile::Memory => "memory.md",
|
|
MemoryFile::User => "user.md",
|
|
}
|
|
}
|
|
|
|
/// The file's limit in characters.
|
|
pub fn limit(self) -> usize {
|
|
match self {
|
|
MemoryFile::Memory => 2_200,
|
|
MemoryFile::User => 1_375,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// The arguments for `memory`: one action. `note` records experience; the others edit identity.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
|
|
pub enum MemoryArgs {
|
|
Add {
|
|
file: MemoryFile,
|
|
text: String,
|
|
},
|
|
Replace {
|
|
file: MemoryFile,
|
|
old: String,
|
|
text: String,
|
|
},
|
|
Remove {
|
|
file: MemoryFile,
|
|
old: String,
|
|
},
|
|
Consolidate {
|
|
file: MemoryFile,
|
|
entries: Vec<ConsolidateEntry>,
|
|
},
|
|
Note {
|
|
text: String,
|
|
},
|
|
}
|
|
|
|
/// One line of a `consolidate`: an existing entry (`old`) with exactly one of `keep`, `text`,
|
|
/// `move`, `drop`; or a new entry (`text` alone).
|
|
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct ConsolidateEntry {
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub old: Option<String>,
|
|
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
|
pub keep: bool,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub text: Option<String>,
|
|
#[serde(default, rename = "move", skip_serializing_if = "std::ops::Not::not")]
|
|
pub moved: bool,
|
|
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
|
|
pub drop: bool,
|
|
}
|
|
|
|
/// What a `consolidate` line does.
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub enum EntryAction {
|
|
Keep(String),
|
|
Rewrite { old: String, text: String },
|
|
Move(String),
|
|
Drop(String),
|
|
New(String),
|
|
}
|
|
|
|
impl ConsolidateEntry {
|
|
/// The line's action, or why it has none.
|
|
pub fn action(&self) -> Result<EntryAction, &'static str> {
|
|
let flags = usize::from(self.keep) + usize::from(self.moved) + usize::from(self.drop);
|
|
match (&self.old, &self.text, flags) {
|
|
(None, Some(text), 0) => Ok(EntryAction::New(text.clone())),
|
|
(None, _, _) => Err("an entry without old must have text and nothing else"),
|
|
(Some(old), Some(text), 0) => Ok(EntryAction::Rewrite {
|
|
old: old.clone(),
|
|
text: text.clone(),
|
|
}),
|
|
(Some(old), None, 1) => {
|
|
if self.keep {
|
|
Ok(EntryAction::Keep(old.clone()))
|
|
} else if self.moved {
|
|
Ok(EntryAction::Move(old.clone()))
|
|
} else {
|
|
Ok(EntryAction::Drop(old.clone()))
|
|
}
|
|
}
|
|
(Some(_), _, _) => {
|
|
Err("an entry with old must have exactly one of keep, text, move or drop")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Why an entry's text is not a well-formed entry: empty once trimmed, too long, or holding a line
|
|
/// that is only the separator. `None` when it is fine.
|
|
pub fn entry_problem(text: &str, max: usize) -> Option<String> {
|
|
if text.trim().is_empty() {
|
|
return Some("an entry cannot be empty".to_string());
|
|
}
|
|
let chars = text.chars().count();
|
|
if chars > max {
|
|
return Some(format!(
|
|
"an entry has at most {max} characters; this has {chars}"
|
|
));
|
|
}
|
|
for line in text.lines() {
|
|
if line.trim() == SEPARATOR {
|
|
return Some(format!(
|
|
"an entry cannot hold a line that is only {SEPARATOR}"
|
|
));
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
impl RecallArgs {
|
|
/// The shape rules of `recall` (M5a spec, section 5).
|
|
pub fn check(&self) -> Result<(), String> {
|
|
if self.query.trim().is_empty() || self.query.chars().count() > MAX_QUERY {
|
|
return Err(format!("query must have 1 to {MAX_QUERY} characters"));
|
|
}
|
|
if self.k == 0 || self.k > MAX_K {
|
|
return Err(format!("k must be 1 to {MAX_K}"));
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl MemoryArgs {
|
|
/// The shape rules of `memory` (M5a spec, section 5): every text is a well-formed entry, and
|
|
/// every `consolidate` line has one action and the list is not empty.
|
|
pub fn check(&self) -> Result<(), String> {
|
|
match self {
|
|
MemoryArgs::Add { text, .. } => {
|
|
if let Some(problem) = entry_problem(text, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
MemoryArgs::Replace { old, text, .. } => {
|
|
if let Some(problem) = entry_problem(old, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
if let Some(problem) = entry_problem(text, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
MemoryArgs::Remove { old, .. } => {
|
|
if let Some(problem) = entry_problem(old, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
MemoryArgs::Note { text } => {
|
|
if let Some(problem) = entry_problem(text, MAX_NOTE) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
MemoryArgs::Consolidate { entries, .. } => {
|
|
if entries.is_empty() {
|
|
return Err("consolidate needs every entry of the file".to_string());
|
|
}
|
|
for line in entries {
|
|
let action = line.action().map_err(|problem| problem.to_string())?;
|
|
match action {
|
|
EntryAction::Keep(old)
|
|
| EntryAction::Move(old)
|
|
| EntryAction::Drop(old) => {
|
|
if let Some(problem) = entry_problem(&old, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
EntryAction::Rewrite { old, text } => {
|
|
if let Some(problem) = entry_problem(&old, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
if let Some(problem) = entry_problem(&text, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
EntryAction::New(text) => {
|
|
if let Some(problem) = entry_problem(&text, MAX_ENTRY) {
|
|
return Err(problem);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
/// `memoryd` → `loopd`: the memory block for a new session's baseline.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct MemoryBlockReply {
|
|
pub text: String,
|
|
}
|
|
|
|
/// `loopd` → `memoryd`: this session's log has new records.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct SessionUpdated {
|
|
pub session: SessionId,
|
|
}
|
|
|
|
/// `brokerd` → `memoryd`: a decided `recall` or `memory` call, with the session's state when it
|
|
/// was decided.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct MemoryCall {
|
|
pub request: ToolRequest,
|
|
pub taint: DataClass,
|
|
pub untrusted: bool,
|
|
}
|
|
|
|
/// `memoryd` → `bxctl`: what a reindex read.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Reindexed {
|
|
pub logs: u64,
|
|
pub records: u64,
|
|
pub notes: u64,
|
|
}
|
|
|
|
/// The owner's memory commands (M5a spec, section 10).
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum MemoryCommand {
|
|
Log,
|
|
Undo,
|
|
Pending,
|
|
Accept,
|
|
Reject,
|
|
}
|
|
|
|
/// `bxctl` → `memoryd`: one command; `arg` is the count for `log`, the edit or pending id for
|
|
/// `undo`, `accept` and `reject`, and empty otherwise.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct MemoryAdmin {
|
|
pub command: MemoryCommand,
|
|
pub arg: String,
|
|
}
|
|
|
|
/// `memoryd` → `bxctl`: the text to print.
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct MemoryAdminReply {
|
|
pub text: String,
|
|
}
|