maggraph 0.2.5__tar.gz → 0.3.0__tar.gz

{maggraph-0.2.5 → maggraph-0.3.0}/Cargo.lock

@@ -839,7 +839,7 @@ checksum = "113b30b4cd05f7c06868fdb2854f66a7b9fece9a48425351cd532e810d74024f"
 
 [[package]]
 name = "maggraph"
-version = "0.2.5"
+version = "0.3.0"
 dependencies = [
  "axum",
  "chrono",
@@ -862,7 +862,7 @@ dependencies = [
 
 [[package]]
 name = "maggraph-cli"
-version = "0.2.5"
+version = "0.3.0"
 dependencies = [
  "assert_cmd",
  "axum",

{maggraph-0.2.5 → maggraph-0.3.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["maggraph"]
 resolver = "2"
 
 [workspace.package]
-version = "0.2.5"
+version = "0.3.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/AlexMercedCoder/MagGraph"

{maggraph-0.2.5 → maggraph-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maggraph
-Version: 0.2.5
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/Cargo.toml

@@ -39,12 +39,17 @@ axum = { workspace = true, optional = true }
 tower = { workspace = true, optional = true }
 tower-http = { workspace = true, optional = true }
 serde_json = { workspace = true, optional = true }
+tempfile.workspace = true
 
 [dev-dependencies]
-tempfile = { workspace = true }
 tower = { workspace = true, features = ["util"] }
 
 [[bench]]
 name = "traversal"
 path = "benches/traversal.rs"
 harness = false
+
+[[bench]]
+name = "index_scale"
+path = "benches/index_scale.rs"
+harness = false

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/__init__.py

@@ -50,4 +50,4 @@ __all__ = [
     "open_index",
 ]
 
-__version__ = "0.2.5"
+__version__ = "0.3.0"

maggraph-0.3.0/maggraph/benches/index_scale.rs

@@ -0,0 +1,85 @@
+use std::env;
+use std::fs;
+use std::time::{Duration, Instant};
+
+use maggraph::{GraphIndex, QueryOptions};
+use tempfile::TempDir;
+
+fn sizes() -> Vec<usize> {
+    if let Ok(value) = env::var("MAGGRAPH_BENCH_SIZES") {
+        return value
+            .split(',')
+            .filter_map(|item| item.trim().parse().ok())
+            .collect();
+    }
+    if env::var_os("MAGGRAPH_BENCH_FULL").is_some() {
+        vec![1_000, 10_000, 100_000]
+    } else {
+        vec![1_000, 10_000]
+    }
+}
+
+fn write_fixture(root: &std::path::Path, count: usize) {
+    fs::create_dir_all(root).expect("create fixture root");
+    for index in 0..count {
+        let previous = index.checked_sub(1).unwrap_or(count - 1);
+        let tags = if index % 25 == 0 {
+            "tags: [\"benchmark\", \"selected\"]\n"
+        } else {
+            "tags: [\"benchmark\"]\n"
+        };
+        let markdown = format!(
+            "---\nid: \"node_{index:06}\"\ntype: \"project_fact\"\n{tags}links: [\"node_{previous:06}\"]\n---\nSynthetic graph fact {index}. Search needle group {}.\n",
+            index % 100
+        );
+        fs::write(root.join(format!("node_{index:06}.md")), markdown).expect("write node");
+    }
+}
+
+fn timed<T>(operation: impl FnOnce() -> T) -> (T, Duration) {
+    let started = Instant::now();
+    let result = operation();
+    (result, started.elapsed())
+}
+
+fn main() {
+    println!("MagGraph index scale benchmark");
+    println!("nodes,open_ms,search_ms,backlinks_ms,recall_us,update_us");
+
+    for count in sizes() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        write_fixture(&root, count);
+
+        let (mut index, open) = timed(|| GraphIndex::open(&root).expect("open index"));
+        let options = QueryOptions {
+            text: Some("needle group 42".into()),
+            tags: vec!["benchmark".into()],
+            limit: 50,
+            ..QueryOptions::default()
+        };
+        let (results, search) = timed(|| index.search(&options).expect("search"));
+        assert!(!results.is_empty());
+
+        let (_, backlinks) = timed(|| index.backlinks("node_000042").expect("backlinks"));
+        let (_, recall) = timed(|| {
+            index
+                .recall_bundle("node_000042", "scale benchmark", 600)
+                .expect("recall bundle")
+        });
+        let (_, update) = timed(|| {
+            index
+                .update_file(root.join("node_000042.md"))
+                .expect("incremental update")
+        });
+
+        println!(
+            "{count},{:.3},{:.3},{:.3},{:.3},{:.3}",
+            open.as_secs_f64() * 1_000.0,
+            search.as_secs_f64() * 1_000.0,
+            backlinks.as_secs_f64() * 1_000.0,
+            recall.as_secs_f64() * 1_000_000.0,
+            update.as_secs_f64() * 1_000_000.0,
+        );
+    }
+}

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/src/graph.rs

@@ -4,8 +4,6 @@ use std::collections::{HashMap, HashSet, VecDeque};
 
 use crate::error::{MagGraphError, Result};
 use crate::index::GraphIndex;
-use crate::node::Node;
-use crate::wikilink::extract_wikilink_targets;
 
 /// Edge direction: all edges are **outgoing** from source node to target node id.
 ///
@@ -20,7 +18,7 @@ pub struct GraphAdjacency {
 }
 
 impl GraphAdjacency {
-    /// Build adjacency by reading all nodes in the index.
+    /// Build adjacency from metadata and wikilinks cached in the index.
     pub fn from_index(index: &GraphIndex) -> Result<Self> {
         let mut outgoing: HashMap<String, Vec<String>> = HashMap::new();
         let mut unresolved: HashMap<String, Vec<String>> = HashMap::new();
@@ -28,9 +26,13 @@ impl GraphAdjacency {
         let id_set: HashSet<&str> = index.iter().map(|(id, _)| id).collect();
         let path_stem_to_id = build_path_stem_index(index);
 
-        for (id, _) in index.iter() {
-            let node = index.read_node(id)?;
-            let (targets, dangling) = collect_outgoing_targets(&node, &id_set, &path_stem_to_id);
+        for (id, entry) in index.iter() {
+            let (targets, dangling) = collect_outgoing_targets(
+                &entry.metadata.links,
+                &entry.wikilinks,
+                &id_set,
+                &path_stem_to_id,
+            );
             if !targets.is_empty() {
                 outgoing.insert(id.to_string(), targets);
             }
@@ -114,7 +116,8 @@ fn build_path_stem_index(index: &GraphIndex) -> HashMap<String, String> {
 }
 
 fn collect_outgoing_targets(
-    node: &Node,
+    frontmatter_links: &[String],
+    wikilinks: &[String],
     id_set: &HashSet<&str>,
     path_stem_to_id: &HashMap<String, String>,
 ) -> (Vec<String>, Vec<String>) {
@@ -140,12 +143,12 @@ fn collect_outgoing_targets(
         }
     };
 
-    for link in &node.metadata.links {
+    for link in frontmatter_links {
         consider(link);
     }
 
-    for target in extract_wikilink_targets(&node.body) {
-        consider(&target);
+    for target in wikilinks {
+        consider(target);
     }
 
     (resolved, dangling)

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/src/index.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::sync::Arc;
 
 use walkdir::WalkDir;
 
@@ -11,18 +12,26 @@ use crate::query::{changed_since, GraphChange, QueryOptions, SearchResult};
 use crate::recall::{recall_bundle, RecallBundle};
 use crate::security::validate_relative_node_path;
 use crate::sync::WritePolicy;
+use crate::wikilink::extract_wikilink_targets;
 
-/// Lightweight index entry for a graph node (metadata + path, no body).
+/// Parsed index entry used by graph, search, and retrieval operations.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct NodeIndexEntry {
     pub metadata: NodeMetadata,
     pub relative_path: PathBuf,
+    pub(crate) body: Arc<str>,
+    pub(crate) summary: String,
+    pub(crate) wikilinks: Vec<String>,
 }
 
 impl NodeIndexEntry {
     pub fn id(&self) -> &str {
         &self.metadata.id
     }
+
+    pub(crate) fn body(&self) -> &str {
+        &self.body
+    }
 }
 
 /// In-memory index of markdown nodes under a graph root.
@@ -99,7 +108,7 @@ impl GraphIndex {
             }
 
             let node = Node::from_file(path, &self.root_path)?;
-            self.insert_entry(node.metadata, relative_path.to_path_buf())?;
+            self.insert_entry(node.metadata, relative_path.to_path_buf(), node.body)?;
         }
 
         Ok(())
@@ -158,17 +167,28 @@ impl GraphIndex {
             return Ok(None);
         }
 
-        if let Some(existing_id) = self.by_path.remove(&relative_path) {
-            self.by_id.remove(&existing_id);
-        }
-
         if !full_path.exists() {
+            if let Some(existing_id) = self.by_path.remove(&relative_path) {
+                self.by_id.remove(&existing_id);
+            }
             return Ok(None);
         }
 
         let node = Node::from_file(&full_path, &self.root_path)?;
         let id = node.id().to_string();
-        self.insert_entry(node.metadata, relative_path)?;
+        if let Some(existing) = self.by_id.get(&id) {
+            if existing.relative_path != relative_path {
+                return Err(MagGraphError::DuplicateNodeId {
+                    id,
+                    first: existing.relative_path.clone(),
+                    second: relative_path,
+                });
+            }
+        }
+        if let Some(existing_id) = self.by_path.remove(&relative_path) {
+            self.by_id.remove(&existing_id);
+        }
+        self.insert_entry(node.metadata, relative_path, node.body)?;
         Ok(Some(id))
     }
 
@@ -260,7 +280,11 @@ impl GraphIndex {
         }
 
         node.write_to(&self.root_path)?;
-        self.insert_entry(node.metadata.clone(), node.relative_path.clone())?;
+        self.insert_entry(
+            node.metadata.clone(),
+            node.relative_path.clone(),
+            node.body.clone(),
+        )?;
         Ok(node)
     }
 
@@ -298,6 +322,9 @@ impl GraphIndex {
             NodeIndexEntry {
                 metadata: node.metadata,
                 relative_path: node.relative_path,
+                summary: crate::query::summarize_text(&node.body),
+                wikilinks: extract_wikilink_targets(&node.body),
+                body: Arc::from(node.body),
             },
         );
         Ok(())
@@ -317,16 +344,18 @@ impl GraphIndex {
     fn delete_node_unchecked(&mut self, id: &str) -> Result<()> {
         let entry = self
             .by_id
-            .remove(id)
+            .get(id)
+            .cloned()
             .ok_or_else(|| MagGraphError::NodeNotFound { id: id.to_string() })?;
 
-        self.by_path.remove(&entry.relative_path);
-
         let path = self.root_path.join(&entry.relative_path);
         if path.exists() {
             fs::remove_file(&path).map_err(|source| MagGraphError::NodeDelete { path, source })?;
         }
 
+        self.by_id.remove(id);
+        self.by_path.remove(&entry.relative_path);
+
         Ok(())
     }
 
@@ -362,28 +391,55 @@ impl GraphIndex {
         }
         let mut target = self.read_node(target_id)?;
         let source = self.read_node(source_id)?;
-        if !target.body.ends_with('\n') {
-            target.body.push('\n');
+        let source_value = serde_yaml::Value::String(source_id.to_string());
+        let already_merged = target
+            .metadata
+            .extra
+            .get("merged_from")
+            .and_then(serde_yaml::Value::as_sequence)
+            .is_some_and(|values| values.contains(&source_value));
+        if !already_merged {
+            if !target.body.ends_with('\n') {
+                target.body.push('\n');
+            }
+            target.body.push_str(&format!(
+                "\n---\n\n## Merged from `{}`\n\n{}",
+                source.id(),
+                source.body
+            ));
+            for link in source.metadata.links {
+                if link != target_id && !target.metadata.links.contains(&link) {
+                    target.metadata.links.push(link);
+                }
+            }
         }
-        target.body.push_str(&format!(
-            "\n---\n\n## Merged from `{}`\n\n{}",
-            source.id(),
-            source.body
-        ));
-        for link in source.metadata.links {
-            if link != target_id && !target.metadata.links.contains(&link) {
-                target.metadata.links.push(link);
+        let merged_from = target
+            .metadata
+            .extra
+            .entry("merged_from".to_string())
+            .or_insert_with(|| serde_yaml::Value::Sequence(Vec::new()));
+        let provenance = match merged_from {
+            serde_yaml::Value::Sequence(values) => values,
+            _ => {
+                *merged_from = serde_yaml::Value::Sequence(Vec::new());
+                merged_from
+                    .as_sequence_mut()
+                    .expect("sequence inserted above")
             }
+        };
+        if !provenance.contains(&source_value) {
+            provenance.push(source_value);
         }
-        target.metadata.extra.insert(
-            "merged_from".to_string(),
-            serde_yaml::Value::Sequence(vec![serde_yaml::Value::String(source_id.to_string())]),
-        );
         self.update_node(target)?;
         self.delete_node(source_id)
     }
 
-    fn insert_entry(&mut self, metadata: NodeMetadata, relative_path: PathBuf) -> Result<()> {
+    fn insert_entry(
+        &mut self,
+        metadata: NodeMetadata,
+        relative_path: PathBuf,
+        body: String,
+    ) -> Result<()> {
         let id = metadata.id.clone();
 
         if let Some(existing) = self.by_id.get(&id) {
@@ -406,6 +462,9 @@ impl GraphIndex {
             NodeIndexEntry {
                 metadata,
                 relative_path: relative_path.clone(),
+                summary: crate::query::summarize_text(&body),
+                wikilinks: extract_wikilink_targets(&body),
+                body: Arc::from(body),
             },
         );
         self.by_path.insert(relative_path, id);
@@ -677,4 +736,123 @@ tags: ["agent"]
         assert!(index.contains("fresh"));
         assert!(!index.changed_since(0).is_empty());
     }
+
+    #[test]
+    fn malformed_incremental_update_keeps_last_valid_index_state() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        write_example_graph(&root);
+        let mut index = GraphIndex::open(&root).expect("open index");
+
+        fs::write(root.join("welcome.md"), "# truncated without frontmatter")
+            .expect("write malformed external edit");
+        index
+            .update_file("welcome.md")
+            .expect_err("malformed update should fail");
+
+        assert!(index.contains("welcome"));
+        let results = index
+            .search(&QueryOptions {
+                text: Some("Welcome".into()),
+                ..QueryOptions::default()
+            })
+            .expect("cached index remains searchable");
+        assert_eq!(results[0].id, "welcome");
+    }
+
+    #[test]
+    fn failed_disk_delete_keeps_index_entry() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        write_example_graph(&root);
+        let mut index = GraphIndex::open(&root).expect("open index");
+        let path = root.join("getting_started.md");
+
+        fs::remove_file(&path).expect("remove fixture file");
+        fs::create_dir(&path).expect("replace file with directory");
+        let error = index
+            .delete_node("getting_started")
+            .expect_err("directory cannot be removed as a file");
+
+        assert!(error.to_string().contains("delete"));
+        assert!(index.contains("getting_started"));
+        assert_eq!(
+            index.get("getting_started").unwrap().relative_path,
+            PathBuf::from("getting_started.md")
+        );
+    }
+
+    #[test]
+    fn repeated_merges_preserve_all_provenance() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        write_example_graph(&root);
+        let mut index = GraphIndex::open(&root).expect("open index");
+        index
+            .create_node(NewNode {
+                metadata: NodeMetadata {
+                    id: "third".into(),
+                    node_type: "note".into(),
+                    source: None,
+                    links: vec![],
+                    extra: Default::default(),
+                },
+                body: "Third body\n".into(),
+                relative_path: PathBuf::from("third.md"),
+            })
+            .expect("create third node");
+
+        index
+            .merge_nodes("welcome", "getting_started")
+            .expect("first merge");
+        index.merge_nodes("welcome", "third").expect("second merge");
+
+        let merged = index.read_node("welcome").expect("merged target");
+        let provenance = merged
+            .metadata
+            .extra
+            .get("merged_from")
+            .and_then(serde_yaml::Value::as_sequence)
+            .expect("merged_from sequence");
+        assert_eq!(
+            provenance,
+            &vec![
+                serde_yaml::Value::String("getting_started".into()),
+                serde_yaml::Value::String("third".into()),
+            ]
+        );
+    }
+
+    #[test]
+    fn merge_retry_does_not_duplicate_already_recorded_source() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        write_example_graph(&root);
+        let mut index = GraphIndex::open(&root).expect("open index");
+        let source_body = index.read_node("getting_started").expect("source").body;
+        let mut target = index.read_node("welcome").expect("target");
+        target.body.push_str(&format!(
+            "\n---\n\n## Merged from `getting_started`\n\n{source_body}"
+        ));
+        target.metadata.extra.insert(
+            "merged_from".into(),
+            serde_yaml::Value::Sequence(vec![serde_yaml::Value::String("getting_started".into())]),
+        );
+        index
+            .update_node(target)
+            .expect("record interrupted merge state");
+
+        index
+            .merge_nodes("welcome", "getting_started")
+            .expect("retry merge");
+        let merged = index.read_node("welcome").expect("merged target");
+        assert_eq!(
+            merged
+                .body
+                .matches("## Merged from `getting_started`")
+                .count(),
+            1
+        );
+        assert!(!index.contains("getting_started"));
+    }
 }

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/src/node/mod.rs

@@ -2,6 +2,7 @@ mod frontmatter;
 
 use std::collections::BTreeMap;
 use std::fs;
+use std::io::Write;
 use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
@@ -93,7 +94,26 @@ impl Node {
         }
 
         let contents = self.to_markdown()?;
-        fs::write(&path, contents).map_err(|source| MagGraphError::NodeWrite { path, source })
+        let mut pending =
+            tempfile::NamedTempFile::new_in(path.parent().unwrap_or_else(|| Path::new(".")))
+                .map_err(|source| MagGraphError::NodeWrite {
+                    path: path.clone(),
+                    source,
+                })?;
+        pending
+            .write_all(contents.as_bytes())
+            .and_then(|_| pending.as_file().sync_all())
+            .map_err(|source| MagGraphError::NodeWrite {
+                path: path.clone(),
+                source,
+            })?;
+        pending
+            .persist(&path)
+            .map_err(|error| MagGraphError::NodeWrite {
+                path,
+                source: error.error,
+            })?;
+        Ok(())
     }
 
     pub fn id(&self) -> &str {
@@ -228,6 +248,37 @@ links: ["getting_started"]
         assert_eq!(reloaded, node);
     }
 
+    #[test]
+    fn atomic_replacement_ignores_orphaned_pending_files() {
+        let temp = TempDir::new().expect("temp dir");
+        let root = temp.path().join("graph");
+        fs::create_dir_all(&root).expect("create root");
+
+        let mut node = Node {
+            metadata: NodeMetadata {
+                id: "durable".into(),
+                node_type: "note".into(),
+                source: None,
+                links: vec![],
+                extra: BTreeMap::new(),
+            },
+            body: "original\n".into(),
+            relative_path: PathBuf::from("durable.md"),
+        };
+        node.write_to(&root).expect("initial write");
+
+        fs::write(root.join(".tmp-interrupted-write"), "partial").expect("orphan temp");
+        node.body = "replacement\n".into();
+        node.write_to(&root).expect("atomic replacement");
+
+        let reloaded = Node::from_file(root.join("durable.md"), &root).expect("reload");
+        assert_eq!(reloaded.body, "replacement\n");
+        assert_eq!(
+            fs::read_to_string(root.join(".tmp-interrupted-write")).unwrap(),
+            "partial"
+        );
+    }
+
     #[test]
     fn rejects_missing_frontmatter() {
         let err = parse_markdown_node("# No frontmatter", Path::new("x.md")).expect_err("error");

{maggraph-0.2.5 → maggraph-0.3.0}/maggraph/src/query.rs

@@ -63,7 +63,6 @@ pub fn search_index(index: &GraphIndex, options: &QueryOptions) -> Result<Vec<Se
             }
         }
 
-        let node = index.read_node(id)?;
         let mut score = 0;
         let mut matched = Vec::new();
         if needle.is_empty() {
@@ -72,7 +71,7 @@ pub fn search_index(index: &GraphIndex, options: &QueryOptions) -> Result<Vec<Se
         } else {
             score += score_text(id, &needle, 30, "id", &mut matched);
             score += score_text(&entry.metadata.node_type, &needle, 12, "type", &mut matched);
-            score += score_text(&node.body, &needle, 6, "body", &mut matched);
+            score += score_text(entry.body(), &needle, 6, "body", &mut matched);
             for link in &entry.metadata.links {
                 score += score_text(link, &needle, 10, "links", &mut matched);
             }
@@ -98,7 +97,7 @@ pub fn search_index(index: &GraphIndex, options: &QueryOptions) -> Result<Vec<Se
             relative_path: entry.relative_path.display().to_string(),
             score,
             matched,
-            summary: summarize_body(&node),
+            summary: entry.summary.clone(),
             modified_unix,
         });
     }
@@ -139,8 +138,11 @@ pub fn is_suppressed(node: &Node) -> bool {
 }
 
 pub fn summarize_body(node: &Node) -> String {
-    node.body
-        .lines()
+    summarize_text(&node.body)
+}
+
+pub(crate) fn summarize_text(body: &str) -> String {
+    body.lines()
         .filter(|line| !line.trim().is_empty())
         .take(3)
         .collect::<Vec<_>>()

{maggraph-0.2.5 → maggraph-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "maggraph"
-version = "0.2.5"
+version = "0.3.0"
 description = "In-process graph engine for AI semantic layers — powered by Rust"
 readme = "README.md"
 requires-python = ">=3.9"