#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![allow(unknown_lints)]
#![allow(clippy::chunks_exact_to_as_chunks)]
#[cfg(feature = "embed-candle")]
pub mod builtin;
mod cache;
mod crypto;
mod embed;
mod embed_cmd;
mod error;
mod format;
mod freelist;
pub mod guide;
mod ident;
mod index;
pub mod keys;
mod keyslot;
pub mod mcp;
mod memory;
mod pager;
pub mod redact;
mod result_cache;
mod session;
mod shared;
mod store;
mod text;
mod transcript;
mod veccol;
mod wal;
#[cfg(feature = "embed-candle")]
pub use builtin::BuiltinEmbedder;
pub use crypto::{KdfParams, SecretKind};
pub use embed::{Embedder, EmbedderIdentity};
pub use embed_cmd::{EmbedCmd, DEFAULT_EMBED_TIMEOUT};
pub use error::{MnemoError, Result};
pub use index::{IndexConfig, IndexInfo};
pub use memory::{
status as essence_status, CommitBatch, CommitReport, EssenceOp, EssenceOpKind, EssenceScope,
EssenceSection, ExportedTurn, Filter, FilterTerm, IngestReport, KeyScope, KeyedMemory, Memory,
MemoryPatch, MemoryType, Metric, Scope, ScoreWeights, ThreadTurn, TurnPolicy, WriteOutcome,
CONTINUATION_TIMELINE_ENTRIES, ESSENCE_DEFAULT_RENDER_BYTES, ESSENCE_SECTION_MAX_BYTES,
ESSENCE_TIMELINE_MAX_BYTES, ESSENCE_TRANSITIONS, FINDING_TRANSITIONS, MNEMO_META_CONTINUES,
MNEMO_META_INVALID_AT, MNEMO_META_KEY, MNEMO_META_KIND, MNEMO_META_KIND_ESSENCE,
MNEMO_META_KIND_THREAD_LINK, MNEMO_META_KIND_TURN, MNEMO_META_LENGTH, MNEMO_META_MARKERS_ONLY,
MNEMO_META_NS, MNEMO_META_PART, MNEMO_META_REFS, MNEMO_META_ROLE, MNEMO_META_SECTION,
MNEMO_META_SEQ, MNEMO_META_SHA256, MNEMO_META_STATUS, MNEMO_META_STATUS_HISTORY,
MNEMO_META_SUPERSEDED_BY, MNEMO_META_SUPERSEDES, MNEMO_META_THREAD, MNEMO_META_TURN_ID,
MNEMO_META_UPDATED_AT, TASK_TRANSITIONS, THREAD_TOOL_RESULT_TRUNCATE_BYTES,
THREAD_TURN_CHUNK_BYTES,
};
pub use result_cache::{
CacheBudget, CacheFlushPolicy, CachePutOpts, CacheStats, CachedValue, SemanticCachePutOpts,
DEFAULT_BATCH_MAX_AGE, DEFAULT_BATCH_MAX_DIRTY, DEFAULT_MAX_BYTES, DEFAULT_MAX_ENTRIES,
DEFAULT_SEMANTIC_THRESHOLD,
};
pub use session::{Role, Session, Turn};
pub use shared::{CancelToken, SharedOptions};
#[doc(hidden)]
#[cfg(feature = "dev-hooks")]
pub use store::BudgetReport;
pub use store::{
CloseError, CompactReport, Mnemo, MnemoConfig, RecallMode, RecallRequest, RecallResponse,
RecallResult, ReembedReport, SharedMnemo, SnapshotInfo, Stats, StatsSummary, VerifyReport,
DEFAULT_KEYWORD_WEIGHT, DEFAULT_TEXT_KEYWORD_WEIGHT, DEFAULT_TURN_COMPRESS_AFTER_SECS,
DEFAULT_VECTOR_CACHE_BUDGET, INDEX_PERSIST_EVERY_CHANGES, INDEX_PERSIST_EVERY_COMMITS,
V9_ANN_MIN_FACTS, V9_RERANK_PER_HIT,
};
pub use text::{KeywordIndex, KeywordTokenizer};
pub use transcript::{
read_transcript, read_transcript_with, ToolResults, TranscriptFormat, TranscriptOptions,
};
pub use ulid::Ulid;
mod fsync_counter {
use std::cell::Cell;
thread_local! {
static COUNT: Cell<u64> = const { Cell::new(0) };
}
pub(crate) fn bump() {
COUNT.with(|c| c.set(c.get().wrapping_add(1)));
}
pub(crate) fn count() -> u64 {
COUNT.with(|c| c.get())
}
}
pub(crate) use fsync_counter::{bump as bump_fsync, count as fsync_count};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BuildInfo {
pub version: &'static str,
pub target: &'static str,
pub aes_backend: &'static str,
pub polyval_backend: &'static str,
}
pub fn build_info() -> BuildInfo {
BuildInfo {
version: env!("CARGO_PKG_VERSION"),
target: TARGET_TRIPLE,
aes_backend: aes_backend_name(),
polyval_backend: polyval_backend_name(),
}
}
const TARGET_TRIPLE: &str = {
if cfg!(all(target_arch = "aarch64", target_os = "macos")) {
"aarch64-apple-darwin"
} else if cfg!(all(target_arch = "aarch64", target_os = "linux")) {
"aarch64-unknown-linux-gnu"
} else if cfg!(all(target_arch = "x86_64", target_os = "macos")) {
"x86_64-apple-darwin"
} else if cfg!(all(target_arch = "x86_64", target_os = "linux")) {
"x86_64-unknown-linux-gnu"
} else if cfg!(all(target_arch = "x86_64", target_os = "windows")) {
"x86_64-pc-windows-msvc"
} else {
"unknown"
}
};
const fn aes_backend_name() -> &'static str {
if cfg!(aes_armv8) {
"armv8 hardware"
} else if cfg!(target_arch = "aarch64") {
"armv8 software (constant-time fallback)"
} else if cfg!(target_arch = "x86_64") {
"x86_64 AES-NI (runtime detect)"
} else {
"portable software"
}
}
const fn polyval_backend_name() -> &'static str {
if cfg!(polyval_armv8) {
"armv8 PMULL hardware"
} else if cfg!(target_arch = "aarch64") {
"armv8 software (constant-time fallback)"
} else if cfg!(target_arch = "x86_64") {
"x86_64 CLMUL (runtime detect)"
} else {
"portable software"
}
}
#[cfg(feature = "dev-hooks")]
#[doc(hidden)]
pub fn __fsync_count() -> u64 {
fsync_count()
}
#[cfg(any(test, feature = "failpoints"))]
#[doc(hidden)]
pub mod __failpoints {
pub fn set_writes_until_fail(n: i64) {
crate::pager::failpoints::set_writes_until_fail(n)
}
pub fn set_writes_until_fail_n(n: i64, count: u32) {
crate::pager::failpoints::set_writes_until_fail_n(n, count)
}
pub fn set_writes_failing(ns: &[u64]) {
crate::pager::failpoints::set_writes_failing(ns)
}
pub fn writes_seen() -> u64 {
crate::pager::failpoints::writes_seen()
}
thread_local! {
static AFTER_SHARED_COMMIT: std::cell::RefCell<Option<Box<dyn FnOnce()>>> =
const { std::cell::RefCell::new(None) };
static BEFORE_SHARED_COMMIT: std::cell::RefCell<Option<Box<dyn FnOnce()>>> =
const { std::cell::RefCell::new(None) };
}
pub fn before_next_shared_commit(f: impl FnOnce() + 'static) {
BEFORE_SHARED_COMMIT.with(|c| *c.borrow_mut() = Some(Box::new(f)));
}
pub(crate) fn run_before_shared_commit() {
if let Some(f) = BEFORE_SHARED_COMMIT.with(|c| c.borrow_mut().take()) {
f();
}
}
pub fn after_next_shared_commit(f: impl FnOnce() + 'static) {
AFTER_SHARED_COMMIT.with(|c| *c.borrow_mut() = Some(Box::new(f)));
}
pub(crate) fn run_after_shared_commit() {
if let Some(f) = AFTER_SHARED_COMMIT.with(|c| c.borrow_mut().take()) {
f();
}
}
thread_local! {
static NEXT_TEMP_NAME: std::cell::RefCell<Option<std::path::PathBuf>> =
const { std::cell::RefCell::new(None) };
}
pub fn set_next_temp_name(path: impl Into<std::path::PathBuf>) {
NEXT_TEMP_NAME.with(|n| *n.borrow_mut() = Some(path.into()));
}
pub(crate) fn take_next_temp_name() -> Option<std::path::PathBuf> {
NEXT_TEMP_NAME.with(|n| n.borrow_mut().take())
}
thread_local! {
static SHARED_MAIN_TRIES: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
static SHARED_REPLACED: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
pub fn shared_main_tries() -> u64 {
SHARED_MAIN_TRIES.with(|c| c.get())
}
pub(crate) fn count_shared_main_try() {
SHARED_MAIN_TRIES.with(|c| c.set(c.get() + 1));
}
pub fn set_shared_replaced(n: u64) {
SHARED_REPLACED.with(|c| c.set(n));
}
thread_local! {
static EUID_OVERRIDE: std::cell::Cell<Option<u32>> = const { std::cell::Cell::new(None) };
}
pub fn set_euid_override(uid: Option<u32>) {
EUID_OVERRIDE.with(|c| c.set(uid));
}
#[cfg(unix)]
pub(crate) fn euid_override() -> Option<u32> {
EUID_OVERRIDE.with(|c| c.get())
}
thread_local! {
static PATH_CHECK_FAILURES: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
pub fn set_path_check_failures(n: u64) {
PATH_CHECK_FAILURES.with(|c| c.set(n));
}
pub fn path_check_failures_left() -> u64 {
PATH_CHECK_FAILURES.with(|c| c.get())
}
pub(crate) fn take_path_check_failure() -> bool {
PATH_CHECK_FAILURES.with(|c| {
let n = c.get();
if n > 0 {
c.set(n - 1);
}
n > 0
})
}
pub(crate) fn take_shared_replaced() -> bool {
SHARED_REPLACED.with(|c| {
let n = c.get();
if n > 0 {
c.set(n - 1);
}
n > 0
})
}
}
#[cfg(any(test, feature = "failpoints"))]
#[doc(hidden)]
pub mod __shared {
use std::path::{Path, PathBuf};
use crate::shared::{BrainLocks, Call, Held, LockKind};
use crate::{Result, SharedOptions};
pub const SUFFIX: &str = crate::shared::testing::SUFFIX;
pub const INTENT: &str = crate::shared::testing::INTENT;
pub const LOCK_INFO: &str = crate::shared::testing::LOCK_INFO;
pub const VALVE: &str = crate::shared::testing::VALVE;
pub const WINDOWS_OLD_RENAME: bool = crate::shared::WINDOWS_OLD_RENAME;
pub fn sidecar_path(brain: &Path) -> PathBuf {
crate::shared::testing::sidecar_path(brain)
}
pub fn classify_synced(path: &Path, home: &Path) -> Option<String> {
crate::shared::testing::classify_synced(path, home)
}
pub fn linux_fs_allowed(magic: u32) -> bool {
crate::shared::testing::linux_fs_allowed(magic)
}
#[derive(Debug)]
pub struct Locks(BrainLocks);
impl Locks {
pub fn new(path: &Path, opts: &SharedOptions) -> Result<Self> {
BrainLocks::new(path, opts).map(Locks)
}
pub fn for_plain(path: &Path, opts: &SharedOptions) -> Result<Self> {
BrainLocks::for_plain(path, opts).map(Locks)
}
pub fn valve_takes(&self) -> u64 {
self.0.valve_takes()
}
pub fn shared(&mut self, opts: &SharedOptions) -> Result<Lock> {
let mut call = Call::new(opts.deadline, opts.cancel.as_ref());
self.0.acquire(LockKind::Shared, &mut call).map(Lock)
}
pub fn exclusive(&mut self, opts: &SharedOptions) -> Result<Lock> {
let mut call = Call::new(opts.deadline, opts.cancel.as_ref());
self.0.acquire(LockKind::Exclusive, &mut call).map(Lock)
}
pub fn has_sidecar(&self) -> bool {
self.0.has_sidecar()
}
pub fn sidecar_path(&self) -> Option<PathBuf> {
self.0.sidecar_path().map(Path::to_path_buf)
}
pub fn notices(&self) -> Vec<String> {
self.0.notices().to_vec()
}
}
pub struct Lock(Held);
impl Lock {
pub fn announce(&mut self, op: &str) {
self.0.announce(op)
}
pub fn file(&self) -> &std::fs::File {
self.0.file()
}
}
}
#[doc(hidden)]
pub mod __wal {
pub const PAGE_SIZE: usize = crate::format::PAGE_SIZE;
pub type Frame = (u64, Vec<u8>);
pub fn txn_byte_len(n: usize) -> u64 {
crate::wal::txn_byte_len(n, PAGE_SIZE)
}
pub fn commit(
file: &mut std::fs::File,
wal_pages: u64,
txn_id: u64,
frames: &[Frame],
) -> crate::Result<()> {
crate::wal::commit(file, 0, wal_pages, txn_id, frames)
}
pub fn recover(
file: &mut std::fs::File,
wal_pages: u64,
wal_seq: u64,
) -> crate::Result<Option<Vec<Frame>>> {
crate::wal::recover(file, 0, wal_pages, wal_seq)
}
}
#[doc(hidden)]
pub mod __fuzz {
pub fn parse_header(bytes: &[u8]) -> crate::Result<()> {
crate::format::Header::from_page(bytes).map(|_| ())
}
pub fn wal_recover_bytes(region: &[u8], wal_seq: u64) -> crate::Result<()> {
crate::wal::recover_bytes(region, wal_seq).map(|_| ())
}
pub fn decode_memory(bytes: &[u8]) -> crate::Result<()> {
rmp_serde::from_slice::<crate::Memory>(bytes)
.map(|_| ())
.map_err(|e| crate::MnemoError::Serialize(e.to_string()))
}
pub fn decode_v9_memory(bytes: &[u8]) -> crate::Result<()> {
let plain = crate::store::plain_record(bytes)?;
rmp_serde::from_slice::<crate::Memory>(&plain)
.map(|_| ())
.map_err(|e| crate::MnemoError::Serialize(e.to_string()))
}
pub fn decode_cache_entry(bytes: &[u8]) -> crate::Result<()> {
rmp_serde::from_slice::<crate::result_cache::CacheEntry>(bytes)
.map(|_| ())
.map_err(|e| crate::MnemoError::Serialize(e.to_string()))
}
pub fn decode_cache_directory(bytes: &[u8]) -> crate::Result<()> {
rmp_serde::from_slice::<Vec<crate::result_cache::CacheDirectoryEntry>>(bytes)
.map(|_| ())
.map_err(|e| crate::MnemoError::Serialize(e.to_string()))
}
pub fn parse_mcp_request_line(line: &str) -> Result<(), String> {
crate::mcp::__fuzz_parse_request_line(line)
}
}