use anyhow::Result;
use rusqlite::{params, Connection, OptionalExtension};
use std::collections::BTreeSet;
const MIN_SEMANTIC_SLOT_TERMS: usize = 4;
const MAX_SEMANTIC_SLOT_TERMS: usize = 6;
const CJK_SEMANTIC_SLOT_TERMS: &[(&str, &str)] = &[
("三元组", "trigram"),
("中文", "cjk"),
("全文搜索", "fts5"),
("分词器", "tokenizer"),
("分词", "tokenizer"),
("搜索", "search"),
("检索", "retrieval"),
("查询", "query"),
("数据库", "database"),
("加密", "encryption"),
("接口", "api"),
("钩子", "hook"),
("适配器", "adapter"),
("评测", "eval"),
("基准测试", "benchmark"),
("压缩", "compression"),
("超时", "timeout"),
("工作线程", "worker"),
("记忆", "memory"),
("捕获", "capture"),
("提取", "extraction"),
("事实", "fact"),
("知识图谱", "knowledge-graph"),
("提示词", "prompt"),
("发布", "publish"),
("部署", "deploy"),
("配置", "config"),
("端口", "port"),
("会话", "session"),
("作用域", "scope"),
("全局", "global"),
("摘要", "summary"),
("格式", "format"),
("服务器", "server"),
("服务", "service"),
("性能", "performance"),
("上下文", "context"),
("竞品", "competitive"),
("对比", "comparison"),
("偏好", "preference"),
("共享", "sharing"),
("架构", "architecture"),
("设计", "design"),
("规则", "rule"),
("跨项目", "cross-project"),
("候选", "candidate"),
("声明", "declaration"),
("执行", "execution"),
("验证", "verification"),
("状态", "status"),
("数据", "data"),
("代码", "code"),
("分离", "separation"),
("分开", "separation"),
("隔离", "separation"),
];
#[derive(Debug, Clone, PartialEq)]
pub struct StateKeyDecision {
pub state_key: String,
pub confidence: f64,
pub reason: String,
}
impl StateKeyDecision {
pub fn allows_direct_upsert(&self) -> bool {
self.reason != "semantic_slot_terms"
}
}
pub fn derive_state_key(
memory_type: &str,
topic_key: Option<&str>,
title: &str,
content: &str,
) -> Option<StateKeyDecision> {
if let Some(topic_key) = stable_state_topic_key(topic_key) {
return Some(StateKeyDecision {
state_key: topic_key,
confidence: 1.0,
reason: "stable_topic_key".to_string(),
});
}
derive_compat_preference_state_key(memory_type, title, content)
.or_else(|| derive_semantic_state_key(memory_type, title, content))
}
pub fn current_memory_id(
conn: &Connection,
owner_scope: &str,
owner_key: &str,
memory_type: &str,
state_key: &str,
now_epoch: i64,
) -> Result<Option<i64>> {
let mut values: Vec<Box<dyn rusqlite::types::ToSql>> = vec![Box::new(owner_scope.to_string())];
let (owner_clause, mut idx) = owner_key_filter(conn, owner_scope, owner_key, 2, &mut values)?;
values.push(Box::new(memory_type.to_string()));
let memory_type_idx = idx;
idx += 1;
values.push(Box::new(state_key.to_string()));
let state_key_idx = idx;
idx += 1;
values.push(Box::new(now_epoch));
let now_idx = idx;
let sql = format!(
"SELECT m.id
FROM memory_state_keys sk
JOIN memories m ON m.id = sk.current_memory_id
WHERE sk.owner_scope = ?1
AND {owner_clause}
AND sk.memory_type = ?{memory_type_idx}
AND sk.state_key = ?{state_key_idx}
AND sk.state_status = 'active'
AND m.status = 'active'
AND (m.expires_at_epoch IS NULL OR m.expires_at_epoch > ?{now_idx})
ORDER BY m.updated_at_epoch DESC, m.id DESC
LIMIT 1"
);
let refs = crate::db::to_sql_refs(&values);
conn.query_row(&sql, refs.as_slice(), |row| row.get(0))
.optional()
.map_err(Into::into)
}
pub fn active_memory_ids(
conn: &Connection,
owner_scope: &str,
owner_key: &str,
memory_type: &str,
state_key: &str,
now_epoch: i64,
require_unexpired: bool,
) -> Result<Vec<i64>> {
let mut values: Vec<Box<dyn rusqlite::types::ToSql>> = vec![Box::new(owner_scope.to_string())];
let (owner_clause, mut idx) = owner_key_filter(conn, owner_scope, owner_key, 2, &mut values)?;
values.push(Box::new(memory_type.to_string()));
let memory_type_idx = idx;
idx += 1;
values.push(Box::new(state_key.to_string()));
let state_key_idx = idx;
idx += 1;
values.push(Box::new(if require_unexpired { 1_i64 } else { 0_i64 }));
let require_idx = idx;
idx += 1;
values.push(Box::new(now_epoch));
let now_idx = idx;
let sql = format!(
"SELECT m.id
FROM memories m
JOIN memory_state_keys sk ON sk.id = m.state_key_id
WHERE sk.owner_scope = ?1
AND {owner_clause}
AND sk.memory_type = ?{memory_type_idx}
AND sk.state_key = ?{state_key_idx}
AND sk.state_status = 'active'
AND m.status = 'active'
AND (
?{require_idx} = 0
OR m.expires_at_epoch IS NULL
OR m.expires_at_epoch > ?{now_idx}
)
ORDER BY m.updated_at_epoch DESC, m.id DESC"
);
let mut stmt = conn.prepare(&sql)?;
let refs = crate::db::to_sql_refs(&values);
let rows = stmt.query_map(refs.as_slice(), |row| row.get(0))?;
crate::db::query::collect_rows(rows)
}
pub fn attach_current_memory(
conn: &Connection,
memory_id: i64,
owner_scope: &str,
owner_key: &str,
memory_type: &str,
decision: &StateKeyDecision,
now_epoch: i64,
) -> Result<i64> {
let state_key_id = upsert_state_key(
conn,
owner_scope,
owner_key,
memory_type,
decision,
Some(memory_id),
now_epoch,
)?;
conn.execute(
"UPDATE memories SET state_key_id = ?1 WHERE id = ?2",
params![state_key_id, memory_id],
)?;
Ok(state_key_id)
}
pub fn ensure_state_key(
conn: &Connection,
owner_scope: &str,
owner_key: &str,
memory_type: &str,
decision: &StateKeyDecision,
created_at_epoch: i64,
) -> Result<i64> {
upsert_state_key(
conn,
owner_scope,
owner_key,
memory_type,
decision,
None,
created_at_epoch,
)
}
fn upsert_state_key(
conn: &Connection,
owner_scope: &str,
owner_key: &str,
memory_type: &str,
decision: &StateKeyDecision,
current_memory_id: Option<i64>,
now_epoch: i64,
) -> Result<i64> {
let canonical_owner_key = if owner_scope == "repo" {
crate::project_alias::canonical_project_path_for_write(conn, owner_key)?
} else {
owner_key.to_string()
};
conn.execute(
"INSERT INTO memory_state_keys
(owner_scope, owner_key, memory_type, state_key, state_label, state_status,
current_memory_id, created_at_epoch, updated_at_epoch)
VALUES (?1, ?2, ?3, ?4, ?5, 'active', ?6, ?7, ?7)
ON CONFLICT(owner_scope, owner_key, memory_type, state_key)
DO UPDATE SET
state_label = COALESCE(excluded.state_label, memory_state_keys.state_label),
state_status = 'active',
current_memory_id = CASE
WHEN excluded.current_memory_id IS NULL THEN memory_state_keys.current_memory_id
WHEN memory_state_keys.current_memory_id IS NULL THEN excluded.current_memory_id
WHEN excluded.updated_at_epoch >= memory_state_keys.updated_at_epoch THEN excluded.current_memory_id
ELSE memory_state_keys.current_memory_id
END,
created_at_epoch = MIN(memory_state_keys.created_at_epoch, excluded.created_at_epoch),
updated_at_epoch = MAX(memory_state_keys.updated_at_epoch, excluded.updated_at_epoch)",
params![
owner_scope,
canonical_owner_key,
memory_type,
decision.state_key,
decision.state_key.replace('-', " "),
current_memory_id,
now_epoch
],
)?;
conn.query_row(
"SELECT id FROM memory_state_keys
WHERE owner_scope = ?1
AND owner_key = ?2
AND memory_type = ?3
AND state_key = ?4",
params![
owner_scope,
canonical_owner_key,
memory_type,
decision.state_key
],
|row| row.get(0),
)
.map_err(Into::into)
}
fn owner_key_filter(
conn: &Connection,
owner_scope: &str,
owner_key: &str,
idx: usize,
params: &mut Vec<Box<dyn rusqlite::types::ToSql>>,
) -> Result<(String, usize)> {
if owner_scope == "repo" {
crate::project_alias::push_project_value_filter(
conn,
"sk.owner_key",
owner_key,
idx,
params,
)
} else {
params.push(Box::new(owner_key.to_string()));
Ok((format!("sk.owner_key = ?{idx}"), idx + 1))
}
}
fn stable_state_topic_key(topic_key: Option<&str>) -> Option<String> {
let topic_key = topic_key?.trim();
if topic_key.is_empty() || is_hash_like_topic_key(topic_key) {
return None;
}
let slug = crate::memory::promote::slugify_for_topic(topic_key, 120);
if slug.is_empty() {
None
} else {
Some(slug)
}
}
fn derive_compat_preference_state_key(
memory_type: &str,
title: &str,
content: &str,
) -> Option<StateKeyDecision> {
if memory_type != "preference" {
return None;
}
let combined = format!("{title}\n{content}");
if mentions_small_reversible_changes(&combined)
&& mentions_concrete_verification(&combined)
&& !mentions_cumulative_workflow_subrule(&combined)
{
return Some(StateKeyDecision {
state_key: "small-reversible-verified-changes".to_string(),
confidence: 0.95,
reason: "preference_domain_small_reversible_verified_changes".to_string(),
});
}
if mentions_verification_status(&combined) && mentions_data_code_separation(&combined) {
return Some(StateKeyDecision {
state_key: "verification-status-separation".to_string(),
confidence: 0.95,
reason: "preference_domain_verification_status_separation".to_string(),
});
}
if mentions_data_code_separation(&combined) {
return Some(StateKeyDecision {
state_key: "data-code-change-separation".to_string(),
confidence: 0.90,
reason: "preference_domain_data_code_separation".to_string(),
});
}
if mentions_codesign_binary(&combined) {
return Some(StateKeyDecision {
state_key: "local-rust-binary-codesign-after-cp".to_string(),
confidence: 0.90,
reason: "preference_domain_codesign_binary".to_string(),
});
}
None
}
fn derive_semantic_state_key(
memory_type: &str,
_title: &str,
content: &str,
) -> Option<StateKeyDecision> {
let prefix = semantic_slot_prefix(memory_type)?;
let terms = semantic_slot_terms(content);
if terms.len() < MIN_SEMANTIC_SLOT_TERMS {
return None;
}
let mut key_terms = terms
.iter()
.take(MAX_SEMANTIC_SLOT_TERMS)
.cloned()
.collect::<Vec<_>>();
if terms.len() > MAX_SEMANTIC_SLOT_TERMS {
key_terms.push(semantic_terms_signature(&terms));
}
let raw_key = format!("{prefix}-{}", key_terms.join("-"));
let state_key = crate::memory::promote::slugify_for_topic(&raw_key, 120);
if state_key.is_empty() {
return None;
}
Some(StateKeyDecision {
state_key,
confidence: 0.82,
reason: "semantic_slot_terms".to_string(),
})
}
fn semantic_slot_prefix(memory_type: &str) -> Option<&'static str> {
match memory_type {
"architecture" => Some("architecture"),
"bugfix" => Some("bugfix"),
"decision" => Some("decision"),
"discovery" => Some("discovery"),
"lesson" => Some("lesson"),
"preference" => Some("preference"),
"procedure" => Some("procedure"),
_ => None,
}
}
fn semantic_slot_terms(text: &str) -> Vec<String> {
let mut terms = BTreeSet::new();
for raw in text.split(|ch: char| !ch.is_ascii_alphanumeric()) {
let Some(term) = normalize_semantic_slot_term(raw) else {
continue;
};
if !is_semantic_slot_stopword(&term) {
terms.insert(term);
}
}
add_cjk_semantic_slot_terms(text, &mut terms);
terms.into_iter().collect()
}
fn add_cjk_semantic_slot_terms(text: &str, terms: &mut BTreeSet<String>) {
if !text.chars().any(is_cjk) {
return;
}
let mut matches = Vec::new();
for (cjk, canonical) in CJK_SEMANTIC_SLOT_TERMS {
for (start, _) in text.match_indices(cjk) {
matches.push((start, start + cjk.len(), cjk.len(), *canonical));
}
}
matches.sort_by(|a, b| b.2.cmp(&a.2).then_with(|| a.0.cmp(&b.0)));
let mut claimed = Vec::new();
for (start, end, _, canonical) in matches {
if claimed
.iter()
.any(|(claimed_start, claimed_end)| start < *claimed_end && end > *claimed_start)
{
continue;
}
claimed.push((start, end));
let Some(term) = normalize_semantic_slot_term(canonical) else {
continue;
};
if !is_semantic_slot_stopword(&term) {
terms.insert(term);
}
}
}
fn semantic_terms_signature(terms: &[String]) -> String {
let joined = terms.join("\0");
format!(
"sig{:08x}",
crate::db::deterministic_hash(joined.as_bytes()) as u32
)
}
fn normalize_semantic_slot_term(raw: &str) -> Option<String> {
let mut term = raw.trim().to_ascii_lowercase();
if term.is_empty() {
return None;
}
term = match term.as_str() {
"tokenization" | "tokenized" | "tokenize" | "tokenizing" => "tokenizer".to_string(),
"summaries" => "summary".to_string(),
"memories" => "memory".to_string(),
"claims" => "claim".to_string(),
"candidates" => "candidate".to_string(),
"decisions" => "decision".to_string(),
"observations" => "observation".to_string(),
"indexes" | "indexed" | "indexing" => "index".to_string(),
"tests" | "tested" | "testing" => "test".to_string(),
"changes" | "changed" | "changing" => "change".to_string(),
"updates" | "updated" | "updating" => "update".to_string(),
"embeddings" => "embedding".to_string(),
"vectors" => "vector".to_string(),
"separately" | "separation" | "separate" | "separating" => "separation".to_string(),
"verification" | "verified" | "verifies" | "verify" => "verification".to_string(),
"statuses" => "status".to_string(),
_ => term,
};
if term.len() > 4 && term.ends_with('s') && !term.ends_with("ss") {
term.pop();
}
let has_digit = term.chars().any(|ch| ch.is_ascii_digit());
if term.len() < 3 && !has_digit {
return None;
}
Some(term)
}
fn is_semantic_slot_stopword(term: &str) -> bool {
matches!(
term,
"about"
| "active"
| "add"
| "after"
| "again"
| "against"
| "always"
| "and"
| "are"
| "as"
| "because"
| "before"
| "choose"
| "current"
| "default"
| "disable"
| "disabled"
| "does"
| "enable"
| "enabled"
| "for"
| "from"
| "has"
| "have"
| "into"
| "keep"
| "later"
| "must"
| "now"
| "of"
| "only"
| "or"
| "prefer"
| "record"
| "remove"
| "removed"
| "run"
| "should"
| "stop"
| "support"
| "supports"
| "switch"
| "text"
| "the"
| "this"
| "through"
| "to"
| "use"
| "using"
| "with"
| "without"
)
}
fn is_hash_like_topic_key(topic_key: &str) -> bool {
let lower = topic_key.to_ascii_lowercase();
let mut parts = lower.rsplitn(2, ['-', '_']);
let tail = parts.next().unwrap_or_default();
let prefix = parts.next().unwrap_or_default();
tail.len() >= 8
&& tail.chars().all(|ch| ch.is_ascii_hexdigit())
&& matches!(
prefix,
"decision"
| "discovery"
| "preference"
| "bugfix"
| "lesson"
| "procedure"
| "architecture"
)
}
fn mentions_verification_status(text: &str) -> bool {
let lower = text.to_ascii_lowercase();
lower.contains("verification status")
|| lower.contains("verify status")
|| (text.contains("验证") && text.contains("状态"))
}
fn mentions_data_code_separation(text: &str) -> bool {
let lower = text.to_ascii_lowercase();
let has_data_code = (lower.contains("data") && lower.contains("code"))
|| (text.contains("数据") && text.contains("代码"));
let has_separation = lower.contains("separat")
|| lower.contains("distinct")
|| text.contains("分开")
|| text.contains("分离")
|| text.contains("隔离");
has_data_code && has_separation
}
fn mentions_codesign_binary(text: &str) -> bool {
let lower = text.to_ascii_lowercase();
lower.contains("codesign")
&& (lower.contains("binary")
|| lower.contains("bin/")
|| lower.contains("target/release")
|| lower.contains("cp "))
}
fn mentions_small_reversible_changes(text: &str) -> bool {
let compact_cjk = text
.chars()
.filter(|ch| !ch.is_whitespace() && !matches!(ch, ',' | '，' | '、' | ';' | '；'))
.collect::<String>();
if compact_cjk.contains("一处改动一个提交") {
return true;
}
let words = normalized_ascii_words(text);
words.contains(" one change per commit ") || words.contains(" one change one commit ")
}
fn mentions_concrete_verification(text: &str) -> bool {
let terms = ascii_term_set(text);
let words = normalized_ascii_words(text);
[
"artifact",
"build",
"checklist",
"command",
"evidence",
"lint",
"output",
"proof",
"test",
"typecheck",
]
.iter()
.any(|term| terms.contains(*term))
|| words.contains(" job id ")
|| words.contains(" job ids ")
|| words.contains(" build artifact ")
|| words.contains(" build artifacts ")
|| words.contains(" checklist proof ")
|| words.contains(" command output ")
|| words.contains(" test output ")
|| text.contains("证据")
|| text.contains("输出")
|| text.contains("测试")
}
fn mentions_cumulative_workflow_subrule(text: &str) -> bool {
text.split([';', '；']).skip(1).any(|tail| {
let terms = ascii_term_set(tail);
terms.contains("avoid")
|| terms.contains("unsafe")
|| terms.contains("fallback")
|| terms.contains("checklist")
|| terms.contains("done")
|| tail.contains("必须")
|| tail.contains("只")
})
}
fn ascii_term_set(text: &str) -> BTreeSet<String> {
text.split(|ch: char| !ch.is_ascii_alphanumeric())
.filter_map(normalize_semantic_slot_term)
.collect()
}
fn normalized_ascii_words(text: &str) -> String {
let mut words = String::from(" ");
for raw in text.split(|ch: char| !ch.is_ascii_alphanumeric()) {
if raw.is_empty() {
continue;
}
words.push_str(&raw.to_ascii_lowercase());
words.push(' ');
}
words
}
fn is_cjk(ch: char) -> bool {
matches!(
ch,
'\u{4E00}'..='\u{9FFF}' | '\u{3400}'..='\u{4DBF}' | '\u{F900}'..='\u{FAFF}'
)
}
#[cfg(test)]
mod tests;