fix: use JsonValue wrapper for bincode + serde_json::Value compatibility

bincode's deserialize_any is not supported by serde_json::Value, causing
deserialization errors when thoughts have metadata attributes. This fix:

- Adds JsonValue wrapper type that serializes JSON values as strings
- Updates Thought.attrs to use HashMap<String, JsonValue>
- Adds Thought.get_attr() helper method
- Fixes all usages in database.rs and main.rs
- Bumps version to 0.1.9

Fixes test_search_with_embedder and other tests that use embedder attrs.

Author: moonstripe

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "indra_db"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 description = "A content-addressed graph database for versioned thoughts"
 license = "MIT"

Cargo.toml

@@ -4,7 +4,7 @@
 
 use crate::embedding::Embedder;
 use crate::graph::GraphView;
-use crate::model::{Commit, Edge, EdgeType, Hash, Thought, ThoughtId};
+use crate::model::{Commit, Edge, EdgeType, Hash, JsonValue, Thought, ThoughtId};
 use crate::ops::{diff_trees, BranchManager, Diff};
 use crate::search::{SearchResult, VectorSearch};
 use crate::store::ObjectStore;
@@ -114,7 +114,7 @@ impl Database {
             thought.embedding = Some(embedder.embed(&thought.content)?);
             thought.attrs.insert(
                 "embedder_model".to_string(),
-                serde_json::Value::String(embedder.model_name().to_string()),
+                JsonValue::new(serde_json::Value::String(embedder.model_name().to_string())),
             );
         }
 
@@ -139,7 +139,7 @@ impl Database {
             thought.embedding = Some(embedder.embed(&thought.content)?);
             thought.attrs.insert(
                 "embedder_model".to_string(),
-                serde_json::Value::String(embedder.model_name().to_string()),
+                JsonValue::new(serde_json::Value::String(embedder.model_name().to_string())),
             );
         }
 
@@ -185,7 +185,7 @@ impl Database {
             thought.embedding = Some(embedder.embed(&thought.content)?);
             thought.attrs.insert(
                 "embedder_model".to_string(),
-                serde_json::Value::String(embedder.model_name().to_string()),
+                JsonValue::new(serde_json::Value::String(embedder.model_name().to_string())),
             );
         }
 

src/database.rs

@@ -336,6 +336,9 @@ fn main() -> anyhow::Result<()> {
             let thought_id = indra_db::ThoughtId::new(&id);
             match db.get_thought(&thought_id)? {
                 Some(thought) => {
+                    // Convert JsonValue attrs to serde_json::Value for output
+                    let attrs: std::collections::HashMap<String, serde_json::Value> =
+                        thought.attrs.into_iter().map(|(k, v)| (k, v.0)).collect();
                     output(
                         &cli.format,
                         &serde_json::json!({
@@ -344,7 +347,7 @@ fn main() -> anyhow::Result<()> {
                             "type": thought.thought_type,
                             "created_at": thought.created_at,
                             "modified_at": thought.modified_at,
-                            "attrs": thought.attrs,
+                            "attrs": attrs,
                             "has_embedding": thought.embedding.is_some()
                         }),
                     );

src/main.rs

@@ -8,4 +8,4 @@ mod thought;
 pub use commit::Commit;
 pub use edge::{Edge, EdgeType};
 pub use hash::Hash;
-pub use thought::{Thought, ThoughtId};
+pub use thought::{JsonValue, Thought, ThoughtId};

src/model/mod.rs

@@ -1,10 +1,59 @@
 //! Thought (node) type - the fundamental unit of knowledge
 
 use super::Hash;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::collections::HashMap;
 use std::time::{SystemTime, UNIX_EPOCH};
 
+/// Wrapper type for storing JSON values that is compatible with bincode.
+///
+/// bincode doesn't support `serde_json::Value` because it uses `deserialize_any`,
+/// so we serialize JSON values to strings for storage.
+#[derive(Clone, Debug, PartialEq)]
+pub struct JsonValue(pub serde_json::Value);
+
+impl JsonValue {
+    pub fn new(value: serde_json::Value) -> Self {
+        JsonValue(value)
+    }
+}
+
+impl From<serde_json::Value> for JsonValue {
+    fn from(v: serde_json::Value) -> Self {
+        JsonValue(v)
+    }
+}
+
+impl From<JsonValue> for serde_json::Value {
+    fn from(v: JsonValue) -> Self {
+        v.0
+    }
+}
+
+impl Serialize for JsonValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        // Serialize the JSON value as a string
+        let json_string = serde_json::to_string(&self.0).map_err(serde::ser::Error::custom)?;
+        serializer.serialize_str(&json_string)
+    }
+}
+
+impl<'de> Deserialize<'de> for JsonValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Deserialize as string, then parse as JSON
+        let json_string = String::deserialize(deserializer)?;
+        let value: serde_json::Value =
+            serde_json::from_str(&json_string).map_err(serde::de::Error::custom)?;
+        Ok(JsonValue(value))
+    }
+}
+
 /// Unique identifier for a thought (semantic ID, not content hash)
 /// This allows thoughts to evolve while maintaining identity
 #[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -82,8 +131,8 @@ pub struct Thought {
     /// Dimension is configurable at database level
     pub embedding: Option<Vec<f32>>,
 
-    /// Arbitrary metadata
-    pub attrs: HashMap<String, serde_json::Value>,
+    /// Arbitrary metadata (stored as JSON strings for bincode compatibility)
+    pub attrs: HashMap<String, JsonValue>,
 
     /// Creation timestamp (unix millis)
     pub created_at: u64,
@@ -147,10 +196,15 @@ impl Thought {
         key: impl Into<String>,
         value: impl Into<serde_json::Value>,
     ) -> Self {
-        self.attrs.insert(key.into(), value.into());
+        self.attrs.insert(key.into(), JsonValue::new(value.into()));
         self
     }
 
+    /// Get a metadata attribute
+    pub fn get_attr(&self, key: &str) -> Option<&serde_json::Value> {
+        self.attrs.get(key).map(|v| &v.0)
+    }
+
     /// Compute the content hash of this thought
     /// This determines the blob's address in content-addressed storage
     pub fn content_hash(&self) -> Hash {
@@ -209,7 +263,7 @@ mod tests {
 
         assert_eq!(thought.thought_type, Some("hypothesis".to_string()));
         assert_eq!(
-            thought.attrs.get("confidence"),
+            thought.get_attr("confidence"),
             Some(&serde_json::json!(0.8))
         );
     }