feat: Implement M2.4 pgvector repository with real Postgres
M2.4 Complete: PostgreSQL-backed repository for memory projection
Implementation (crates/mem-store/src/pg_repo.rs):
- PgRepo::connect() with migration support
- upsert_node() — ON CONFLICT idempotent inserts
- upsert_vector() — store text + symptom embeddings (768-dim)
- insert_edges() — two-pass graph construction
- search() — cosine distance with literal kind predicates & partial indexes
- lookup_signature() — exact-match tier for failure_signature
- parents_of() — traverse memory_edge graph
- clear_project() — scoped deletion with cascade
Types:
- Level: L0, L1, L2, R
- VectorKind: Text, Symptom
- Scope: Project(id) vs AllProjects (federated for tool lookups)
- ScoredNode: { node, distance, matched_kind }
- SignatureHit: { node_sha, tool, raw, seen_count }
Schema Updated (migrations/001_init_schema.sql):
- memory_node with content-addressed sha256
- memory_edge for provenance graph
- memory_vector with partial indexes per kind
- failure_signature for exact-match tier
- memory_supersede for lesson replacement
Tests (tests/it_pg_repo.rs): 8 integration tests (with #[ignore] for local Postgres)
1. a1_upsert_idempotent — duplicate insert = no-op
2. a2_two_pass_required — forward edges fail, two-pass succeeds
3. a3_search_orders_by_distance — hand-computed cosine distance verification
4. a4_level_filter — respect levels constraint
5. a5_project_isolation — no cross-project leakage
6. a6_clear_project_scoped — clean per-project cleanup
7. a8_parents_of — graph traversal correctness
Deterministic embedder: sha256(text) → 768-dim normalized vector
Allows exact assertions without external API calls
Updated INDEX.md:
- M2.x: 3/8 done (was 2/8)
- Total: 45✅ + 2🟡 + 26⬜ (was 44✅)
Note: M2.3 schema tables now match spec (memory_node, edges, vectors)
This commit is contained in:
Story Crater Bot
@@ -0,0 +1,70 @@
|
||||
-- Poimen Memory schema (M2.3, M2.4 spec)
|
||||
-- Tables: memory_node, memory_edge, memory_vector, failure_signature, memory_supersede
|
||||
|
||||
-- Enable pgvector extension
|
||||
CREATE EXTENSION IF NOT EXISTS vector;
|
||||
|
||||
-- Core memory node (sha256 = content identity, idempotent upsert key)
|
||||
CREATE TABLE IF NOT EXISTS memory_node (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
sha256 TEXT NOT NULL UNIQUE,
|
||||
level TEXT NOT NULL CHECK (level IN ('L0', 'L1', 'L2', 'R')),
|
||||
project TEXT NOT NULL,
|
||||
query_id TEXT, -- NULL at L2 and R; CHECK enforced below
|
||||
run_id TEXT NOT NULL,
|
||||
t INT NOT NULL,
|
||||
source TEXT, -- set at L0; source URI at R
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
CONSTRAINT level_query_id_check CHECK (
|
||||
(level IN ('L2', 'R') AND query_id IS NULL) OR
|
||||
(level NOT IN ('L2', 'R') AND query_id IS NOT NULL)
|
||||
)
|
||||
);
|
||||
|
||||
CREATE INDEX idx_memory_node_project_level ON memory_node(project, level);
|
||||
CREATE INDEX idx_memory_node_sha256 ON memory_node(sha256);
|
||||
|
||||
-- Memory edges (provenance graph: child → parent)
|
||||
CREATE TABLE IF NOT EXISTS memory_edge (
|
||||
child_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
parent_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
PRIMARY KEY (child_sha, parent_sha)
|
||||
);
|
||||
|
||||
CREATE INDEX idx_memory_edge_parent ON memory_edge(parent_sha);
|
||||
|
||||
-- Vector storage (one node can have multiple kinds: text + symptom)
|
||||
CREATE TABLE IF NOT EXISTS memory_vector (
|
||||
node_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
kind TEXT NOT NULL CHECK (kind IN ('text', 'symptom')),
|
||||
embedding vector(768) NOT NULL,
|
||||
PRIMARY KEY (node_sha, kind)
|
||||
);
|
||||
|
||||
-- Partial indexes per kind (literal predicate required for planner to use them)
|
||||
CREATE INDEX idx_memory_vector_text ON memory_vector USING hnsw (embedding vector_cosine_ops) WHERE kind = 'text';
|
||||
CREATE INDEX idx_memory_vector_symptom ON memory_vector USING hnsw (embedding vector_cosine_ops) WHERE kind = 'symptom';
|
||||
|
||||
-- Exact-match failure signature tier (M3.7.7)
|
||||
CREATE TABLE IF NOT EXISTS failure_signature (
|
||||
sig_sha TEXT PRIMARY KEY, -- hash of normalized signature
|
||||
node_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
tool TEXT NOT NULL, -- 'github-actions' | 'kubectl' | 'npm' | ...
|
||||
raw TEXT NOT NULL, -- pre-normalisation, for display
|
||||
seen_count INT NOT NULL DEFAULT 1,
|
||||
last_seen TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX idx_failure_signature_tool ON failure_signature(tool);
|
||||
CREATE INDEX idx_failure_signature_node ON failure_signature(node_sha);
|
||||
|
||||
-- Memory supersession (old lesson replaced by new one)
|
||||
CREATE TABLE IF NOT EXISTS memory_supersede (
|
||||
old_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
new_sha TEXT NOT NULL REFERENCES memory_node(sha256) ON DELETE CASCADE,
|
||||
reason TEXT,
|
||||
PRIMARY KEY (old_sha, new_sha)
|
||||
);
|
||||
|
||||
CREATE INDEX idx_memory_supersede_new ON memory_supersede(new_sha);
|
||||
@@ -8,6 +8,6 @@ pub mod schema;
|
||||
pub use event_log::{EventRecord, LogWriter};
|
||||
pub use pgvector::{VectorRecord, VectorStore, ChunkL0, MemoryL1, MemoryL2};
|
||||
pub use rebuild::RebuildState;
|
||||
pub use pg_repo::{PgRepo, MemoryNode, VectorKind, Level, ScoredNode};
|
||||
pub use pg_repo::{PgRepo, MemoryNode, VectorKind, Level, ScoredNode, Scope, SignatureHit};
|
||||
pub use obsidian::ObsidianProjector;
|
||||
pub use schema::init_schema;
|
||||
|
||||
+297
-140
@@ -1,9 +1,43 @@
|
||||
use anyhow::Result;
|
||||
use anyhow::{anyhow, Result};
|
||||
use pgvector::Vector;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::collections::BTreeMap;
|
||||
use sqlx::{PgPool, Row};
|
||||
|
||||
/// Vector kind (text or symptom).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||||
/// Memory level
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
pub enum Level {
|
||||
L0,
|
||||
L1,
|
||||
L2,
|
||||
R,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for Level {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Level::L0 => write!(f, "L0"),
|
||||
Level::L1 => write!(f, "L1"),
|
||||
Level::L2 => write!(f, "L2"),
|
||||
Level::R => write!(f, "R"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::str::FromStr for Level {
|
||||
type Err = anyhow::Error;
|
||||
fn from_str(s: &str) -> Result<Self> {
|
||||
match s {
|
||||
"L0" => Ok(Level::L0),
|
||||
"L1" => Ok(Level::L1),
|
||||
"L2" => Ok(Level::L2),
|
||||
"R" => Ok(Level::R),
|
||||
_ => Err(anyhow!("invalid level: {}", s)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Vector kind (text embedding or symptom projection)
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||||
pub enum VectorKind {
|
||||
Text,
|
||||
Symptom,
|
||||
@@ -18,193 +52,316 @@ impl std::fmt::Display for VectorKind {
|
||||
}
|
||||
}
|
||||
|
||||
/// Level (L0, L1, L2).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
|
||||
pub enum Level {
|
||||
L0,
|
||||
L1,
|
||||
L2,
|
||||
/// Search scope (project-specific or federated)
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub enum Scope {
|
||||
Project(String), // project-specific search
|
||||
AllProjects, // federated across all projects (for tool-failure lookups)
|
||||
}
|
||||
|
||||
/// Memory node (idempotent upsert key: sha256).
|
||||
/// Memory node (content-addressable by sha256)
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct MemoryNode {
|
||||
pub sha256: String,
|
||||
pub level: Level,
|
||||
pub project: String,
|
||||
pub query_id: Option<String>, // NULL at L2, R
|
||||
pub run_id: String,
|
||||
pub t: i32,
|
||||
pub source: Option<String>, // set at L0; URI at R
|
||||
pub text: String,
|
||||
pub tokens: u32,
|
||||
}
|
||||
|
||||
/// Scored search result.
|
||||
/// Scored search result with metadata
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct ScoredNode {
|
||||
pub node: MemoryNode,
|
||||
pub distance: f32,
|
||||
pub distance: f32, // raw cosine distance (not similarity)
|
||||
pub matched_kind: VectorKind,
|
||||
}
|
||||
|
||||
/// PostgreSQL repository (in-memory mock for now).
|
||||
/// Failure signature hit (exact-match tier)
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub struct SignatureHit {
|
||||
pub node_sha: String,
|
||||
pub tool: String,
|
||||
pub raw: String,
|
||||
pub seen_count: i32,
|
||||
}
|
||||
|
||||
/// PostgreSQL repository for memory projection
|
||||
pub struct PgRepo {
|
||||
// Nodes by sha256
|
||||
nodes: BTreeMap<String, MemoryNode>,
|
||||
// Vectors by (sha256, kind)
|
||||
vectors: BTreeMap<(String, VectorKind), Vec<f32>>,
|
||||
// Parents edges: child_sha -> vec of parent_shas
|
||||
edges: BTreeMap<String, Vec<String>>,
|
||||
pool: PgPool,
|
||||
}
|
||||
|
||||
impl PgRepo {
|
||||
/// Create new repo (mock, no real DB).
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
nodes: BTreeMap::new(),
|
||||
vectors: BTreeMap::new(),
|
||||
edges: BTreeMap::new(),
|
||||
}
|
||||
/// Connect to Postgres and run migrations
|
||||
pub async fn connect(url: &str) -> Result<Self> {
|
||||
let pool = PgPool::connect(url).await?;
|
||||
sqlx::migrate!("./migrations")
|
||||
.run(&pool)
|
||||
.await?;
|
||||
Ok(Self { pool })
|
||||
}
|
||||
|
||||
/// Upsert node (idempotent).
|
||||
pub fn upsert_node(&mut self, node: &MemoryNode) -> Result<()> {
|
||||
self.nodes.insert(node.sha256.clone(), node.clone());
|
||||
/// Upsert a memory node (ON CONFLICT DO NOTHING — idempotent)
|
||||
pub async fn upsert_node(&self, node: &MemoryNode) -> Result<()> {
|
||||
let level_str = node.level.to_string();
|
||||
sqlx::query(
|
||||
r#"
|
||||
INSERT INTO memory_node
|
||||
(sha256, level, project, query_id, run_id, t, source, text)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
|
||||
ON CONFLICT (sha256) DO NOTHING
|
||||
"#,
|
||||
)
|
||||
.bind(&node.sha256)
|
||||
.bind(&level_str)
|
||||
.bind(&node.project)
|
||||
.bind(&node.query_id)
|
||||
.bind(&node.run_id)
|
||||
.bind(node.t)
|
||||
.bind(&node.source)
|
||||
.bind(&node.text)
|
||||
.execute(&self.pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Upsert many nodes (batching embedding calls).
|
||||
pub fn upsert_many(&mut self, nodes: &[MemoryNode]) -> Result<()> {
|
||||
for node in nodes {
|
||||
self.upsert_node(node)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Upsert vector for node.
|
||||
pub fn upsert_vector(&mut self, sha: &str, kind: VectorKind, embedding: &[f32]) -> Result<()> {
|
||||
if !self.nodes.contains_key(sha) {
|
||||
return Err(anyhow::anyhow!("Node {} not found", sha));
|
||||
}
|
||||
self.vectors.insert((sha.to_string(), kind), embedding.to_vec());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Insert edges (requires both endpoints exist).
|
||||
pub fn insert_edges(&mut self, child: &str, parents: &[String]) -> Result<()> {
|
||||
if !self.nodes.contains_key(child) {
|
||||
return Err(anyhow::anyhow!("Child node {} not found", child));
|
||||
}
|
||||
for parent in parents {
|
||||
if !self.nodes.contains_key(parent) {
|
||||
return Err(anyhow::anyhow!("Parent node {} not found", parent));
|
||||
}
|
||||
}
|
||||
self.edges.insert(child.to_string(), parents.to_vec());
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Search by cosine distance.
|
||||
pub fn search(
|
||||
/// Store an embedding for a node (text or symptom kind)
|
||||
pub async fn upsert_vector(
|
||||
&self,
|
||||
q: &[f32],
|
||||
node_sha: &str,
|
||||
kind: VectorKind,
|
||||
embedding: &[f32],
|
||||
) -> Result<()> {
|
||||
if embedding.len() != 768 {
|
||||
return Err(anyhow!(
|
||||
"invalid embedding dimension: expected 768, got {}",
|
||||
embedding.len()
|
||||
));
|
||||
}
|
||||
let kind_str = kind.to_string();
|
||||
let vec = Vector::from(embedding.to_vec());
|
||||
sqlx::query(
|
||||
r#"
|
||||
INSERT INTO memory_vector (node_sha, kind, embedding)
|
||||
VALUES ($1, $2, $3)
|
||||
ON CONFLICT (node_sha, kind) DO UPDATE
|
||||
SET embedding = $3
|
||||
"#,
|
||||
)
|
||||
.bind(node_sha)
|
||||
.bind(&kind_str)
|
||||
.bind(&vec)
|
||||
.execute(&self.pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Insert edges (child → parent pointers) — fails if endpoints don't exist
|
||||
pub async fn insert_edges(&self, child_sha: &str, parent_shas: &[String]) -> Result<()> {
|
||||
// Batch insert edges; foreign key constraints ensure endpoints exist
|
||||
for parent_sha in parent_shas {
|
||||
sqlx::query(
|
||||
r#"
|
||||
INSERT INTO memory_edge (child_sha, parent_sha)
|
||||
VALUES ($1, $2)
|
||||
ON CONFLICT (child_sha, parent_sha) DO NOTHING
|
||||
"#,
|
||||
)
|
||||
.bind(child_sha)
|
||||
.bind(parent_sha)
|
||||
.execute(&self.pool)
|
||||
.await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Search by embedding (cosine distance, kind-filtered)
|
||||
/// - For text kind: uses partial index WHERE kind = 'text'
|
||||
/// - For symptom kind: uses partial index WHERE kind = 'symptom'
|
||||
pub async fn search(
|
||||
&self,
|
||||
query_embedding: &[f32],
|
||||
kind: VectorKind,
|
||||
levels: &[Level],
|
||||
scope: &Scope,
|
||||
k: usize,
|
||||
) -> Result<Vec<ScoredNode>> {
|
||||
let mut results = Vec::new();
|
||||
if query_embedding.len() != 768 {
|
||||
return Err(anyhow!("query embedding must be 768-dim"));
|
||||
}
|
||||
|
||||
let q_vec = Vector::from(query_embedding.to_vec());
|
||||
let kind_str = kind.to_string();
|
||||
let level_strs: Vec<String> = levels.iter().map(|l| l.to_string()).collect();
|
||||
|
||||
// Build the WHERE clause based on scope
|
||||
let (where_clause, project_param) = match scope {
|
||||
Scope::Project(proj) => ("AND n.project = $4".to_string(), Some(proj.clone())),
|
||||
Scope::AllProjects => ("".to_string(), None),
|
||||
};
|
||||
|
||||
for ((sha, vkind), embedding) in &self.vectors {
|
||||
if *vkind != kind {
|
||||
continue;
|
||||
}
|
||||
let query_sql = format!(
|
||||
r#"
|
||||
SELECT n.sha256, n.level, n.project, n.query_id, n.run_id, n.t, n.source, n.text,
|
||||
v.embedding <=> $1 AS distance
|
||||
FROM memory_vector v
|
||||
JOIN memory_node n ON v.node_sha = n.sha256
|
||||
WHERE v.kind = $2
|
||||
AND n.level = ANY($3)
|
||||
{}
|
||||
AND (SELECT COUNT(*) FROM memory_supersede WHERE old_sha = n.sha256) = 0
|
||||
ORDER BY v.embedding <=> $1 ASC
|
||||
LIMIT $5
|
||||
"#,
|
||||
if where_clause.is_empty() { "" } else { &where_clause }
|
||||
);
|
||||
|
||||
if let Some(node) = self.nodes.get(sha) {
|
||||
if !levels.contains(&node.level) {
|
||||
continue;
|
||||
}
|
||||
let rows = if let Some(proj) = project_param {
|
||||
sqlx::query(&query_sql)
|
||||
.bind(&q_vec)
|
||||
.bind(&kind_str)
|
||||
.bind(&level_strs)
|
||||
.bind(&proj)
|
||||
.bind(k as i64)
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
} else {
|
||||
sqlx::query(&query_sql)
|
||||
.bind(&q_vec)
|
||||
.bind(&kind_str)
|
||||
.bind(&level_strs)
|
||||
.bind(k as i64)
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
};
|
||||
|
||||
if let Some(dist) = cosine_distance(q, embedding) {
|
||||
results.push(ScoredNode {
|
||||
node: node.clone(),
|
||||
distance: dist,
|
||||
matched_kind: kind,
|
||||
});
|
||||
}
|
||||
}
|
||||
let mut results = Vec::new();
|
||||
for row in rows {
|
||||
let level_str: String = row.get("level");
|
||||
let node = MemoryNode {
|
||||
sha256: row.get("sha256"),
|
||||
level: level_str.parse()?,
|
||||
project: row.get("project"),
|
||||
query_id: row.get("query_id"),
|
||||
run_id: row.get("run_id"),
|
||||
t: row.get("t"),
|
||||
source: row.get("source"),
|
||||
text: row.get("text"),
|
||||
};
|
||||
let distance: f32 = row.get("distance");
|
||||
results.push(ScoredNode {
|
||||
node,
|
||||
distance,
|
||||
matched_kind: kind,
|
||||
});
|
||||
}
|
||||
|
||||
// Sort by distance (ascending)
|
||||
results.sort_by(|a, b| a.distance.partial_cmp(&b.distance).unwrap());
|
||||
Ok(results)
|
||||
}
|
||||
|
||||
/// Parents of node.
|
||||
pub fn parents_of(&self, sha: &str) -> Result<Vec<MemoryNode>> {
|
||||
let parent_shas = self.edges.get(sha).cloned().unwrap_or_default();
|
||||
let parents: Vec<_> = parent_shas
|
||||
.iter()
|
||||
.filter_map(|p_sha| self.nodes.get(p_sha).cloned())
|
||||
.collect();
|
||||
/// Exact-match lookup on failure signature
|
||||
pub async fn lookup_signature(&self, sig_sha: &str) -> Result<Option<SignatureHit>> {
|
||||
let row = sqlx::query(
|
||||
r#"
|
||||
SELECT node_sha, tool, raw, seen_count
|
||||
FROM failure_signature
|
||||
WHERE sig_sha = $1
|
||||
"#,
|
||||
)
|
||||
.bind(sig_sha)
|
||||
.fetch_optional(&self.pool)
|
||||
.await?;
|
||||
|
||||
Ok(row.map(|r| SignatureHit {
|
||||
node_sha: r.get("node_sha"),
|
||||
tool: r.get("tool"),
|
||||
raw: r.get("raw"),
|
||||
seen_count: r.get("seen_count"),
|
||||
}))
|
||||
}
|
||||
|
||||
/// Traverse parent nodes via edges
|
||||
pub async fn parents_of(&self, sha: &str) -> Result<Vec<MemoryNode>> {
|
||||
let rows = sqlx::query(
|
||||
r#"
|
||||
SELECT n.sha256, n.level, n.project, n.query_id, n.run_id, n.t, n.source, n.text
|
||||
FROM memory_node n
|
||||
JOIN memory_edge e ON e.parent_sha = n.sha256
|
||||
WHERE e.child_sha = $1
|
||||
"#,
|
||||
)
|
||||
.bind(sha)
|
||||
.fetch_all(&self.pool)
|
||||
.await?;
|
||||
|
||||
let mut parents = Vec::new();
|
||||
for row in rows {
|
||||
let level_str: String = row.get("level");
|
||||
parents.push(MemoryNode {
|
||||
sha256: row.get("sha256"),
|
||||
level: level_str.parse()?,
|
||||
project: row.get("project"),
|
||||
query_id: row.get("query_id"),
|
||||
run_id: row.get("run_id"),
|
||||
t: row.get("t"),
|
||||
source: row.get("source"),
|
||||
text: row.get("text"),
|
||||
});
|
||||
}
|
||||
Ok(parents)
|
||||
}
|
||||
|
||||
/// Clear all nodes for project.
|
||||
pub fn clear_project(&mut self, project: &str) -> Result<()> {
|
||||
let nodes_to_remove: Vec<String> = self
|
||||
.nodes
|
||||
.iter()
|
||||
.filter(|(_, n)| n.project == project)
|
||||
.map(|(sha, _)| sha.clone())
|
||||
.collect();
|
||||
|
||||
// Remove vectors
|
||||
self.vectors.retain(|(sha, _), _| !nodes_to_remove.contains(sha));
|
||||
|
||||
// Remove edges
|
||||
self.edges.retain(|child, _| !nodes_to_remove.contains(child));
|
||||
|
||||
// Remove nodes
|
||||
self.nodes.retain(|sha, _| !nodes_to_remove.contains(sha));
|
||||
|
||||
/// Clear all nodes for a project (edges cascade delete)
|
||||
pub async fn clear_project(&self, project: &str) -> Result<()> {
|
||||
sqlx::query("DELETE FROM memory_node WHERE project = $1")
|
||||
.bind(project)
|
||||
.execute(&self.pool)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Get all nodes.
|
||||
pub fn all_nodes(&self) -> Vec<&MemoryNode> {
|
||||
self.nodes.values().collect()
|
||||
/// Get node count (for testing)
|
||||
pub async fn node_count(&self) -> Result<i64> {
|
||||
let row = sqlx::query("SELECT COUNT(*) as cnt FROM memory_node")
|
||||
.fetch_one(&self.pool)
|
||||
.await?;
|
||||
Ok(row.get("cnt"))
|
||||
}
|
||||
|
||||
/// Verify: count upserted nodes.
|
||||
pub fn node_count(&self) -> usize {
|
||||
self.nodes.len()
|
||||
}
|
||||
|
||||
/// Verify: count edges.
|
||||
pub fn edge_count(&self) -> usize {
|
||||
self.edges.len()
|
||||
/// Get edge count (for testing)
|
||||
pub async fn edge_count(&self) -> Result<i64> {
|
||||
let row = sqlx::query("SELECT COUNT(*) as cnt FROM memory_edge")
|
||||
.fetch_one(&self.pool)
|
||||
.await?;
|
||||
Ok(row.get("cnt"))
|
||||
}
|
||||
}
|
||||
|
||||
/// Cosine distance (1 - cosine_similarity).
|
||||
fn cosine_distance(a: &[f32], b: &[f32]) -> Option<f32> {
|
||||
if a.len() != b.len() || a.is_empty() {
|
||||
return None;
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_level_display() {
|
||||
assert_eq!(Level::L0.to_string(), "L0");
|
||||
assert_eq!(Level::L1.to_string(), "L1");
|
||||
assert_eq!(Level::L2.to_string(), "L2");
|
||||
assert_eq!(Level::R.to_string(), "R");
|
||||
}
|
||||
|
||||
let mut dot = 0.0;
|
||||
let mut norm_a = 0.0;
|
||||
let mut norm_b = 0.0;
|
||||
|
||||
for (x, y) in a.iter().zip(b.iter()) {
|
||||
dot += x * y;
|
||||
norm_a += x * x;
|
||||
norm_b += y * y;
|
||||
#[test]
|
||||
fn test_vector_kind_display() {
|
||||
assert_eq!(VectorKind::Text.to_string(), "text");
|
||||
assert_eq!(VectorKind::Symptom.to_string(), "symptom");
|
||||
}
|
||||
|
||||
let norm_a = norm_a.sqrt();
|
||||
let norm_b = norm_b.sqrt();
|
||||
|
||||
if norm_a == 0.0 || norm_b == 0.0 {
|
||||
return None;
|
||||
#[test]
|
||||
fn test_scope_variants() {
|
||||
let proj_scope = Scope::Project("test".to_string());
|
||||
let all_scope = Scope::AllProjects;
|
||||
assert_ne!(proj_scope, all_scope);
|
||||
}
|
||||
|
||||
let similarity = dot / (norm_a * norm_b);
|
||||
Some(1.0 - similarity)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user