kyle/boxmaker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

memoryd: the memory files, and the block a new session starts with

Browse Source 
Implemented-By: OpenCode session (model recorded in docs/implementer-log.md)
This commit is contained in:
kyle
2026-09-25 16:41:44 -07:00
committed by kyle
parent ad5ce5c6e7
commit f5981338b4
4 changed files with 383 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/memoryd/src/files.rs
+217
View File
@@ -0,0 +1,217 @@
//! The files under `memory/` and the memory block (M5a spec, sections 3 and 4). `memoryd` creates
//! what is missing and never overwrites anything; files are 0600 in a 0700 directory.
use std::fs::{DirBuilder, OpenOptions, Permissions};
use std::io::Write;
use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};
use std::path::{Path, PathBuf};
use proto::MemoryFile;
use crate::check::{Refused, check};
use crate::entries;
/// The most characters `soul.md` may have.
pub const SOUL_LIMIT: usize = 4_000;
/// `n` with commas between thousands: `2,200`.
pub fn grouped(n: usize) -> String {
// `let digits = n.to_string()`. Walk its chars with their index i; before each char where i > 0
// and `(digits.len() - i).is_multiple_of(3)`, push a comma. So 2200 is "2,200" and 999 is
// "999".
let digits = n.to_string();
let mut out = String::with_capacity(digits.len() + digits.len() / 3);
for (i, c) in digits.chars().enumerate() {
if i > 0 && (digits.len() - i).is_multiple_of(3) {
out.push(',');
}
out.push(c);
}
out
}
/// The memory directory.
#[derive(Debug, Clone)]
pub struct Store {
dir: PathBuf,
}
/// The block for a new session, and the identity entries left out of it because they failed the
/// check (for `memoryd` to log).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Block {
pub text: String,
pub left_out: Vec<(MemoryFile, Refused)>,
}
fn fail(path: &Path, e: std::io::Error) -> String {
format!("{}: {e}", path.display())
}
impl Store {
pub fn new(dir: &Path) -> Store {
Store {
dir: dir.to_path_buf(),
}
}
pub fn path(&self, name: &str) -> PathBuf {
self.dir.join(name)
}
/// Create `memory/` (0700) and each missing file (0600): `soul.md` from `starter`, the others
/// empty. Nothing that exists is changed. The error names the path.
pub fn init(&self, starter: &Path) -> Result<(), String> {
// 1. `DirBuilder::new().recursive(true).mode(0o700).create(&self.dir)`, then
// `set_permissions(&self.dir, Permissions::from_mode(0o700))`.
// 2. When `self.path("soul.md")` does not exist: `read_to_string(starter)`, then
// `self.create(&soul, &text)`.
// 3. Each of "memory.md", "user.md", "notes.md" that does not exist: `self.create(&path,
// "")`. Every error through `fail(path, e)`. Nothing that exists is changed. Ok(()).
DirBuilder::new()
.recursive(true)
.mode(0o700)
.create(&self.dir)
.map_err(|e| fail(&self.dir, e))?;
std::fs::set_permissions(&self.dir, Permissions::from_mode(0o700))
.map_err(|e| fail(&self.dir, e))?;
if !self.path("soul.md").exists() {
let text = std::fs::read_to_string(starter).map_err(|e| fail(starter, e))?;
let soul = self.path("soul.md");
self.create(&soul, &text)?;
}
for name in ["memory.md", "user.md", "notes.md"] {
let path = self.path(name);
if !path.exists() {
self.create(&path, "")?;
}
}
Ok(())
}
/// Create `path` at 0600 with `text`; an existing file is an error, never overwritten.
fn create(&self, path: &Path, text: &str) -> Result<(), String> {
// `OpenOptions::new().write(true).create_new(true).mode(0o600).open(path)`, then
// `write_all(text.as_bytes())`. Errors through `fail(path, e)`. create_new makes an
// existing file an error: it is never overwritten.
let mut file = OpenOptions::new()
.write(true)
.create_new(true)
.mode(0o600)
.open(path)
.map_err(|e| fail(path, e))?;
file.write_all(text.as_bytes()).map_err(|e| fail(path, e))?;
Ok(())
}
/// The entries of an identity file.
pub fn entries(&self, file: MemoryFile) -> Result<Vec<String>, String> {
// `read_to_string(self.path(file.name()))` (an error through `fail`), then
// `entries::parse(&text)`.
let path = self.path(file.name());
let text = std::fs::read_to_string(&path).map_err(|e| fail(&path, e))?;
Ok(entries::parse(&text))
}
/// Replace an identity file's entries: written to a temporary file at 0600, then renamed.
pub fn write_entries(&self, file: MemoryFile, list: &[String]) -> Result<(), String> {
// The file is `self.path(file.name())`; the temporary file is
// `self.path(&format!(".{}.tmp", file.name()))`. Remove the temporary file if it is there
// (ignore the result), `self.create(&temp, &entries::render(list))?`, then
// `std::fs::rename(&temp, &path)` (an error through `fail(&path, e)`).
let path = self.path(file.name());
let temp = self.path(&format!(".{}.tmp", file.name()));
let _ = std::fs::remove_file(&temp);
self.create(&temp, &entries::render(list))?;
std::fs::rename(&temp, &path).map_err(|e| fail(&path, e))?;
Ok(())
}
/// Append `text` to a file (0600, created if missing), as one write.
pub fn append(&self, name: &str, text: &str) -> Result<(), String> {
// `OpenOptions::new().append(true).create(true).mode(0o600).open(&path)` for
// `self.path(name)`, then one `write_all(text.as_bytes())`. Errors through `fail`.
let path = self.path(name);
let mut file = OpenOptions::new()
.append(true)
.create(true)
.mode(0o600)
.open(&path)
.map_err(|e| fail(&path, e))?;
file.write_all(text.as_bytes())
.map_err(|e| fail(&path, e))?;
Ok(())
}
/// The block for a new session (M5a spec, section 4). A file over its limit, or unreadable,
/// is an error: no session starts without its memory and no sign of it. Identity entries that
/// fail the check are left out and reported; `soul.md` is the owner's and is not checked.
pub fn block(&self) -> Result<Block, String> {
// 1. Read `self.path("soul.md")` (an error through `fail`) and trim() it. When its
// chars().count() > SOUL_LIMIT: Err(format!("{}: {} characters; its limit is {}",
// path.display(), grouped(chars), grouped(SOUL_LIMIT))).
// 2. `text` starts as format!("# soul.md\n{}", soul), with "(empty)" in place of an empty
// soul.
// 3. For file in [MemoryFile::Memory, MemoryFile::User]: `self.entries(file)?`; `size =
// entries::size(&list)`; when size > file.limit(), the same Err sentence with the path,
// size and limit of that file. Each entry: `check(&entry)` Ok -> kept; Err(refused) ->
// push (file, refused) onto `left_out`. The body is "(empty)" when nothing is kept, else
// `entries::render(&kept).trim_end()`. Append format!("\n\n# {} ({} of {}
// characters)\n{body}", file.name(), grouped(size), grouped(file.limit())) to `text`.
// `size` counts the whole file, entries left out included.
// 4. Ok(Block { text, left_out }).
let soul_path = self.path("soul.md");
let soul = std::fs::read_to_string(&soul_path).map_err(|e| fail(&soul_path, e))?;
let soul = soul.trim();
let chars = soul.chars().count();
if chars > SOUL_LIMIT {
return Err(format!(
"{}: {} characters; its limit is {}",
soul_path.display(),
grouped(chars),
grouped(SOUL_LIMIT)
));
}
let mut text = if soul.is_empty() {
"# soul.md\n(empty)".to_string()
} else {
format!("# soul.md\n{soul}")
};
let mut left_out = Vec::new();
for file in [MemoryFile::Memory, MemoryFile::User] {
let list = self.entries(file)?;
let size = entries::size(&list);
if size > file.limit() {
let path = self.path(file.name());
return Err(format!(
"{}: {} characters; its limit is {}",
path.display(),
grouped(size),
grouped(file.limit())
));
}
let mut kept = Vec::new();
for entry in &list {
match check(entry) {
Ok(()) => kept.push(entry.clone()),
Err(refused) => left_out.push((file, refused)),
}
}
let body = if kept.is_empty() {
"(empty)".to_string()
} else {
entries::render(&kept).trim_end().to_string()
};
text.push_str(&format!(
"\n\n# {} ({} of {} characters)\n{body}",
file.name(),
grouped(size),
grouped(file.limit())
));
}
Ok(Block { text, left_out })
}
}
crates/memoryd/src/lib.rs
+1
View File
@@ -3,4 +3,5 @@
pub mod check;
pub mod config;
pub mod entries;
pub mod files;
pub mod socket;